Feldspar.Representation

Internal representation of Feldspar programs

Object-language types

type TypeRep = Struct PrimType' PrimTypeRep

Representation of all supported types

class (Eq a, Show a, Typeable a, Inhabited a) => Type a where

Supported types

Minimal complete definition

typeRep

Methods

typeRep :: TypeRep a

Reify a type

Instances

Type Bool

Methods

typeRep :: TypeRep Bool

Type Double

Methods

typeRep :: TypeRep Double

Type Float

Methods

typeRep :: TypeRep Float

Type Int8

Methods

typeRep :: TypeRep Int8

Type Int16

Methods

typeRep :: TypeRep Int16

Type Int32

Methods

typeRep :: TypeRep Int32

Type Int64

Methods

typeRep :: TypeRep Int64

Type Word8

Methods

typeRep :: TypeRep Word8

Type Word16

Methods

typeRep :: TypeRep Word16

Type Word32

Methods

typeRep :: TypeRep Word32

Type Word64

Methods

typeRep :: TypeRep Word64

Type (Complex Double)

Methods

typeRep :: TypeRep (Complex Double)

Type (Complex Float)

Methods

typeRep :: TypeRep (Complex Float)

(Type a, Type b) => Type (a, b)

Methods

typeRep :: TypeRep (a, b)

