Language.Embedded.Imperative.Frontend

References

newRef :: (VarPred (IExp instr) a, RefCMD (IExp instr) :<: instr) => ProgramT instr m (Ref a)

Create an uninitialized reference

initRef :: (VarPred (IExp instr) a, RefCMD (IExp instr) :<: instr) => IExp instr a -> ProgramT instr m (Ref a)

Create an initialized reference

getRef :: (VarPred (IExp instr) a, RefCMD (IExp instr) :<: instr) => Ref a -> ProgramT instr m (IExp instr a)

Get the contents of a reference

setRef :: (VarPred (IExp instr) a, RefCMD (IExp instr) :<: instr) => Ref a -> IExp instr a -> ProgramT instr m ()

Set the contents of a reference

modifyRef :: (VarPred (IExp instr) a, EvalExp (IExp instr), CompExp (IExp instr), RefCMD (IExp instr) :<: instr, Monad m) => Ref a -> (IExp instr a -> IExp instr a) -> ProgramT instr m ()

Modify the contents of reference

veryUnsafeFreezeRef :: (VarPred exp a, EvalExp exp, CompExp exp) => Ref a -> exp a

Read the value of a reference without returning in the monad

WARNING: Don't use this function unless you really know what you are doing. It is almost always better to use unsafeFreezeRef instead.

veryUnsafeFreezeRef behaves predictably when doing code generation, but it can give strange results when evaluating in IO, as explained here:

http://fun-discoveries.blogspot.se/2015/09/strictness-can-fix-non-termination.html

unsafeFreezeRef :: (VarPred exp a, EvalExp exp, CompExp exp, Monad m) => Ref a -> ProgramT instr m (exp a)

Freeze the contents of reference (only safe if the reference is never written to after the freezing)

Arrays

newArr :: (pred a, pred i, Integral i, Ix i, ArrCMD (IExp instr) :<: instr, pred ~ VarPred (IExp instr)) => IExp instr i -> ProgramT instr m (Arr i a)

Create an uninitialized an array

newArr_ :: (pred a, pred i, Integral i, Ix i, ArrCMD (IExp instr) :<: instr, pred ~ VarPred (IExp instr)) => ProgramT instr m (Arr i a)

getArr :: (VarPred (IExp instr) a, ArrCMD (IExp instr) :<: instr, Integral i, Ix i) => IExp instr i -> Arr i a -> ProgramT instr m (IExp instr a)

Set the contents of an array

setArr :: (VarPred (IExp instr) a, ArrCMD (IExp instr) :<: instr, Integral i, Ix i) => IExp instr i -> IExp instr a -> Arr i a -> ProgramT instr m ()

Set the contents of an array

Control flow

iff

Arguments

:: ControlCMD (IExp instr) :<: instr

=> IExp instr Bool

Condition

-> ProgramT instr m ()

True branch

-> ProgramT instr m ()

False branch

-> ProgramT instr m ()

Conditional statement

ifE

Arguments

:: (VarPred (IExp instr) a, ControlCMD (IExp instr) :<: instr, RefCMD (IExp instr) :<: instr, Monad m)

=> IExp instr Bool

Condition

-> ProgramT instr m (IExp instr a)

True branch

-> ProgramT instr m (IExp instr a)

False branch

-> ProgramT instr m (IExp instr a)

Conditional statement that returns an expression

while

Arguments

:: ControlCMD (IExp instr) :<: instr

=> ProgramT instr m (IExp instr Bool)

Continue condition

-> ProgramT instr m ()

Loop body

-> ProgramT instr m ()

While loop

whileE

Arguments

:: (VarPred (IExp instr) a, ControlCMD (IExp instr) :<: instr, RefCMD (IExp instr) :<: instr, Monad m)

=> ProgramT instr m (IExp instr Bool)

Continue condition

-> ProgramT instr m (IExp instr a)

Loop body

-> ProgramT instr m (IExp instr a)

While loop that returns an expression

for

Arguments

:: (ControlCMD (IExp instr) :<: instr, Integral n, VarPred (IExp instr) n)

=> IExp instr n

Start index

-> IExp instr n

Stop index

-> (IExp instr n -> ProgramT instr m ())

Loop body

-> ProgramT instr m ()

For loop

forE

Arguments

:: (Integral n, VarPred (IExp instr) n, VarPred (IExp instr) a, ControlCMD (IExp instr) :<: instr, RefCMD (IExp instr) :<: instr, Monad m)

=> IExp instr n

Start index

-> IExp instr n

Stop index

-> (IExp instr n -> ProgramT instr m (IExp instr a))

Loop body

-> ProgramT instr m (IExp instr a)

For loop

break :: ControlCMD (IExp instr) :<: instr => ProgramT instr m ()

Break out from a loop

File handling

fopen :: FileCMD (IExp instr) :<: instr => FilePath -> IOMode -> ProgramT instr m Handle

Open a file

