Language.Embedded.Imperative.CMD

Imperative commands. These commands can be used with the Program monad, and different command types can be combined using (:+:).

These commands are general imperative constructs independent of the back end, except for C_CMD which is C-specific.

References

data Ref a

Mutable reference

Constructors

RefComp VarId

RefEval (IORef a)

Instances

ToIdent (Ref a)

Assignable (Ref a)

data RefCMD fs a where

Commands for mutable references

Constructors

NewRef :: pred a => String -> RefCMD (Param3 prog exp pred) (Ref a)

InitRef :: pred a => String -> exp a -> RefCMD (Param3 prog exp pred) (Ref a)

GetRef :: pred a => Ref a -> RefCMD (Param3 prog exp pred) (Val a)

SetRef :: pred a => Ref a -> exp a -> RefCMD (Param3 prog exp pred) ()

UnsafeFreezeRef :: pred a => Ref a -> RefCMD (Param3 prog exp pred) (Val a)

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 (* -> *))

Arrays

data Arr i a

Mutable array

Constructors

ArrComp VarId

ArrEval (IORef (IOArray i a))

Instances

ToIdent (Arr i a)

Assignable (Arr i a)

IsPointer (Arr i a)

data IArr i a

Immutable array

Constructors

IArrComp VarId

IArrEval (Array i a)

Instances

ToIdent (IArr i a)

Assignable (IArr i a)

data ArrCMD fs a where

Commands for mutable arrays

Constructors

NewArr :: (pred a, Integral i, Ix i) => String -> exp i -> ArrCMD (Param3 prog exp pred) (Arr i a)

InitArr :: (pred a, Integral i, Ix i) => String -> [a] -> ArrCMD (Param3 prog exp pred) (Arr i a)

GetArr :: (pred a, Integral i, Ix i) => exp i -> Arr i a -> ArrCMD (Param3 prog exp pred) (Val a)

SetArr :: (pred a, Integral i, Ix i) => exp i -> exp a -> Arr i a -> ArrCMD (Param3 prog exp pred) ()

CopyArr :: (pred a, Integral i, Ix i) => Arr i a -> Arr i a -> exp i -> ArrCMD (Param3 prog exp pred) ()

UnsafeFreezeArr :: (pred a, Integral i, Ix i) => Arr i a -> ArrCMD (Param3 prog exp pred) (IArr i a)

UnsafeThawArr :: (pred a, Integral i, Ix i) => IArr i a -> ArrCMD (Param3 prog exp pred) (Arr i a)

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 (* -> *))

Control flow

data Border i

Constructors

Incl i

Excl i

Instances

Functor Border

Foldable Border

Traversable Border

Eq i => Eq (Border i)

Num i => Num (Border i)

fromInteger gives an inclusive border. No other methods defined.

Show i => Show (Border i)

borderVal :: Border i -> i

borderIncl :: Border i -> Bool

type IxRange i = (i, Int, Border i)

Index range

(lo,step,hi)

lo gives the start index; step gives the step length; hi gives the stop index which may be inclusive or exclusive.

data ControlCMD fs a where

Constructors

If :: exp Bool -> prog () -> prog () -> ControlCMD (Param3 prog exp pred) ()

While :: prog (exp Bool) -> prog () -> ControlCMD (Param3 prog exp pred) ()

For :: (pred i, Integral i) => IxRange (exp i) -> (Val i -> prog ()) -> ControlCMD (Param3 prog exp pred) ()

Break :: ControlCMD (Param3 prog exp pred) ()

Assert :: exp Bool -> String -> ControlCMD (Param3 prog exp pred) ()

Instances

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

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

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

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

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

Pointers

class ToIdent a => IsPointer a where

Types that are represented as a pointers in C

Methods

runSwapPtr :: a -> a -> IO ()

Instances

IsPointer (Arr i a)

data PtrCMD fs a where

Constructors

SwapPtr :: IsPointer a => a -> a -> PtrCMD (Param3 prog exp pred) ()

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)

File handling

data Handle

File handle

Constructors

HandleComp VarId

HandleEval Handle

Instances

ToIdent Handle

stdin :: Handle

Handle to stdin

stdout :: Handle

Handle to stdout