class (PrimType' a, Type a) => PrimType a

Alias for the conjunction of PrimType' and Type

Instances

CompTypeClass PrimType

Methods

compType :: (PrimType a, MonadC m) => proxy1 PrimType -> proxy2 a -> m Type

compLit :: (PrimType a, MonadC m) => proxy PrimType -> a -> m Exp

(PrimType' a, Type a) => PrimType a

toTypeRep :: Struct PrimType' c a -> TypeRep a

Convert any Struct with a PrimType constraint to a TypeRep

typeEq :: TypeRep a -> TypeRep b -> Maybe (Dict (a ~ b))

Check whether two type representations are equal

witTypeable :: TypeRep a -> Dict (Typeable a)

Reflect a TypeRep to a Typeable constraint

data TypeRepFun a where

Representation of supported value types + N-ary functions over such types

Constructors

ValT :: TypeRep a -> TypeRepFun a

FunT :: TypeRep a -> TypeRepFun b -> TypeRepFun (a -> b)

typeEqFun :: TypeRepFun a -> TypeRepFun b -> Maybe (Dict (a ~ b))

Check whether two type representations are equal

newtype Ref a

Mutable variable

Constructors

Ref

Fields

• unRef :: Struct PrimType' Ref (Internal a)

Instances

Eq (Ref a)

Methods

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

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

type DRef a = Ref (Data a)

Reference specialized to Data elements

data Arr a

Mutable array

Constructors

Arr

Fields

• arrOffset :: Data Index
• arrLength :: Data Length
• unArr :: Struct PrimType' (Arr Index) (Internal a)

Instances

Eq (Arr a)

== checks if two Arr use the same physical array. The length and offset are ignored.

Methods

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

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

Slicable (Arr a)

Methods

slice :: Data Index -> Data Length -> Arr a -> Arr a

Finite (Arr a)

Methods

length :: Arr a -> Data Length

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (Arr a)

Associated Types

type HaskellRep (Arr a) :: *

Methods

fwrite :: Handle -> Arr a -> Run ()

fread :: Handle -> Run (Arr a)

type SizeSpec (Arr a)

type SizeSpec (Arr a) = VecChanSizeSpec (SizeSpec a)

type HaskellRep (Arr a)

type HaskellRep (Arr a) = [Internal a]

type DArr a = Arr (Data a)

Array specialized to Data elements

data IArr a

Immutable array

Constructors

IArr

Fields

• iarrOffset :: Data Index
• iarrLength :: Data Length
• unIArr :: Struct PrimType' (IArr Index) (Internal a)

Instances

MonadComp m => Manifestable2 m (Manifest2 a) a

manifest2 and manifestFresh2 are no-ops. manifestStore2 does a proper arrCopy.

Methods

manifest2 :: Arr a -> Manifest2 a -> m (Manifest2 a)

manifestFresh2 :: Manifest2 a -> m (Manifest2 a)

manifestStore2 :: Arr a -> Manifest2 a -> m ()

MonadComp m => Manifestable m (Manifest a) a

manifest and manifestFresh are no-ops. manifestStore does a proper arrCopy.

Methods

manifest :: Arr a -> Manifest a -> m (Manifest a)

manifestFresh :: Manifest a -> m (Manifest a)

manifestStore :: Arr a -> Manifest a -> m ()

(Syntax a, MonadComp m) => Seqy m (Manifest a) a

Methods

toSeq :: Manifest a -> Seq m a

(Syntax a, MonadComp m) => Pushy2 m (Manifest2 a) a

Methods

toPush2 :: Manifest2 a -> Push2 m a

(Syntax a, MonadComp m) => Pushy2 m (Manifest a) a

Convert to a Push2 with a single row

Methods

toPush2 :: Manifest a -> Push2 m a

(Syntax a, MonadComp m) => Pushy m (Manifest a) a

Methods

toPush :: Manifest a -> Push m a

Slicable (IArr a)

Methods

slice :: Data Index -> Data Length -> IArr a -> IArr a

Finite (IArr a)

Methods

length :: IArr a -> Data Length

Syntax a => Indexed (IArr a)

Associated Types

type IndexedElem (IArr a) :: *

Methods

(!) :: IArr a -> Data Index -> IndexedElem (IArr a)

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (IArr a)

Associated Types

type HaskellRep (IArr a) :: *

Methods

fwrite :: Handle -> IArr a -> Run ()

fread :: Handle -> Run (IArr a)

Syntax a => Storable (Manifest2 a)

Associated Types

type StoreRep (Manifest2 a) :: *

type StoreSize (Manifest2 a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Manifest2 a) -> StoreSize (Manifest2 a) -> m (StoreRep (Manifest2 a))

initStoreRep :: MonadComp m => Manifest2 a -> m (StoreRep (Manifest2 a))

readStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

writeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> Manifest2 a -> m ()

Syntax a => Storable (Manifest a)

Associated Types

type StoreRep (Manifest a) :: *

type StoreSize (Manifest a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Manifest a) -> StoreSize (Manifest a) -> m (StoreRep (Manifest a))

initStoreRep :: MonadComp m => Manifest a -> m (StoreRep (Manifest a))

readStoreRep :: MonadComp m => StoreRep (Manifest a) -> m (Manifest a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Manifest a) -> m (Manifest a)

writeStoreRep :: MonadComp m => StoreRep (Manifest a) -> Manifest a -> m ()

ViewManifest2 (Manifest2 a) a

Methods

viewManifest2 :: Manifest2 a -> Maybe (Manifest2 a)

ViewManifest (Manifest a) a

Methods

viewManifest :: Manifest a -> Maybe (Manifest a)

Syntax a => Pully2 (Manifest a) a

Convert to a Pull2 with a single row

Methods

toPull2 :: Manifest a -> Pull2 a

type IndexedElem (IArr a)

type IndexedElem (IArr a) = a

type SizeSpec (IArr a)

type SizeSpec (IArr a) = VecChanSizeSpec (SizeSpec a)

type HaskellRep (IArr a)

type HaskellRep (IArr a) = [Internal a]

type StoreRep (Manifest2 a)

type StoreRep (Manifest2 a) = (DRef Length, DRef Length, Arr a)

type StoreRep (Manifest a)

type StoreRep (Manifest a) = (DRef Length, Arr a)

type StoreSize (Manifest2 a)

type StoreSize (Manifest2 a) = (Data Length, Data Length)

type StoreSize (Manifest a)

type StoreSize (Manifest a) = Data Length

type DIArr a = IArr (Data a)

Immutable array specialized to Data elements

unsafeEqArrIArr :: Arr a -> IArr a -> Bool

Check if an Arr and and IArr use the same physical array. The length and offset are ignored. This operation may give false negatives, but never false positives. Whether or not false negatives occur may also depend on the interpretation of the program.

Due to this unreliability, the function should only be used to affect the non-functional properties of a program (e.g. to avoid unnecessary array copying).

Pure expressions

data AssertionLabel

Assertion labels

Constructors

InternalAssertion

Internal assertion to guarantee meaningful results

LibraryAssertion String

Assertion related to a specific library

UserAssertion String

Assertion in user code. The default label for user assertions is UserAssertion ""

Instances

Eq AssertionLabel

Methods

(==) :: AssertionLabel -> AssertionLabel -> Bool

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

Show AssertionLabel

Methods

showsPrec :: Int -> AssertionLabel -> ShowS

show :: AssertionLabel -> String

showList :: [AssertionLabel] -> ShowS

onlyUserAssertions :: Selection AssertionLabel

A selection that includes all labels defined as UserAssertion

data ExtraPrimitive sig where

Constructors

DivBalanced :: (Integral a, PrimType' a) => ExtraPrimitive (a :-> (a :-> Full a))

GuardVal :: AssertionLabel -> String -> ExtraPrimitive (Bool :-> (a :-> Full a))

Instances

Eval ExtraPrimitive

Methods

evalSym :: ExtraPrimitive sig -> Denotation sig

Equality ExtraPrimitive

Methods

equal :: ExtraPrimitive a -> ExtraPrimitive b -> Bool

hash :: ExtraPrimitive a -> Hash

Render ExtraPrimitive

Methods

renderSym :: ExtraPrimitive sig -> String

renderArgs :: [String] -> ExtraPrimitive sig -> String

StringTree ExtraPrimitive

Methods

stringTreeSym :: [Tree String] -> ExtraPrimitive a -> Tree String

Symbol ExtraPrimitive

Methods

symSig :: ExtraPrimitive sig -> SigRep sig

EvalEnv ExtraPrimitive env

Methods

compileSym :: proxy env -> ExtraPrimitive sig -> DenotationM (Reader env) sig

data ForLoop sig where

For loop

Constructors

ForLoop :: Type st => ForLoop (Length :-> (st :-> ((Index -> st -> st) :-> Full st)))

Instances

Eval ForLoop

Methods

evalSym :: ForLoop sig -> Denotation sig

Equality ForLoop

Methods

equal :: ForLoop a -> ForLoop b -> Bool

hash :: ForLoop a -> Hash

Render ForLoop

Methods

renderSym :: ForLoop sig -> String

renderArgs :: [String] -> ForLoop sig -> String

StringTree ForLoop

Methods

stringTreeSym :: [Tree String] -> ForLoop a -> Tree String

Symbol ForLoop

Methods

symSig :: ForLoop sig -> SigRep sig

EvalEnv ForLoop env

Methods

compileSym :: proxy env -> ForLoop sig -> DenotationM (Reader env) sig

data Unsafe sig where

Interaction with the IO layer

Constructors

UnsafePerform :: Comp (Data a) -> Unsafe (Full a)

Instances

Eval Unsafe

Methods

evalSym :: Unsafe sig -> Denotation sig

Equality Unsafe

equal always returns False

Methods

equal :: Unsafe a -> Unsafe b -> Bool

hash :: Unsafe a -> Hash

Render Unsafe

Methods

renderSym :: Unsafe sig -> String

renderArgs :: [String] -> Unsafe sig -> String

StringTree Unsafe

Methods

stringTreeSym :: [Tree String] -> Unsafe a -> Tree String

Symbol Unsafe

Methods

symSig :: Unsafe sig -> SigRep sig

EvalEnv Unsafe env

Methods

compileSym :: proxy env -> Unsafe sig -> DenotationM (Reader env) sig

type FeldConstructs = BindingT :+: (Let :+: (Tuple :+: (Primitive :+: (ExtraPrimitive :+: (ForLoop :+: Unsafe)))))

type FeldDomain = FeldConstructs :&: TypeRepFun

newtype Data a

Constructors

Data

Fields

• unData :: ASTF FeldDomain a

Instances

FreeExp Data

Associated Types

type FreePred (Data :: * -> *) :: * -> Constraint

Methods

constExp :: FreePred Data a => a -> Data a

varExp :: FreePred Data a => VarId -> Data a

EvalExp Data

Methods

evalExp :: Data a -> a

Syntactic (Data a)

Declaring Data as syntactic sugar

Associated Types

type Domain (Data a) :: * -> *

type Internal (Data a) :: *

Methods

desugar :: Data a -> ASTF (Domain (Data a)) (Internal (Data a))

sugar :: ASTF (Domain (Data a)) (Internal (Data a)) -> Data a

PrimType' a => BulkTransferable (Data a)

Associated Types

type ContainerType (Data a) :: *

Methods

readChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedReadChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

writeChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedWriteChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

PrimType' a => Transferable (Data a)

Associated Types

type SizeSpec (Data a) :: *

Methods

calcChanSize :: proxy (Data a) -> SizeSpec (Data a) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (Data a) -> Run (Chan * * Uncloseable (Data a))

newCloseableChan :: SizeSpec (Data a) -> Run (Chan * * Closeable (Data a))

readChan :: Chan * * t (Data a) -> Run (Data a)

untypedReadChan :: Chan * * t c -> Run (Data a)

writeChan :: Chan * * t (Data a) -> Data a -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> Data a -> Run (Data Bool)

MarshalFeld (Data Double)

Associated Types

type HaskellRep (Data Double) :: *

Methods

fwrite :: Handle -> Data Double -> Run ()

fread :: Handle -> Run (Data Double)

MarshalFeld (Data Float)

Associated Types

type HaskellRep (Data Float) :: *

Methods

fwrite :: Handle -> Data Float -> Run ()

fread :: Handle -> Run (Data Float)

MarshalFeld (Data Int8)

Associated Types

type HaskellRep (Data Int8) :: *

Methods

fwrite :: Handle -> Data Int8 -> Run ()

fread :: Handle -> Run (Data Int8)

MarshalFeld (Data Int16)

Associated Types

type HaskellRep (Data Int16) :: *

Methods

fwrite :: Handle -> Data Int16 -> Run ()

fread :: Handle -> Run (Data Int16)

MarshalFeld (Data Int32)

Associated Types

type HaskellRep (Data Int32) :: *

Methods

fwrite :: Handle -> Data Int32 -> Run ()

fread :: Handle -> Run (Data Int32)

MarshalFeld (Data Int64)

Associated Types

type HaskellRep (Data Int64) :: *

Methods

fwrite :: Handle -> Data Int64 -> Run ()

fread :: Handle -> Run (Data Int64)

MarshalFeld (Data Word8)

Associated Types

type HaskellRep (Data Word8) :: *

Methods

fwrite :: Handle -> Data Word8 -> Run ()

fread :: Handle -> Run (Data Word8)

MarshalFeld (Data Word16)

Associated Types

type HaskellRep (Data Word16) :: *

Methods

fwrite :: Handle -> Data Word16 -> Run ()

fread :: Handle -> Run (Data Word16)

MarshalFeld (Data Word32)

Associated Types

type HaskellRep (Data Word32) :: *

Methods

fwrite :: Handle -> Data Word32 -> Run ()

fread :: Handle -> Run (Data Word32)

MarshalFeld (Data Word64)

Associated Types

type HaskellRep (Data Word64) :: *

Methods

fwrite :: Handle -> Data Word64 -> Run ()

fread :: Handle -> Run (Data Word64)

MarshalFeld (Data (Complex Double))

Associated Types

type HaskellRep (Data (Complex Double)) :: *

Methods

fwrite :: Handle -> Data (Complex Double) -> Run ()

fread :: Handle -> Run (Data (Complex Double))

MarshalFeld (Data (Complex Float))

Associated Types

type HaskellRep (Data (Complex Float)) :: *

Methods

fwrite :: Handle -> Data (Complex Float) -> Run ()

fread :: Handle -> Run (Data (Complex Float))

Type a => Storable (Data a)

Associated Types

type StoreRep (Data a) :: *

type StoreSize (Data a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Data a) -> StoreSize (Data a) -> m (StoreRep (Data a))

initStoreRep :: MonadComp m => Data a -> m (StoreRep (Data a))

readStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a)

writeStoreRep :: MonadComp m => StoreRep (Data a) -> Data a -> m ()

Type a => Forcible (Data a)

Associated Types

type ValueRep (Data a) :: *

Methods

toValue :: MonadComp m => Data a -> m (ValueRep (Data a))

fromValue :: ValueRep (Data a) -> Data a

(Formattable a, PrimType a, PrintfType r) => PrintfType (Data a -> r)

Methods

fprf :: Handle -> String -> [PrintfArg Data] -> Data a -> r

Syntactic (Struct PrimType' Data a)

Associated Types

type Domain (Struct PrimType' Data a) :: * -> *

type Internal (Struct PrimType' Data a) :: *

Methods

desugar :: Struct PrimType' Data a -> ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a))

sugar :: ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a)) -> Struct PrimType' Data a

type FreePred Data

type FreePred Data = PrimType'

type Internal (Data a)

type Internal (Data a) = a

type Domain (Data a)

type Domain (Data a) = FeldDomain

type ContainerType (Data a)

type ContainerType (Data a) = DArr a

type SizeSpec (Data a)

type SizeSpec (Data a) = Data Length

type HaskellRep (Data Double)

type HaskellRep (Data Double) = Double

type HaskellRep (Data Float)

type HaskellRep (Data Float) = Float

type HaskellRep (Data Int8)

type HaskellRep (Data Int8) = Int8

type HaskellRep (Data Int16)

type HaskellRep (Data Int16) = Int16

type HaskellRep (Data Int32)

type HaskellRep (Data Int32) = Int32

type HaskellRep (Data Int64)

type HaskellRep (Data Int64) = Int64

type HaskellRep (Data Word8)

type HaskellRep (Data Word8) = Word8

type HaskellRep (Data Word16)

type HaskellRep (Data Word16) = Word16

type HaskellRep (Data Word32)

type HaskellRep (Data Word32) = Word32

type HaskellRep (Data Word64)

type HaskellRep (Data Word64) = Word64

type HaskellRep (Data (Complex Double))

type HaskellRep (Data (Complex Double)) = Complex Double

type HaskellRep (Data (Complex Float))

type HaskellRep (Data (Complex Float)) = Complex Float

type StoreRep (Data a)

type StoreRep (Data a) = DRef a

type StoreSize (Data a)

type StoreSize (Data a) = ()

type ValueRep (Data a)

type ValueRep (Data a) = Data a

type Internal (Struct PrimType' Data a)

type Internal (Struct PrimType' Data a) = a

type Domain (Struct PrimType' Data a)

type Domain (Struct PrimType' Data a) = FeldDomain

class (Syntactic a, Domain a ~ FeldDomain, Type (Internal a)) => Syntax a

Specialization of the Syntactic class for the Feldspar domain

Instances

(Syntactic a, (~) (* -> *) (Domain a) FeldDomain, Type (Internal a)) => Syntax a

sugarSymFeld :: (Signature sig, fi ~ SmartFun FeldDomain sig, sig ~ SmartSig fi, FeldDomain ~ SmartSym fi, SyntacticN f fi, sub :<: FeldConstructs, Type (DenResult sig)) => sub sig -> f

Make a smart constructor for a symbol

sugarSymFeldPrim :: (Signature sig, fi ~ SmartFun FeldDomain sig, sig ~ SmartSig fi, FeldDomain ~ SmartSym fi, SyntacticN f fi, sub :<: FeldConstructs, PrimType' (DenResult sig)) => sub sig -> f

Make a smart constructor for a symbol

eval :: (Syntactic a, Domain a ~ FeldDomain) => a -> Internal a

Evaluate a closed expression

Monadic computations

data AssertCMD fs a where

Constructors

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

Instances

HFunctor * k1 (* -> *, (k, *)) (AssertCMD (k1 -> *) k)

Methods

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

HBifunctor * * (k, *) (AssertCMD (* -> *) 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

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

Methods

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

InterpBi * (* -> Constraint, *) (AssertCMD (* -> *) (* -> Constraint)) IO (Param1 (* -> Constraint) PrimType')

Methods

interpBi :: Param1 (* -> Constraint) PrimType' ((AssertCMD (* -> *) (* -> Constraint) -> *, (AssertCMD (* -> *) (* -> Constraint) -> *, IO)) m ((AssertCMD (* -> *) (* -> Constraint) -> *, IO) m fs)) a -> m a

type CompCMD = RefCMD :+: (ArrCMD :+: (ControlCMD :+: AssertCMD))

newtype Comp a

Monad for computational effects: mutable data structures and control flow

Constructors

Comp

Fields

• unComp :: Program CompCMD (Param2 Data PrimType') a

Instances

Monad Comp

Methods

(>>=) :: Comp a -> (a -> Comp b) -> Comp b

(>>) :: Comp a -> Comp b -> Comp b

return :: a -> Comp a

fail :: String -> Comp a

Functor Comp

Methods

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

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

Applicative Comp

Methods

pure :: a -> Comp a

(<*>) :: Comp (a -> b) -> Comp a -> Comp b

(*>) :: Comp a -> Comp b -> Comp b

(<*) :: Comp a -> Comp b -> Comp a

MonadComp Comp

Methods

liftComp :: Comp a -> Comp a

iff :: Data Bool -> Comp () -> Comp () -> Comp ()

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> Comp ()) -> Comp ()

while :: Comp (Data Bool) -> Comp () -> Comp ()

MonadRun Comp

Methods

liftRun :: Comp a -> Run a

Syntax a => Storable (Push Comp a)

Associated Types

type StoreRep (Push Comp a) :: *

type StoreSize (Push Comp a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Push Comp a) -> StoreSize (Push Comp a) -> m (StoreRep (Push Comp a))

initStoreRep :: MonadComp m => Push Comp a -> m (StoreRep (Push Comp a))

readStoreRep :: MonadComp m => StoreRep (Push Comp a) -> m (Push Comp a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Push Comp a) -> m (Push Comp a)

writeStoreRep :: MonadComp m => StoreRep (Push Comp a) -> Push Comp a -> m ()

type StoreRep (Push Comp a)

type StoreRep (Push Comp a) = (DRef Length, Arr a)

type StoreSize (Push Comp a)

type StoreSize (Push Comp a) = Data Length