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.

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

Program monad

module Control.Monad

data ProgramT instr fs m a :: ((,) (* -> *) k -> * -> *) -> k -> (* -> *) -> * -> *

Representation of programs parameterized by the primitive instructions (transformer version)

Instances

MonadTrans (ProgramT k instr fs)

Monad m => Monad (ProgramT k instr fs m)

Monad m => Functor (ProgramT k instr fs m)

Monad m => Applicative (ProgramT k instr fs m)

((:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * (FileCMD (* -> *)) instr, (~) * a ()) => PrintfType (ProgramT ((,) (* -> *) ((,) (* -> Constraint) *)) instr (Param2 (* -> *) (* -> Constraint) exp pred) m a)

type PrintfExp (ProgramT ((,) (* -> *) ((,) (* -> Constraint) *)) instr (Param2 (* -> *) (* -> Constraint) exp pred) m a) = exp

type Program instr fs = ProgramT k instr fs Identity

Representation of programs parameterized by the primitive instructions

interpretT

Arguments

:: forall (i :: (,) (* -> *) k -> * -> *) (fs :: k) (n :: * -> *) (m :: * -> *). (Interp k * i m fs, HFunctor * * k i, Monad m)

=> (forall b. n b -> m b)

Interpretation of the underlying monad

-> ProgramT k i fs n a

-> m a

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

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

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

interpretBiT

Arguments

:: forall (i :: (,) (* -> *) ((,) (* -> *) k) -> * -> *) (exp :: * -> *) (fs :: k) (n :: * -> *) (m :: * -> *). (InterpBi k * i m fs, HBifunctor * * k i, Functor m, Monad m, Monad n)

=> (forall b. exp b -> m b)

Interpretation of the exp sub-structure

-> (forall b. n b -> m b)

Interpretation of the underlying monad

-> ProgramT ((,) (* -> *) k) i ((,) (* -> *) k exp fs) n a

-> m a

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

interpretBi

Arguments

:: forall (i :: (,) (* -> *) ((,) (* -> *) k) -> * -> *) (exp :: * -> *) (fs :: k) (m :: * -> *). (InterpBi k * i m fs, HBifunctor * * k i, Functor m, Monad m)

=> (forall b. exp b -> m b)

Interpretation of the exp sub-structure

-> Program ((,) (* -> *) k) i ((,) (* -> *) k exp fs) a

-> m a

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

type Param1 a = (,) k * a Param0

Singleton parameter list

type Param2 a b = (,) k ((,) k1 *) a (Param1 k1 b)

Two-element parameter list

type Param3 a b c = (,) k ((,) k1 ((,) k2 *)) a (Param2 k1 k2 b c)

Three-element parameter list

Imperative instructions

data RefCMD fs a

Commands for mutable references

Instances

HFunctor k * ((,) (* -> *) ((,) (* -> Constraint) *)) (RefCMD (k -> *))

HBifunctor * * ((,) (* -> Constraint) *) (RefCMD (* -> *))

(:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * (RefCMD (* -> *)) instr => Reexpressible * ((,) (* -> Constraint) *) (RefCMD (* -> *)) instr

InterpBi ((,) (* -> Constraint) *) * (RefCMD (* -> *)) IO (Param1 (* -> Constraint) pred)

DryInterp ((,) (* -> *) ((,) (* -> Constraint) *)) (RefCMD (* -> *))

data ArrCMD fs a

Commands for mutable arrays

Instances

HFunctor k * ((,) (* -> *) ((,) (* -> Constraint) *)) (ArrCMD (k -> *))

HBifunctor * * ((,) (* -> Constraint) *) (ArrCMD (* -> *))

(:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * (ArrCMD (* -> *)) instr => Reexpressible * ((,) (* -> Constraint) *) (ArrCMD (* -> *)) instr

InterpBi ((,) (* -> Constraint) *) * (ArrCMD (* -> *)) IO (Param1 (* -> Constraint) pred)

DryInterp ((,) (* -> *) ((,) (* -> Constraint) *)) (ArrCMD (* -> *))

data ControlCMD fs a

Instances

HFunctor * * ((,) (* -> *) ((,) (* -> Constraint) *)) ControlCMD

HBifunctor * * ((,) (* -> Constraint) *) ControlCMD

(:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * ControlCMD instr => Reexpressible * ((,) (* -> Constraint) *) ControlCMD instr

DryInterp ((,) (* -> *) ((,) (* -> Constraint) *)) ControlCMD

InterpBi ((,) (* -> Constraint) *) * ControlCMD IO (Param1 (* -> Constraint) pred)

data PtrCMD fs a

Instances

HFunctor k * ((,) k ((,) k *)) (PtrCMD (k -> *) k k)

HBifunctor * k ((,) k *) (PtrCMD (* -> *) (k -> *) k)

(:<:) ((,) (* -> *) ((,) (k -> *) ((,) k1 *))) * (PtrCMD (* -> *) (k -> *) k1) instr => Reexpressible k ((,) k *) (PtrCMD (* -> *) (k -> *) k) instr

InterpBi ((,) k *) * (PtrCMD (* -> *) (* -> *) k) IO (Param1 k pred)

DryInterp ((,) k ((,) k *)) (PtrCMD (* -> *) k k)

data FileCMD fs a

Instances

HFunctor k * ((,) (* -> *) ((,) (* -> Constraint) *)) (FileCMD (k -> *))

HBifunctor * * ((,) (* -> Constraint) *) (FileCMD (* -> *))

(:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * (FileCMD (* -> *)) instr => Reexpressible * ((,) (* -> Constraint) *) (FileCMD (* -> *)) instr

InterpBi ((,) (* -> Constraint) *) * (FileCMD (* -> *)) IO (Param1 (* -> Constraint) pred)

DryInterp ((,) (* -> *) ((,) (* -> Constraint) *)) (FileCMD (* -> *))

data C_CMD fs a

Instances

HFunctor * * ((,) (* -> *) ((,) (* -> Constraint) *)) C_CMD

HBifunctor * * ((,) (* -> Constraint) *) C_CMD

(:<:) ((,) (* -> *) ((,) (* -> *) ((,) (* -> Constraint) *))) * C_CMD instr => Reexpressible * ((,) (* -> Constraint) *) C_CMD instr

DryInterp ((,) (* -> *) ((,) (* -> Constraint) *)) C_CMD

InterpBi ((,) (* -> Constraint) *) * C_CMD IO (Param1 (* -> Constraint) pred)

Composing instruction sets

data (h1 :+: h2) fs a :: (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 k2 h1, HFunctor k k1 k2 h2) => HFunctor k k1 k2 ((:+:) ((,) (k -> *) k2) k1 h1 h2)

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

(Reexpressible k k1 i1 instr, Reexpressible k k1 i2 instr) => Reexpressible k k1 ((:+:) ((,) (* -> *) ((,) (k -> *) k1)) * i1 i2) instr

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

(InterpBi k k1 i1 m fs, InterpBi k k1 i2 m fs) => InterpBi k k1 ((:+:) ((,) (k1 -> *) ((,) (k1 -> *) k)) k1 i1 i2) m fs

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

(Functor (h1 fs), Functor (h2 fs)) => Functor ((:+:) k * h1 h2 fs)

class sub :<: sup

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)

Interface for expression types

class FreeExp exp

Expressions that support injection of values and named variables

Minimal complete definition

valExp, varExp

Associated Types

type VarPred exp :: * -> Constraint

Constraint on the types of values and variables in an expression language

Instances

FreeExp CExp

class FreeExp exp => EvalExp exp

Expressions that support evaluation

Minimal complete definition

evalExp

Instances

EvalExp CExp

class FreeExp exp => CompExp exp

General interface for compiling expressions

Minimal complete definition

compExp

Instances

CompExp CExp

Front end

module Data.Int

module Data.Word

module Language.Embedded.Imperative.Frontend.General

module Language.Embedded.Imperative.Frontend