Synthesizer.LLVM.Causal.Process

Documentation

data T a b

Constructors

forall state packed size ioContext . (Memory state packed, IsSized packed size) => 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

simple :: (Memory state packed, IsSized packed size) => (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 a -> T () a

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

mapAccum :: (Memory state packed, IsSized packed size) => (forall r. a -> state -> CodeGenFunction r (b, state)) -> (forall r. CodeGenFunction r state) -> T a b

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 :: IsArithmetic a => T (Value a, Value a) (Value a)

mixStereo :: IsArithmetic a => T (T (Value a), T (Value a)) (T (Value a))

envelope :: IsArithmetic a => T (Value a, Value a) (Value a)

envelopeStereo :: IsArithmetic a => T (Value a, T (Value a)) (T (Value 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 valueA, Memory valueA structA, Storable b, MakeValueTuple b valueB, Memory valueB structB) => 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 :: (Memory aValue aStruct, Memory bValue bStruct, Memory state stateStruct, IsSized stateStruct stateSize) => (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 valueA, Memory valueA structA, Storable b, MakeValueTuple b valueB, Memory valueB structB) => T valueA valueB -> IO (Vector a -> Vector b)

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 valueA, Memory valueA structA, Storable b, MakeValueTuple b valueB, Memory valueB structB) => T valueA valueB -> Vector a -> Vector b