Feldspar.Data.Storable

Storable types

Note that the Storable interface is currently not ideal for vectors:

• The Store representation only allows a vector to be read back as the same type as it was written. But it is usually desired to read a vector as Manifest regardless of what type it was written as.

  • But this is solved by using functions that operated on StoreRep instead (such as readStoreRep).
• There is no support for double-buffered storage, as provided by Feldspar.Data.Buffered which means that memory management can become more tedious.

Forcible class

class Forcible a where

Expression types that can be "forced" to values

Associated Types

type ValueRep a

Representation of a forced value

Methods

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

Force an expression to a value. The resulting value can be used multiple times without risking re-computation.

toValue will allocate memory to hold the value.

fromValue :: ValueRep a -> a

Convert a forced value back to an expression

Instances

Forcible a => Forcible [a]

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep [a]

Methods

toValue :: MonadComp m => [a] -> m (ValueRep [a])

fromValue :: ValueRep [a] -> [a]

Type a => Forcible (Data a)

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (Data a)

Methods

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

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

Forcible a => Forcible (Validated a)

toValue will force the value even if it's invalid

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (Validated a)

Methods

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

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

Syntax a => Forcible (Option a)

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (Option a)

Methods

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

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

(Forcible a, Forcible b) => Forcible (a, b)

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (a, b)

Methods

toValue :: MonadComp m => (a, b) -> m (ValueRep (a, b))

fromValue :: ValueRep (a, b) -> (a, b)

(Forcible a, Forcible b, Forcible c) => Forcible (a, b, c)

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (a, b, c)

Methods

toValue :: MonadComp m => (a, b, c) -> m (ValueRep (a, b, c))

fromValue :: ValueRep (a, b, c) -> (a, b, c)

(Forcible a, Forcible b, Forcible c, Forcible d) => Forcible (a, b, c, d)

Defined in Feldspar.Data.Storable

Associated Types

type ValueRep (a, b, c, d)

Methods

toValue :: MonadComp m => (a, b, c, d) -> m (ValueRep (a, b, c, d))

fromValue :: ValueRep (a, b, c, d) -> (a, b, c, d)

forceCast :: (Forcible a, Forcible b, ValueRep a ~ ValueRep b, MonadComp m) => a -> m b

Cast between Forcible types that have the same value representation

force :: (Forcible a, MonadComp m) => a -> m a

Force the computation of an expression. The resulting value can be used multiple times without risking re-computation.

Storable class

class Storable a where

Storable types

Associated Types

type StoreRep a

Memory representation

type StoreSize a

Size of memory representation

Methods

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

Creat a fresh memory store. It is usually better to use newStore instead of this function as it improves type inference.

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

Store a value to a fresh memory store. It is usually better to use initStore instead of this function as it improves type inference.

readStoreRep :: MonadComp m => StoreRep a -> m a

Read from a memory store. It is usually better to use readStore instead of this function as it improves type inference.

unsafeFreezeStoreRep :: MonadComp m => StoreRep a -> m a

Unsafe freezing of a memory store. It is usually better to use unsafeFreezeStore instead of this function as it improves type inference.

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

Write to a memory store. It is usually better to use writeStore instead of this function as it improves type inference.

Instances

Storable ()

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep ()

type StoreSize ()

Methods

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

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

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

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

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

Type a => Storable (Data a)

Defined in Feldspar.Data.Storable

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

Syntax a => Storable (Pull a)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (Pull a)

type StoreSize (Pull a)

Methods

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

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

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

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

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

Syntax a => Storable (Manifest2 a)

Defined in Feldspar.Data.Storable

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)

Defined in Feldspar.Data.Storable

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

(Storable a, Syntax a, StoreSize a ~ ()) => Storable (Option a)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (Option a)

type StoreSize (Option a)

Methods

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

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

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

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

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

(Storable a, Storable b) => Storable (a, b)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (a, b)

type StoreSize (a, b)

Methods

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

initStoreRep :: MonadComp m => (a, b) -> m (StoreRep (a, b))

readStoreRep :: MonadComp m => StoreRep (a, b) -> m (a, b)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (a, b) -> m (a, b)

writeStoreRep :: MonadComp m => StoreRep (a, b) -> (a, b) -> m ()

Syntax a => Storable (Push Comp a)

Defined in Feldspar.Data.Storable

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

(Storable a, Storable b, Storable c) => Storable (a, b, c)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (a, b, c)

type StoreSize (a, b, c)

Methods

newStoreRep :: MonadComp m => proxy (a, b, c) -> StoreSize (a, b, c) -> m (StoreRep (a, b, c))

initStoreRep :: MonadComp m => (a, b, c) -> m (StoreRep (a, b, c))

readStoreRep :: MonadComp m => StoreRep (a, b, c) -> m (a, b, c)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (a, b, c) -> m (a, b, c)

writeStoreRep :: MonadComp m => StoreRep (a, b, c) -> (a, b, c) -> m ()

(Storable a, Storable b, Storable c, Storable d) => Storable (a, b, c, d)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (a, b, c, d)

type StoreSize (a, b, c, d)

Methods

newStoreRep :: MonadComp m => proxy (a, b, c, d) -> StoreSize (a, b, c, d) -> m (StoreRep (a, b, c, d))

initStoreRep :: MonadComp m => (a, b, c, d) -> m (StoreRep (a, b, c, d))

readStoreRep :: MonadComp m => StoreRep (a, b, c, d) -> m (a, b, c, d)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (a, b, c, d) -> m (a, b, c, d)

writeStoreRep :: MonadComp m => StoreRep (a, b, c, d) -> (a, b, c, d) -> m ()

initStoreRepVec :: forall m vec. (Storable vec, StoreSize vec ~ Data Length, Finite vec, MonadComp m) => vec -> m (StoreRep vec)

initStoreRepVec2 :: forall m vec. (Storable vec, StoreSize vec ~ (Data Length, Data Length), Finite2 vec, MonadComp m) => vec -> m (StoreRep vec)

writeStoreRepVec :: (Manifestable m vec a, StoreRep vec ~ (DRef Length, Arr a), Finite vec, Syntax a, MonadComp m) => StoreRep vec -> vec -> m ()

writeStoreRepVec2 :: (Manifestable2 m vec a, StoreRep vec ~ (DRef Length, DRef Length, Arr a), Finite2 vec, Syntax a, MonadComp m) => StoreRep vec -> vec -> m ()

User interface

newtype Store a

Memory for storing values

Constructors

Store

Fields

• unStore :: StoreRep a

newStore :: forall a m. (Storable a, MonadComp m) => StoreSize a -> m (Store a)

Create a fresh Store

initStore :: (Storable a, MonadComp m) => a -> m (Store a)

Store a value to a fresh Store

readStore :: (Storable a, MonadComp m) => Store a -> m a

Read from a Store

unsafeFreezeStore :: (Storable a, MonadComp m) => Store a -> m a

Unsafe freezeing of a Store. This operation is only safe if the Store is not updated as long as the resulting value is alive.

writeStore :: (Storable a, MonadComp m) => Store a -> a -> m ()

Write to a Store

inplace :: (Storable a, MonadComp m) => Store a -> (a -> a) -> m ()

Update a Store in-place