Elvecent

import { createContext, useContext, useReducer } from "react";
import * as React from "react";
import { render } from "react-dom";

// <LibraryCode>
const StateContext: React.Context<[any, React.Dispatch<any>]> = createContext(
  undefined
);

function StateProvider<S, A>({

Elvecent

{-# LANGUAGE TypeApplications, DataKinds, KindSignatures, TypeFamilies, MultiParamTypeClasses, FunctionalDependencies, UndecidableInstances #-}

module Main where

import Data.Functor.Compose
import Data.Functor.Identity
import Data.Coerce

data Nat = Zero | Succ Nat

Elvecent

module Utils.Concurrent (mkPipeline, launchNukes) where

import           Control.Concurrent       (threadDelay)
import           Control.Concurrent.Async (Async, async, cancel, wait)
import           Control.Concurrent.STM   (TBQueue, atomically, newTBQueueIO,
                                           readTBQueue, writeTBQueue)
import           Control.Monad            (forever, void)
import           Control.Monad.IO.Class   (MonadIO, liftIO)
import           GHC.Natural              (Natural)

Elvecent

{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeOperators         #-}
{-# LANGUAGE TypeSynonymInstances  #-}


module Main where

Elvecent

-- packages "free" and "transformers" assumed

{-# LANGUAGE DeriveFunctor #-}

module Main where

import Control.Monad.Trans.Free
import Control.Monad.Trans.Class

data CoroutineF a = Yield a 

Elvecent

{-# Language DeriveFunctor #-}

module Parser where

newtype Parser a = Parser { parse :: String -> [(a, String)] }
  deriving Functor

parserBind :: Parser a -> (a -> Parser b) -> Parser b
parserBind (Parser p) mf = Parser $ \s ->
  p s >>= (\(x,s) -> parse (mf x) s)

Elvecent

import 'package:flutter/material.dart';
import 'func.dart';

class Message {
  Message(this.text, this.isMe);

  String text;
  bool isMe;
}

Elvecent

Minimal Haskell Emacs configuration, from scratch

This little instruction shows how to set up Emacs with some packages to start writing Haskell in a more or less convenient way (including, but not limited to: smart auto completion, type info, autoformatting).

Get emacs

First step: get Emacs for your platform. This should be simple.

Find your init file

That's usually ~/.emacs on unix-like systems. ~ stands for "home folder" and on Windows it's usually AppData\Roaming. Check this out.

Set up MELPA

Elvecent

{-# Language GADTs,
DataKinds,
KindSignatures,
StandaloneDeriving,
DeriveFunctor,
TypeFamilies
#-}

import Data.Function

Elvecent

{-# Language TypeSynonymInstances
, FlexibleInstances
, MultiParamTypeClasses
, KindSignatures
, GADTs
, DataKinds
, TypeFamilies
, AllowAmbiguousTypes
, TypeApplications
#-}