Synthesizer.LLVM.Causal.Process

Documentation

data T a b

Constructors

forall state ioContext . C state => Cons (forall r c. Phi c => ioContext -> a -> state -> T r c (b, state)) (forall r. ioContext -> CodeGenFunction r state) (IO ioContext) (ioContext -> IO ())

Instances

Arrow T

Category T

Functor (T a)

Applicative (T a)

(Field b, Real b, RationalConstant b) => Fractional (T a b)

(PseudoRing b, Real b, IntegerConstant b) => Num (T a b)

(Field b, RationalConstant b) => C (T a b)

(PseudoRing b, IntegerConstant b) => C (T a b)

Additive b => C (T a b)

simple :: C state => (forall r c. Phi c => a -> state -> T r c (b, state)) -> (forall r. CodeGenFunction r state) -> T a b

toSignal :: T () a -> T a

fromSignal :: T b -> T a b

map :: (forall r. a -> CodeGenFunction r b) -> T a b

mapAccum :: C state => (forall r. a -> state -> CodeGenFunction r (b, state)) -> (forall r. CodeGenFunction r state) -> T a b

zipWith :: (forall r. a -> b -> CodeGenFunction r c) -> T (a, b) c

apply :: T a b -> T a -> T b

feedFst :: T a -> T b (a, b)

feedSnd :: T a -> T b (b, a)

applyFst :: T (a, b) c -> T a -> T b c

applySnd :: T (a, b) c -> T b -> T a c

compose :: T a b -> T b c -> T a c

first :: T b c -> T (b, d) (c, d)

mix :: Additive a => T (a, a) a

envelope :: PseudoRing a => T (a, a) a

envelopeStereo :: PseudoRing a => T (a, T a) (T a)

amplify :: (IsArithmetic a, IsConst a) => a -> T (Value a) (Value a)

amplifyStereo :: (IsArithmetic a, IsConst a) => a -> T (T (Value a)) (T (Value a))

applyStorable :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> Vector a -> Vector b

derefStartPtr :: Importer (IO (Ptr stateStruct))

derefStopPtr :: Importer (Ptr stateStruct -> IO ())

derefChunkPtr :: Importer (Ptr stateStruct -> Word32 -> Ptr aStruct -> Ptr bStruct -> IO Word32)

compileChunky :: (C aValue, Struct aValue ~ aStruct, C bValue, Struct bValue ~ bStruct, C state, Struct state ~ stateStruct) => (forall r. aValue -> state -> T r (Value Bool, (Value (Ptr bStruct), state)) (bValue, state)) -> (forall r. CodeGenFunction r state) -> IO (FunPtr (IO (Ptr stateStruct)), FunPtr (Ptr stateStruct -> IO ()), FunPtr (Ptr stateStruct -> Word32 -> Ptr aStruct -> Ptr bStruct -> IO Word32))

runStorableChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> IO (Vector a -> Vector b)

Deprecated: this function will not work when the process itself depends on a lazy storable vector

This function will not work as expected, since feeding a lazy storable vector to the causal process means that createIOContext creates a StablePtr to an IORef refering to a chunk list. The IORef will be created once for all uses of the generated function of type (SVL.Vector a -> SVL.Vector b). This means that the pointer into the chunks list will conflict. An alternative would be to create the StablePtr in a foreign function that calls back to Haskell. But this way is disallowed for foreign finalizers.

applyStorableChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> Vector a -> Vector b