Synthesizer.Causal.Process

Processes that use only the current and past data. Essentially this is a data type for the crochetL function.

Documentation

data T a b

Cf. StreamFusion T

Constructors

forall s. Cons !(a -> StateT s Maybe b) !s

Instances

Arrow T

Defined in Synthesizer.Causal.Process

Methods

arr :: (b -> c) -> T b c

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

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

(***) :: T b c -> T b' c' -> T (b, b') (c, c')

(&&&) :: T b c -> T b c' -> T b (c, c')

ArrowLoop T

Defined in Synthesizer.Causal.Process

Methods

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

C T

Defined in Synthesizer.Causal.Arrow

Methods

apply :: (Transform sig a, Transform sig b) => T a b -> sig a -> sig b

C T

Defined in Synthesizer.Causal.Process

Associated Types

type SignalOf T :: Type -> Type

Methods

toSignal :: T () a -> SignalOf T a

fromSignal :: SignalOf T b -> T a b

Category T

Defined in Synthesizer.Causal.Process

Methods

id :: forall (a :: k). T a a

(.) :: forall (b :: k) (c :: k) (a :: k). T b c -> T a b -> T a c

Applicative (T a)

Defined in Synthesizer.Causal.Process

Methods

pure :: a0 -> T a a0

(<*>) :: T a (a0 -> b) -> T a a0 -> T a b

liftA2 :: (a0 -> b -> c) -> T a a0 -> T a b -> T a c

(*>) :: T a a0 -> T a b -> T a b

(<*) :: T a a0 -> T a b -> T a a0

Functor (T a)

Defined in Synthesizer.Causal.Process

Methods

fmap :: (a0 -> b) -> T a a0 -> T a b

(<$) :: a0 -> T a b -> T a a0

Num b => Num (T a b)

Defined in Synthesizer.Causal.Process

Methods

(+) :: T a b -> T a b -> T a b

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

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

negate :: T a b -> T a b

abs :: T a b -> T a b

signum :: T a b -> T a b

fromInteger :: Integer -> T a b

Fractional b => Fractional (T a b)

Defined in Synthesizer.Causal.Process

Methods

(/) :: T a b -> T a b -> T a b

recip :: T a b -> T a b

fromRational :: Rational -> T a b

C b => C (T a b)

Defined in Synthesizer.Causal.Process

Methods

zero :: T a b

(+) :: T a b -> T a b -> T a b

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

negate :: T a b -> T a b

C b => C (T a b)

Defined in Synthesizer.Causal.Process

Methods

(/) :: T a b -> T a b -> T a b

recip :: T a b -> T a b

fromRational' :: Rational -> T a b

(^-) :: T a b -> Integer -> T a b

C b => C (T a b)

Defined in Synthesizer.Causal.Process

Methods

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

one :: T a b

fromInteger :: Integer -> T a b

(^) :: T a b -> Integer -> T a b

type SignalOf T

Defined in Synthesizer.Causal.Process

type SignalOf T = T

fromStateMaybe :: (a -> StateT s Maybe b) -> s -> T a b

fromState :: (a -> State s b) -> s -> T a b

fromSimpleModifier :: Simple s ctrl a b -> T (ctrl, a) b

fromInitializedModifier :: Initialized s init ctrl a b -> init -> T (ctrl, a) b

id :: T a a

map :: (a -> b) -> T a b

first :: Arrow a => a b c -> a (b, d) (c, d)

Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.

second :: Arrow a => a b c -> a (d, b) (d, c)

A mirror image of first.

The default definition may be overridden with a more efficient version if desired.

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

split :: T a b -> T c d -> T (a, c) (b, d)

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

loop :: ArrowLoop a => a (b, d) (c, d) -> a b c

apply :: (Transform sig a, Transform sig b) => T a b -> sig a -> sig b

applyFst :: Read sig a => T (a, b) c -> sig a -> T b c

I think this function does too much. Better use feedFst and (>>>).

applySnd :: Read sig b => T (a, b) c -> sig b -> T a c

I think this function does too much. Better use feedSnd and (>>>).

applySameType :: Transform sig a => T a a -> sig a -> sig a

applyConst :: T a b -> a -> T b

applyConst c x == apply c (repeat x)

apply2 :: (Read sig a, Transform sig b, Transform sig c) => T (a, b) c -> sig a -> sig b -> sig c

apply3 :: (Read sig a, Read sig b, Transform sig c, Transform sig d) => T (a, b, c) d -> sig a -> sig b -> sig c -> sig d

applyStorableChunk :: (Storable a, Storable b) => T a b -> T (Vector a) (Vector b)

feed :: Read sig a => sig a -> T () a

feedFst :: Read sig a => sig a -> T b (a, b)

feedSnd :: Read sig a => sig a -> T b (b, a)

feedGenericFst :: Read sig a => sig a -> T b (a, b)

feedGenericSnd :: Read sig a => sig a -> T b (b, a)

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

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

crochetL :: (x -> acc -> Maybe (y, acc)) -> acc -> T x y

mapAccumL :: (x -> acc -> (y, acc)) -> acc -> T x y

scanL :: (acc -> x -> acc) -> acc -> T x acc

scanL1 :: (x -> x -> x) -> T x x

zipWith :: Read sig a => (a -> b -> c) -> sig a -> T b c

consInit :: x -> T x x

Prepend an element to a signal, but keep the signal length, i.e. drop the last element.

chainControlled :: [T (c, x) x] -> T (c, x) x

replicateControlled :: Int -> T (c, x) x -> T (c, x) x

If T would be the function type -> then replicateControlled 3 f computes (c,x) -> f(c, f(c, f(c, x))).

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

feedbackControlled :: T ((ctrl, a), c) b -> T (ctrl, b) c -> T (ctrl, a) b

applyFst' :: Read sig a => T (a, b) c -> sig a -> T b c

I think this function does too much. Better use feedFst and (>>>).

applySnd' :: Read sig b => T (a, b) c -> sig b -> T a c

I think this function does too much. Better use feedSnd and (>>>).