Synthesizer.Generic.Signal2

Type class for several signal storage types that allows alter element types. There is some overlap between the two Transform classes. This was done in order to save us from ubiquitous Transform sig y y constraints.

Documentation

class (Transform sig y0, Transform sig y1) => Transform sig y0 y1 where

Methods

map :: (y0 -> y1) -> sig y0 -> sig y1

scanL :: (y1 -> y0 -> y1) -> y1 -> sig y0 -> sig y1

crochetL :: (y0 -> s -> Maybe (y1, s)) -> s -> sig y0 -> sig y1

Instances

Transform [] y0 y1

(Storable y0, Storable y1) => Transform Vector y0 y1

Transform T y0 y1

(C time, Integral time) => Transform (T time) y0 y1

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

mapAdjacent :: Transform sig a b => (a -> a -> b) -> sig a -> sig b

zip :: (Read sig a, Transform sig b (a, b)) => sig a -> sig b -> sig (a, b)

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

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

unzip :: (Transform sig (a, b) a, Transform sig (a, b) b) => sig (a, b) -> (sig a, sig b)

unzip3 :: (Transform sig (a, b, c) a, Transform sig (a, b, c) b, Transform sig (a, b, c) c) => sig (a, b, c) -> (sig a, sig b, sig c)

modifyStatic :: Transform sig a b => Simple s ctrl a b -> ctrl -> sig a -> sig b

modifyModulated :: (Transform sig a b, Read sig ctrl) => Simple s ctrl a b -> sig ctrl -> sig a -> sig b

Here the control may vary over the time.

linearComb :: (C t y, Read sig t, Transform sig y y) => sig t -> sig y -> y

mapTails :: Transform sig a b => (sig a -> b) -> sig a -> sig b

zipWithTails :: (Transform sig b, Transform sig a c) => (a -> sig b -> c) -> sig a -> sig b -> sig c

zipWith2Tails :: (Transform sig b, Transform sig c, Transform sig a d) => (a -> sig b -> sig c -> d) -> sig a -> sig b -> sig c -> sig d

zipWithState :: Transform sig b c => (a -> b -> c) -> T a -> sig b -> sig c

zipWithState3 :: Transform sig c d => (a -> b -> c -> d) -> T a -> T b -> sig c -> sig d