Language.Embedded.Imperative

Deep embedding of imperative programs with code generation. This is the main module for users who want to write imperative programs.

The Program type is parameterized by an instruction set that can be combined in a modular way; e.g:

type MyProg exp a = Program (RefCMD exp :+: FileCMD exp) a

Also, instructions are parameterized on the expression language. In the above example, exp can be any type (of kind * -> *) that implements the EvalExp and CompExp classes.

Some examples of using the library are found in the examples directory.

Documentation

module Control.Monad

module Data.Int

module Data.Word

Program monad

data ProgramT instr m a :: ((* -> *) -> * -> *) -> (* -> *) -> * -> *

Representation of programs parameterized by the primitive instructions

Instances

MonadTrans (ProgramT instr)

Monad m => Monad (ProgramT instr m)

Monad m => Functor (ProgramT instr m)

Monad m => Applicative (ProgramT instr m)

((:<:) (* -> *) * (FileCMD (IExp instr)) instr, (~) * a ()) => PrintfType (ProgramT instr m a)

type PrintfExp (ProgramT instr m a) = IExp instr

type Program instr = ProgramT instr Identity

Representation of programs parameterized by its primitive instructions

interpretT :: (Interp i m, HFunctor * * i, Monad m) => (forall b. n b -> m b) -> ProgramT i n a -> m a

Interpret a program in a monad. The interpretation of primitive instructions is provided by the Interp class.

interpret :: (Interp i m, HFunctor * * i, Monad m) => Program i a -> m a

Interpret a program in a monad. The interpretation of primitive instructions is provided by the Interp class.

Imperative instructions

data RefCMD exp prog a

Commands for mutable references

Instances

HFunctor * * (RefCMD exp)

CompExp exp => DryInterp (RefCMD exp)

EvalExp exp => Interp (RefCMD exp) IO

type IExp (RefCMD e) = e

type IExp ((:+:) (* -> *) * (RefCMD e) i) = e

data ArrCMD exp prog a

Commands for mutable arrays

Instances

HFunctor * * (ArrCMD exp)

CompExp exp => DryInterp (ArrCMD exp)

EvalExp exp => Interp (ArrCMD exp) IO

type IExp (ArrCMD e) = e

type IExp ((:+:) (* -> *) * (ArrCMD e) i) = e

data ControlCMD exp prog a

Instances

HFunctor * * (ControlCMD exp)

DryInterp (ControlCMD exp)

EvalExp exp => Interp (ControlCMD exp) IO

type IExp (ControlCMD e) = e

type IExp ((:+:) (* -> *) * (ControlCMD e) i) = e

data FileCMD exp prog a

Instances

HFunctor * * (FileCMD exp)

CompExp exp => DryInterp (FileCMD exp)

EvalExp exp => Interp (FileCMD exp) IO

type IExp (FileCMD e) = e

type IExp ((:+:) (* -> *) * (FileCMD e) i) = e

data CallCMD exp prog a

Instances

HFunctor * * (CallCMD exp)

CompExp exp => DryInterp (CallCMD exp)

EvalExp exp => Interp (CallCMD exp) IO

type IExp (CallCMD e) = e

type IExp ((:+:) (* -> *) * (CallCMD e) i) = e

Types of Printf arguments

data PrintfArg exp

Composing instruction sets

data (f :+: g) a b :: (k -> k1 -> *) -> (k -> k1 -> *) -> k -> k1 -> * infixr 9

Coproducts

Instances

(:<:) k k1 f ((:+:) k k1 f g)

(:<:) k k1 f h => (:<:) k k1 f ((:+:) k k1 g h)

(HFunctor k k1 h1, HFunctor k k1 h2) => HFunctor k k1 ((:+:) (k -> *) k1 h1 h2)

(DryInterp i1, DryInterp i2) => DryInterp ((:+:) (* -> *) * i1 i2)

(Interp i1 m, Interp i2 m) => Interp ((:+:) (* -> *) * i1 i2) m

(Functor (f a), Functor (g a)) => Functor ((:+:) k * f g a)

type IExp ((:+:) (* -> *) * (ChanCMD e) i) = e

type IExp ((:+:) (* -> *) * ThreadCMD i) = IExp i

type IExp ((:+:) (* -> *) * (CallCMD e) i) = e

type IExp ((:+:) (* -> *) * (ObjectCMD e) i) = e

type IExp ((:+:) (* -> *) * (FileCMD e) i) = e

type IExp ((:+:) (* -> *) * (ControlCMD e) i) = e

type IExp ((:+:) (* -> *) * (ArrCMD e) i) = e

type IExp ((:+:) (* -> *) * (RefCMD e) i) = e

class f :<: g

A constraint f :<: g expresses that the signature f is subsumed by g, i.e. f can be used to construct elements in g.

Minimal complete definition

inj, prj

Instances

(:<:) k k1 f f

(:<:) k k1 f ((:+:) k k1 f g)

(:<:) k k1 f h => (:<:) k k1 f ((:+:) k k1 g h)

type family IExp i :: * -> *

Extract the expression type from an instruction set

IExp is needed to avoid types like (SomeInstr exp :<: i) => Program i (). Here it is not possible to constrain exp by constraining i, so the instance search will always fail. Functions like injE solve this by using IExp to determine exp from i. For this to work, one must use an instruction set i that has an instance of IExp.

It is common for all instructions in a sum (using :+:) to use the same expression type. For this common case, it is enough to get the expression type from the first summand. This can be achieved by giving two IExp instances for each instruction:

type instance IExp (SomeInstr exp)       = exp
type instance IExp (SomeInstr exp :+: i) = exp

Instances

type IExp (ChanCMD e) = e

type IExp (CallCMD e) = e

type IExp (ObjectCMD e) = e

type IExp (FileCMD e) = e

type IExp (ControlCMD e) = e

type IExp (ArrCMD e) = e

type IExp (RefCMD e) = e

type IExp ((:+:) (* -> *) * (ChanCMD e) i) = e

type IExp ((:+:) (* -> *) * ThreadCMD i) = IExp i

type IExp ((:+:) (* -> *) * (CallCMD e) i) = e

type IExp ((:+:) (* -> *) * (ObjectCMD e) i) = e

type IExp ((:+:) (* -> *) * (FileCMD e) i) = e

type IExp ((:+:) (* -> *) * (ControlCMD e) i) = e

type IExp ((:+:) (* -> *) * (ArrCMD e) i) = e

type IExp ((:+:) (* -> *) * (RefCMD e) i) = e

Interpreting expressions

type family VarPred exp :: * -> Constraint

Constraint on the types of variables in a given expression language

Instances

type VarPred CExp = CType

class EvalExp exp

General interface for evaluating expressions

Minimal complete definition

litExp, evalExp

Instances

EvalExp CExp

class CompExp exp

General interface for compiling expressions

Minimal complete definition

varExp, compExp, (compType | compTypeP | compTypePP | compTypePP2)

Instances

CompExp CExp

Front end

module Language.Embedded.Imperative.Frontend.General

module Language.Embedded.Imperative.Frontend