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

RefRun (IORef a)

Instances

Eq (Ref a)

Methods

(==) :: Ref a -> Ref a -> Bool

(/=) :: Ref a -> Ref a -> Bool

ToIdent (Ref a)

Methods

toIdent :: Ref a -> SrcLoc -> Id

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 * k1 (* -> *, (* -> Constraint, *)) (RefCMD (k1 -> *))

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (RefCMD (* -> *) -> *, instr) instr ((RefCMD (* -> *) -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (RefCMD (* -> *) -> *, instr)) (ReaderT * env (ProgramT (RefCMD (* -> *) -> *, instr) instr ((RefCMD (* -> *) -> *, instr) exp2 fs) m)) ((RefCMD (* -> *) -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (RefCMD (* -> *) -> *, instr) instr ((RefCMD (* -> *) -> *, instr) exp2 fs) m) a

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

Methods

interpBi :: Param1 (* -> Constraint) pred ((RefCMD (* -> *) -> *, (RefCMD (* -> *) -> *, IO)) m ((RefCMD (* -> *) -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, RefCMD (* -> *)) m fs) a -> m a

Arrays

data Arr i a

Mutable array

Constructors

ArrComp VarId

ArrRun (IORef (IOArray i a))

Instances

Eq (Arr i a)

Methods

(==) :: Arr i a -> Arr i a -> Bool

(/=) :: Arr i a -> Arr i a -> Bool

ToIdent (Arr i a)

Methods

toIdent :: Arr i a -> SrcLoc -> Id

Assignable (Arr i a)

IsPointer (Arr i a)

Methods

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

data IArr i a

Immutable array

Constructors

IArrComp VarId

IArrRun (Array i a)

Instances

(Show a, Show i, Ix i) => Show (IArr i a)

Methods

showsPrec :: Int -> IArr i a -> ShowS

show :: IArr i a -> String

showList :: [IArr i a] -> ShowS

ToIdent (IArr i a)

Methods

toIdent :: IArr i a -> SrcLoc -> Id

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)

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

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

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

CopyArr :: (pred a, Integral i, Ix i) => (Arr i a, exp i) -> (Arr i a, exp i) -> 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 * k1 (* -> *, (* -> Constraint, *)) (ArrCMD (k1 -> *))

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (ArrCMD (* -> *) -> *, instr) instr ((ArrCMD (* -> *) -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (ArrCMD (* -> *) -> *, instr)) (ReaderT * env (ProgramT (ArrCMD (* -> *) -> *, instr) instr ((ArrCMD (* -> *) -> *, instr) exp2 fs) m)) ((ArrCMD (* -> *) -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (ArrCMD (* -> *) -> *, instr) instr ((ArrCMD (* -> *) -> *, instr) exp2 fs) m) a

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

Methods

interpBi :: Param1 (* -> Constraint) pred ((ArrCMD (* -> *) -> *, (ArrCMD (* -> *) -> *, IO)) m ((ArrCMD (* -> *) -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, ArrCMD (* -> *)) m fs) a -> m a

Control flow

data Border i

Constructors

Incl i

Excl i

Instances

Functor Border

Methods

fmap :: (a -> b) -> Border a -> Border b

(<$) :: a -> Border b -> Border a

Foldable Border

Methods

fold :: Monoid m => Border m -> m

foldMap :: Monoid m => (a -> m) -> Border a -> m

foldr :: (a -> b -> b) -> b -> Border a -> b

foldr' :: (a -> b -> b) -> b -> Border a -> b

foldl :: (b -> a -> b) -> b -> Border a -> b

foldl' :: (b -> a -> b) -> b -> Border a -> b

foldr1 :: (a -> a -> a) -> Border a -> a

foldl1 :: (a -> a -> a) -> Border a -> a

toList :: Border a -> [a]

null :: Border a -> Bool

length :: Border a -> Int

elem :: Eq a => a -> Border a -> Bool

maximum :: Ord a => Border a -> a

minimum :: Ord a => Border a -> a

sum :: Num a => Border a -> a

product :: Num a => Border a -> a

Traversable Border

Methods

traverse :: Applicative f => (a -> f b) -> Border a -> f (Border b)

sequenceA :: Applicative f => Border (f a) -> f (Border a)

mapM :: Monad m => (a -> m b) -> Border a -> m (Border b)

sequence :: Monad m => Border (m a) -> m (Border a)

Eq i => Eq (Border i)

Methods

(==) :: Border i -> Border i -> Bool

(/=) :: Border i -> Border i -> Bool

Num i => Num (Border i)

fromInteger gives an inclusive border. No other methods defined.

Methods

(+) :: Border i -> Border i -> Border i

(-) :: Border i -> Border i -> Border i

(*) :: Border i -> Border i -> Border i

negate :: Border i -> Border i

abs :: Border i -> Border i

signum :: Border i -> Border i

fromInteger :: Integer -> Border i

Show i => Show (Border i)

Methods

showsPrec :: Int -> Border i -> ShowS

show :: Border i -> String

showList :: [Border i] -> ShowS

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

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (ControlCMD -> *, instr) instr ((ControlCMD -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (ControlCMD -> *, instr)) (ReaderT * env (ProgramT (ControlCMD -> *, instr) instr ((ControlCMD -> *, instr) exp2 fs) m)) ((ControlCMD -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (ControlCMD -> *, instr) instr ((ControlCMD -> *, instr) exp2 fs) m) a

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

Methods

interpBi :: Param1 (* -> Constraint) pred ((ControlCMD -> *, (ControlCMD -> *, IO)) m ((ControlCMD -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, ControlCMD) m fs) a -> m a

Generic pointer manipulation

class ToIdent a => IsPointer a where

Types that are represented as a pointers in C

Minimal complete definition

runSwapPtr

Methods

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

Instances

IsPointer (Ptr a)

Methods

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

IsPointer (Arr i a)

Methods

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

data PtrCMD fs a where

Constructors

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

Instances

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (PtrCMD (* -> *) (k -> *) k1 -> *, instr) instr ((PtrCMD (* -> *) (k -> *) k1 -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (PtrCMD (* -> *) (k -> *) k1 -> *, instr)) (ReaderT * env (ProgramT (PtrCMD (* -> *) (k -> *) k1 -> *, instr) instr ((PtrCMD (* -> *) (k -> *) k1 -> *, instr) exp2 fs) m)) ((PtrCMD (* -> *) (k -> *) k1 -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (PtrCMD (* -> *) (k -> *) k1 -> *, instr) instr ((PtrCMD (* -> *) (k -> *) k1 -> *, instr) exp2 fs) m) a

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

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

interpBi :: Param1 k pred ((PtrCMD (* -> *) (* -> *) k -> *, (PtrCMD (* -> *) (* -> *) k -> *, IO)) m ((PtrCMD (* -> *) (* -> *) k -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, PtrCMD (* -> *) k1 k) m fs) a -> m a

File handling

data Handle

File handle

Constructors

HandleComp VarId

HandleRun Handle

Instances

Eq Handle

Methods

(==) :: Handle -> Handle -> Bool

(/=) :: Handle -> Handle -> Bool

Show Handle

Methods

showsPrec :: Int -> Handle -> ShowS

show :: Handle -> String

showList :: [Handle] -> ShowS

ToIdent Handle

Methods

toIdent :: Handle -> SrcLoc -> Id

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

Minimal complete definition

formatSpecPrint

Methods

formatSpecPrint :: Proxy a -> String

Format specifier for printf

formatSpecScan :: Proxy a -> String

Format specifier for scanf

Instances

Formattable Double

Methods

formatSpecPrint :: Proxy * Double -> String

formatSpecScan :: Proxy * Double -> String

Formattable Float

Methods

formatSpecPrint :: Proxy * Float -> String

formatSpecScan :: Proxy * Float -> String

Formattable Int

Methods

formatSpecPrint :: Proxy * Int -> String

formatSpecScan :: Proxy * Int -> String

Formattable Int8

Methods

formatSpecPrint :: Proxy * Int8 -> String

formatSpecScan :: Proxy * Int8 -> String

Formattable Int16

Methods

formatSpecPrint :: Proxy * Int16 -> String

formatSpecScan :: Proxy * Int16 -> String

Formattable Int32

Methods

formatSpecPrint :: Proxy * Int32 -> String

formatSpecScan :: Proxy * Int32 -> String

Formattable Int64

Methods

formatSpecPrint :: Proxy * Int64 -> String

formatSpecScan :: Proxy * Int64 -> String

Formattable Word

Methods

formatSpecPrint :: Proxy * Word -> String

formatSpecScan :: Proxy * Word -> String

Formattable Word8

Methods

formatSpecPrint :: Proxy * Word8 -> String

formatSpecScan :: Proxy * Word8 -> String

Formattable Word16

Methods

formatSpecPrint :: Proxy * Word16 -> String

formatSpecScan :: Proxy * Word16 -> String

Formattable Word32

Methods

formatSpecPrint :: Proxy * Word32 -> String

formatSpecScan :: Proxy * Word32 -> String

Formattable Word64

Methods

formatSpecPrint :: Proxy * Word64 -> String

formatSpecScan :: Proxy * Word64 -> String

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 * k1 (* -> *, (* -> Constraint, *)) (FileCMD (k1 -> *))

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (FileCMD (* -> *) -> *, instr) instr ((FileCMD (* -> *) -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (FileCMD (* -> *) -> *, instr)) (ReaderT * env (ProgramT (FileCMD (* -> *) -> *, instr) instr ((FileCMD (* -> *) -> *, instr) exp2 fs) m)) ((FileCMD (* -> *) -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (FileCMD (* -> *) -> *, instr) instr ((FileCMD (* -> *) -> *, instr) exp2 fs) m) a

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

Methods

interpBi :: Param1 (* -> Constraint) pred ((FileCMD (* -> *) -> *, (FileCMD (* -> *) -> *, IO)) m ((FileCMD (* -> *) -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, FileCMD (* -> *)) m fs) a -> m a

C-specific commands

newtype Ptr a

Pointer

Constructors

PtrComp

Fields

• ptrId :: VarId

Instances

Eq (Ptr a)

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Show (Ptr a)

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

ToIdent (Ptr a)

Methods

toIdent :: Ptr a -> SrcLoc -> Id

Assignable (Ptr a)

IsPointer (Ptr a)

Methods

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

data Object

Abstract object

Constructors

Object

Fields

• pointed :: Bool
• objectType :: String
• objectId :: VarId

Instances

Eq Object

Methods

(==) :: Object -> Object -> Bool

(/=) :: Object -> Object -> Bool

Show Object

Methods

showsPrec :: Int -> Object -> ShowS

show :: Object -> String

showList :: [Object] -> ShowS

ToIdent Object

Methods

toIdent :: Object -> SrcLoc -> Id

Assignable Object

class Arg arg pred where

Minimal complete definition

mkArg, mkParam

Methods

mkArg :: arg pred -> CGen Exp

mkParam :: arg pred -> CGen Param

Instances

Arg k (ConstArg k) pred

Methods

mkArg :: pred pred -> CGen Exp

mkParam :: pred pred -> CGen Param

Arg k (StrArg k) pred

Methods

mkArg :: pred pred -> CGen Exp

mkParam :: pred pred -> CGen Param

Arg k (ObjArg k) pred

Methods

mkArg :: pred pred -> CGen Exp

mkParam :: pred pred -> CGen Param

CompTypeClass ct => Arg (* -> Constraint) IArrArg ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

CompTypeClass ct => Arg (* -> Constraint) ArrArg ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

CompTypeClass ct => Arg (* -> Constraint) RefArg ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

CompTypeClass ct => Arg (* -> Constraint) PtrArg ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

(CompExp exp, CompTypeClass ct) => Arg (* -> Constraint) (FunArg * exp) ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

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

OffsetArg :: FunArg exp pred -> exp i -> FunArg exp pred

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

Instances

(CompExp exp, CompTypeClass ct) => Arg (* -> Constraint) (FunArg * exp) ct

Methods

mkArg :: ct pred -> CGen Exp

mkParam :: ct pred -> CGen Param

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

NewCArr :: (pred a, Integral i, Ix i) => String -> Maybe i -> exp i -> C_CMD (Param3 prog exp pred) (Arr i a)

ConstCArr :: (pred a, Integral i, Ix i) => String -> Maybe i -> [a] -> C_CMD (Param3 prog exp pred) (Arr i a)

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

Methods

hfmap :: (forall b. f b -> g b) -> h ((k1 -> *, k2) f fs) a -> h ((k1 -> *, k2) g fs) a

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

Methods

hbimap :: (Functor f, Functor g) => (forall b. f b -> g b) -> (forall b. i b -> j b) -> h ((* -> *, (k1 -> *, k2)) f ((k1 -> *, k2) i fs)) a -> h ((* -> *, (k1 -> *, k2)) g ((k1 -> *, k2) j fs)) a

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

Methods

reexpressInstrEnv :: Monad m => (forall b. exp1 b -> ReaderT * env (ProgramT (C_CMD -> *, instr) instr ((C_CMD -> *, instr) exp2 fs) m) (exp2 b)) -> env ((* -> *, (C_CMD -> *, instr)) (ReaderT * env (ProgramT (C_CMD -> *, instr) instr ((C_CMD -> *, instr) exp2 fs) m)) ((C_CMD -> *, instr) exp1 fs)) a -> ReaderT * env (ProgramT (C_CMD -> *, instr) instr ((C_CMD -> *, instr) exp2 fs) m) a

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

Methods

interpBi :: Param1 (* -> Constraint) pred ((C_CMD -> *, (C_CMD -> *, IO)) m ((C_CMD -> *, IO) m fs)) a -> m a

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

Methods

dryInterp :: MonadSupply m => instr ((* -> *, C_CMD) m fs) a -> m a