fclose :: FileCMD (IExp instr) :<: instr => Handle -> ProgramT instr m ()

Close a file

feof :: (VarPred (IExp instr) Bool, FileCMD (IExp instr) :<: instr) => Handle -> ProgramT instr m (IExp instr Bool)

Check for end of file

class PrintfType r where

Associated Types

type PrintfExp r :: * -> *

Methods

fprf :: Handle -> String -> [PrintfArg (PrintfExp r)] -> r

Instances

(Formattable a, VarPred exp a, PrintfType r, (~) (* -> *) exp (PrintfExp r)) => PrintfType (exp a -> r)

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

fprintf :: PrintfType r => Handle -> String -> r

Print to a handle. Accepts a variable number of arguments.

fput

Arguments

:: (Formattable a, VarPred (IExp instr) a, FileCMD (IExp instr) :<: instr)

=> Handle

-> String

Prefix

-> IExp instr a

Expression to print

-> String

Suffix

-> ProgramT instr m ()

Put a single value to a handle

fget :: (Formattable a, VarPred (IExp instr) a, FileCMD (IExp instr) :<: instr) => Handle -> ProgramT instr m (IExp instr a)

Get a single value from a handle

printf :: PrintfType r => String -> r

Print to stdout. Accepts a variable number of arguments.

Abstract objects

newObject

Arguments

:: ObjectCMD (IExp instr) :<: instr

=> String

Object type

-> ProgramT instr m Object

Create a pointer to an abstract object. The only thing one can do with such objects is to pass them to callFun or callProc.

initObject

Arguments

:: ObjectCMD (IExp instr) :<: instr

=> String

Function name

-> String

Object type

-> [FunArg (IExp instr)]

Arguments

-> ProgramT instr m Object

Call a function to create a pointed object

initUObject

Arguments

:: ObjectCMD (IExp instr) :<: instr

=> String

Function name

-> String

Object type

-> [FunArg (IExp instr)]

Arguments

-> ProgramT instr m Object

Call a function to create an object

External function calls (C-specific)

addInclude :: CallCMD (IExp instr) :<: instr => String -> ProgramT instr m ()

Add an #include statement to the generated code

addDefinition :: CallCMD (IExp instr) :<: instr => Definition -> ProgramT instr m ()

Add a global definition to the generated code

Can be used conveniently as follows:

{-# LANGUAGE QuasiQuotes #-}

import Language.Embedded.Imperative
import Language.C.Quote.C

prog = do
    ...
    addDefinition myCFunction
    ...
  where
    myCFunction = [cedecl|
      void my_C_function( ... )
      {
          // C code
          // goes here
      }
      |]

addExternFun

Arguments

:: (VarPred exp res, CallCMD exp :<: instr, exp ~ IExp instr)

=> String

Function name

-> proxy (exp res)

Proxy for expression and result type

-> [FunArg exp]

Arguments (only used to determine types)

-> ProgramT instr m ()

Declare an external function

addExternProc

Arguments

:: (CallCMD exp :<: instr, exp ~ IExp instr)

=> String

Procedure name

-> [FunArg exp]

Arguments (only used to determine types)

-> ProgramT instr m ()

Declare an external procedure

callFun

Arguments

:: (VarPred (IExp instr) a, CallCMD (IExp instr) :<: instr)

=> String

Function name

-> [FunArg (IExp instr)]

Arguments

-> ProgramT instr m (IExp instr a)

Call a function

callProc

Arguments

:: CallCMD (IExp instr) :<: instr

=> String

Procedure name

-> [FunArg (IExp instr)]

Arguments

-> ProgramT instr m ()

Call a procedure

externFun

Arguments

:: (VarPred exp res, CallCMD exp :<: instr, exp ~ IExp instr, Monad m)

=> String

Function name

-> [FunArg exp]

Arguments

-> ProgramT instr m (exp res)

Declare and call an external function

externProc

Arguments

:: (CallCMD exp :<: instr, exp ~ IExp instr, Monad m)

=> String

Procedure name

-> [FunArg exp]

Arguments

-> ProgramT instr m ()

Declare and call an external procedure

getTime :: (VarPred (IExp instr) Double, CallCMD (IExp instr) :<: instr, Monad m) => ProgramT instr m (IExp instr Double)

Get current time as number of seconds passed today

strArg :: String -> FunArg exp

Constant string argument

valArg :: VarPred exp a => exp a -> FunArg exp

Value argument

refArg :: VarPred exp a => Ref a -> FunArg exp

Reference argument

arrArg :: VarPred exp a => Arr n a -> FunArg exp

Array argument

objArg :: Object -> FunArg exp

Abstract object argument

addr :: FunArg exp -> FunArg exp

Modifier that takes the address of another argument

Running programs

runIO :: (Interp instr IO, HFunctor instr) => Program instr a -> IO a

Run a program in IO. Note that not all instructions are supported for running in IO. For example, calls to external C functions are not supported.