data PrintfArg exp where

Constructors

PrintfArg :: PrintfArg a => exp a -> PrintfArg exp

mapPrintfArg :: (forall a. exp1 a -> exp2 a) -> PrintfArg exp1 -> PrintfArg exp2

mapPrintfArgM :: Monad m => (forall a. exp1 a -> m (exp2 a)) -> PrintfArg exp1 -> m (PrintfArg exp2)

class (Typeable a, Read a, PrintfArg a) => Formattable a where

Values that can be printed/scanned using printf/scanf

Methods

formatSpecifier :: Proxy a -> String

Instances

Formattable Double

Formattable Float

Formattable Int

Formattable Int8

Formattable Int16

Formattable Int32

Formattable Int64

Formattable Word

Formattable Word8

Formattable Word16

Formattable Word32

Formattable Word64

data FileCMD fs a where

Constructors

FOpen :: FilePath -> IOMode -> FileCMD (Param3 prog exp pred) Handle

FClose :: Handle -> FileCMD (Param3 prog exp pred) ()

FEof :: Handle -> FileCMD (Param3 prog exp pred) (Val Bool)

FPrintf :: Handle -> String -> [PrintfArg exp] -> FileCMD (Param3 prog exp pred) ()

FGet :: (pred a, Formattable a) => Handle -> FileCMD (Param3 prog exp pred) (Val 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 (* -> *))

C-specific commands

newtype Ptr a

Pointer

Constructors

PtrComp

Fields

ptrId :: VarId

Instances

ToIdent (Ptr a)

Assignable (Ptr a)

data Object

Abstract object

Constructors

Object

Fields

pointed :: Bool

objectType :: String

objectId :: VarId

Instances

Eq Object

Ord Object

Show Object

ToIdent Object

Assignable Object

class Arg arg pred where

Methods

mkArg :: arg pred -> CGen Exp

mkParam :: arg pred -> CGen Param

Instances

Arg k (StrArg k) pred

Arg k (ObjArg k) pred

Arg (* -> Constraint) PtrArg CType

Arg (* -> Constraint) IArrArg CType

Arg (* -> Constraint) ArrArg CType

Arg (* -> Constraint) RefArg CType

CompExp exp => Arg (* -> Constraint) (FunArg * exp) CType

data FunArg exp pred where

Constructors

ValArg :: pred a => exp a -> FunArg exp pred

AddrArg :: FunArg exp pred -> FunArg exp pred

DerefArg :: FunArg exp pred -> FunArg exp pred

FunArg :: Arg arg pred => arg pred -> FunArg exp pred

Instances

CompExp exp => Arg (* -> Constraint) (FunArg * exp) CType

mapFunArg :: (forall a. exp1 a -> exp2 a) -> FunArg exp1 pred -> FunArg exp2 pred

mapFunArgM :: Monad m => (forall a. exp1 a -> m (exp2 a)) -> FunArg exp1 pred -> m (FunArg exp2 pred)

class ToIdent obj => Assignable obj

Instances

Assignable Object

Assignable (Ptr a)

Assignable (Ref a)

Assignable (IArr i a)

Assignable (Arr i a)

data C_CMD fs a where

Constructors

NewPtr :: pred a => String -> C_CMD (Param3 prog exp pred) (Ptr a)

PtrToArr :: Ptr a -> C_CMD (Param3 prog exp pred) (Arr i a)

NewObject :: String -> String -> Bool -> C_CMD (Param3 prog exp pred) Object

AddInclude :: String -> C_CMD (Param3 prog exp pred) ()

AddDefinition :: Definition -> C_CMD (Param3 prog exp pred) ()

AddExternFun :: pred res => String -> proxy res -> [FunArg exp pred] -> C_CMD (Param3 prog exp pred) ()

AddExternProc :: String -> [FunArg exp pred] -> C_CMD (Param3 prog exp pred) ()

CallFun :: pred a => String -> [FunArg exp pred] -> C_CMD (Param3 prog exp pred) (Val a)

CallProc :: Assignable obj => Maybe obj -> String -> [FunArg exp pred] -> C_CMD (Param3 prog exp pred) ()

InModule :: String -> prog () -> C_CMD (Param3 prog exp pred) ()

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)