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)

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

ToIdent (Ref a)

Defined in Language.Embedded.Imperative.CMD

Methods

toIdent :: Ref a -> SrcLoc -> Id

Assignable (Ref a)

Defined in Language.Embedded.Imperative.CMD

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 (RefCMD :: (k -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k1) (a :: k2). (forall (b :: k0). f b -> g b) -> RefCMD '(f, fs) a -> RefCMD '(g, fs) a

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi (RefCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) IO (Param1 pred :: (Type -> Constraint, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). RefCMD '(IO, '(IO, Param1 pred)) a -> IO a

(CompExp exp, CompTypeClass ct) => Interp (RefCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) CGen (Param2 exp ct :: (Type -> Type, (Type -> Constraint, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). RefCMD '(CGen, Param2 exp ct) a -> CGen a

HBifunctor (RefCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

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

DryInterp (RefCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => 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)

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

ToIdent (Arr i a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

Assignable (Arr i a)

Defined in Language.Embedded.Imperative.CMD

IsPointer (Arr i a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

data IArr i a

Immutable array

Constructors

IArrComp VarId

IArrRun (Array i a)

Instances

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

show :: IArr i a -> String

showList :: [IArr i a] -> ShowS

ToIdent (IArr i a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

Assignable (IArr i a)

Defined in Language.Embedded.Imperative.CMD

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 (ArrCMD :: (k -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k1) (a :: k2). (forall (b :: k0). f b -> g b) -> ArrCMD '(f, fs) a -> ArrCMD '(g, fs) a

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi (ArrCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) IO (Param1 pred :: (Type -> Constraint, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). ArrCMD '(IO, '(IO, Param1 pred)) a -> IO a

(CompExp exp, CompTypeClass ct) => Interp (ArrCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) CGen (Param2 exp ct :: (Type -> Type, (Type -> Constraint, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). ArrCMD '(CGen, Param2 exp ct) a -> CGen a

HBifunctor (ArrCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

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

DryInterp (ArrCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => ArrCMD '(m, fs) a -> m a

Control flow

data Border i

Constructors

Incl i

Excl i

Instances

Functor Border

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

Foldable Border

Defined in Language.Embedded.Imperative.CMD

Methods

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

foldMap :: Monoid m => (a -> m) -> Border a -> 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

Defined in Language.Embedded.Imperative.CMD

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)

Defined in Language.Embedded.Imperative.CMD

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.

Defined in Language.Embedded.Imperative.CMD

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)

Defined in Language.Embedded.Imperative.CMD

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

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi ControlCMD IO (Param1 pred :: (Type -> Constraint, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). ControlCMD '(IO, '(IO, Param1 pred)) a -> IO a

(CompExp exp, CompTypeClass ct) => Interp ControlCMD CGen (Param2 exp ct :: (Type -> Type, (Type -> Constraint, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). ControlCMD '(CGen, Param2 exp ct) a -> CGen a

HFunctor ControlCMD

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k1) (a :: k2). (forall (b :: k). f b -> g b) -> ControlCMD '(f, fs) a -> ControlCMD '(g, fs) a

HBifunctor ControlCMD

Defined in Language.Embedded.Imperative.CMD

Methods

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

DryInterp ControlCMD

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => ControlCMD '(m, fs) a -> m a

Generic pointer manipulation

class ToIdent a => IsPointer a where

Types that are represented as a pointers in C

Methods

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

Instances

IsPointer (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

IsPointer (Arr i a)

Defined in Language.Embedded.Imperative.CMD

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

HFunctor (PtrCMD :: (k -> Type, (k1, (k2, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k10) (a :: k20). (forall (b :: k0). f b -> g b) -> PtrCMD '(f, fs) a -> PtrCMD '(g, fs) a

HBifunctor (PtrCMD :: (Type -> Type, (k -> Type, (k2, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

hbimap :: forall f g i j (fs :: k1) (a :: k20). (Functor f, Functor g) => (forall b. f b -> g b) -> (forall (b :: k0). i b -> j b) -> PtrCMD '(f, '(i, fs)) a -> PtrCMD '(g, '(j, fs)) a

(PtrCMD :: (Type -> Type, (k -> Type, (k2, Type))) -> Type -> Type) :<: instr => Reexpressible (PtrCMD :: (Type -> Type, (k -> Type, (k2, Type))) -> Type -> Type) (instr :: (Type -> Type, (k -> Type, (k2, Type))) -> Type -> Type) env

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi (PtrCMD :: (Type -> Type, (Type -> Type, (k2, Type))) -> Type -> Type) IO (Param1 pred :: (k2, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). PtrCMD '(IO, '(IO, Param1 pred)) a -> IO a

Interp (PtrCMD :: (Type -> Type, (k1, (k2, Type))) -> Type -> Type) CGen (Param2 exp ct :: (k1, (k2, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). PtrCMD '(CGen, Param2 exp ct) a -> CGen a

DryInterp (PtrCMD :: (Type -> Type, (k1, (k2, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => PtrCMD '(m, fs) a -> m a

File handling

data Handle

File handle

Constructors

HandleComp VarId

HandleRun Handle

Instances

Eq Handle

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

Show Handle

Defined in Language.Embedded.Imperative.CMD

Methods

showsPrec :: Int -> Handle -> ShowS

show :: Handle -> String

showList :: [Handle] -> ShowS

ToIdent Handle

Defined in Language.Embedded.Imperative.CMD

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

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Double -> String

formatSpecScan :: Proxy Double -> String

Formattable Float

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Float -> String

formatSpecScan :: Proxy Float -> String

Formattable Int

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Int -> String

formatSpecScan :: Proxy Int -> String

Formattable Int8

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Int8 -> String

formatSpecScan :: Proxy Int8 -> String

Formattable Int16

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Int16 -> String

formatSpecScan :: Proxy Int16 -> String

Formattable Int32

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Int32 -> String

formatSpecScan :: Proxy Int32 -> String

Formattable Int64

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Int64 -> String

formatSpecScan :: Proxy Int64 -> String

Formattable Word

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Word -> String

formatSpecScan :: Proxy Word -> String

Formattable Word8

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Word8 -> String

formatSpecScan :: Proxy Word8 -> String

Formattable Word16

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Word16 -> String

formatSpecScan :: Proxy Word16 -> String

Formattable Word32

Defined in Language.Embedded.Imperative.CMD

Methods

formatSpecPrint :: Proxy Word32 -> String

formatSpecScan :: Proxy Word32 -> String

Formattable Word64

Defined in Language.Embedded.Imperative.CMD

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 (FileCMD :: (k -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k1) (a :: k2). (forall (b :: k0). f b -> g b) -> FileCMD '(f, fs) a -> FileCMD '(g, fs) a

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi (FileCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) IO (Param1 pred :: (Type -> Constraint, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). FileCMD '(IO, '(IO, Param1 pred)) a -> IO a

(CompExp exp, CompTypeClass ct, ct Bool) => Interp (FileCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type) CGen (Param2 exp ct :: (Type -> Type, (Type -> Constraint, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). FileCMD '(CGen, Param2 exp ct) a -> CGen a

HBifunctor (FileCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

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

DryInterp (FileCMD :: (Type -> Type, (Type -> Type, (Type -> Constraint, Type))) -> Type -> Type)

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => FileCMD '(m, fs) a -> m a

C-specific commands

newtype Ptr (a :: *)

Pointer

Constructors

PtrComp

Fields

• ptrId :: VarId

Instances

Eq (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

Show (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

ToIdent (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Methods

toIdent :: Ptr a -> SrcLoc -> Id

Assignable (Ptr a)

Defined in Language.Embedded.Imperative.CMD

IsPointer (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Methods

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

data Object

Abstract object

Constructors

Object

Fields

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

Instances

Eq Object

Defined in Language.Embedded.Imperative.CMD

Methods

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

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

Show Object

Defined in Language.Embedded.Imperative.CMD

Methods

showsPrec :: Int -> Object -> ShowS

show :: Object -> String

showList :: [Object] -> ShowS

ToIdent Object

Defined in Language.Embedded.Imperative.CMD

Methods

toIdent :: Object -> SrcLoc -> Id

Assignable Object

Defined in Language.Embedded.Imperative.CMD

class Arg arg pred where

Methods

mkArg :: arg pred -> CGen Exp

mkParam :: arg pred -> CGen Param

Instances

Arg (ObjArg :: k -> Type) (pred :: k)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: ObjArg pred -> CGen Exp

mkParam :: ObjArg pred -> CGen Param

Arg (StrArg :: k -> Type) (pred :: k)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: StrArg pred -> CGen Exp

mkParam :: StrArg pred -> CGen Param

Arg (ConstArg :: k -> Type) (pred :: k)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: ConstArg pred -> CGen Exp

mkParam :: ConstArg pred -> CGen Param

CompTypeClass ct => Arg PtrArg (ct :: Type -> Constraint)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: PtrArg ct -> CGen Exp

mkParam :: PtrArg ct -> CGen Param

CompTypeClass ct => Arg IArrArg (ct :: Type -> Constraint)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: IArrArg ct -> CGen Exp

mkParam :: IArrArg ct -> CGen Param

CompTypeClass ct => Arg ArrArg (ct :: Type -> Constraint)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: ArrArg ct -> CGen Exp

mkParam :: ArrArg ct -> CGen Param

CompTypeClass ct => Arg RefArg (ct :: Type -> Constraint)

Defined in Language.Embedded.Imperative.Args

Methods

mkArg :: RefArg ct -> CGen Exp

mkParam :: RefArg ct -> CGen Param

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

Defined in Language.Embedded.Imperative.CMD

Methods

mkArg :: FunArg exp ct -> CGen Exp

mkParam :: FunArg exp ct -> 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 (FunArg exp :: (Type -> Constraint) -> Type) (ct :: Type -> Constraint)

Defined in Language.Embedded.Imperative.CMD

Methods

mkArg :: FunArg exp ct -> CGen Exp

mkParam :: FunArg exp ct -> 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

Defined in Language.Embedded.Imperative.CMD

Assignable (Ptr a)

Defined in Language.Embedded.Imperative.CMD

Assignable (Ref a)

Defined in Language.Embedded.Imperative.CMD

Assignable (IArr i a)

Defined in Language.Embedded.Imperative.CMD

Assignable (Arr i a)

Defined in Language.Embedded.Imperative.CMD

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

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

Defined in Language.Embedded.Imperative.CMD

Methods

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

InterpBi C_CMD IO (Param1 pred :: (Type -> Constraint, Type))

Defined in Language.Embedded.Imperative.CMD

Methods

interpBi :: forall (a :: k). C_CMD '(IO, '(IO, Param1 pred)) a -> IO a

(CompExp exp, CompTypeClass ct) => Interp C_CMD CGen (Param2 exp ct :: (Type -> Type, (Type -> Constraint, Type)))

Defined in Language.Embedded.Imperative.Backend.C

Methods

interp :: forall (a :: k). C_CMD '(CGen, Param2 exp ct) a -> CGen a

HFunctor C_CMD

Defined in Language.Embedded.Imperative.CMD

Methods

hfmap :: forall f g (fs :: k1) (a :: k2). (forall (b :: k). f b -> g b) -> C_CMD '(f, fs) a -> C_CMD '(g, fs) a

HBifunctor C_CMD

Defined in Language.Embedded.Imperative.CMD

Methods

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

DryInterp C_CMD

Defined in Language.Embedded.Imperative.CMD

Methods

dryInterp :: forall m (fs :: k) a. MonadSupply m => C_CMD '(m, fs) a -> m a