Synthesizer.Generic.Signal

Type classes that give a uniform interface to storable signals, stateful signals, lists, fusable lists. Some of the signal types require constraints on the element type. Storable signals require Storable elements. Thus we need multiparameter type classes. In this module we collect functions where the element type is not altered by the function.

Documentation

class Storage signal where

Minimal complete definition

constraints

Associated Types

data Constraints signal :: *

Methods

constraints :: signal -> Constraints signal

Instances

Storage [y]

Associated Types

data Constraints [y] :: *

Methods

constraints :: [y] -> Constraints [y]

Storable y => Storage (Vector y)

Associated Types

data Constraints (Vector y) :: *

Methods

constraints :: Vector y -> Constraints (Vector y)

Storable y => Storage (Vector y)

Associated Types

data Constraints (Vector y) :: *

Methods

constraints :: Vector y -> Constraints (Vector y)

Storage (T y)

Associated Types

data Constraints (T y) :: *

Methods

constraints :: T y -> Constraints (T y)

Storage (T time y)

Associated Types

data Constraints (T time y) :: *

Methods

constraints :: T time y -> Constraints (T time y)

class Read0 sig where

Minimal complete definition

toList, toState, foldL, foldR, index

Methods

toList :: Storage (sig y) => sig y -> [y]

toState :: Storage (sig y) => sig y -> T y

foldL :: Storage (sig y) => (s -> y -> s) -> s -> sig y -> s

foldR :: Storage (sig y) => (y -> s -> s) -> s -> sig y -> s

index :: Storage (sig y) => sig y -> Int -> y

Instances

Read0 []

Methods

toList :: Storage [y] => [y] -> [y]

toState :: Storage [y] => [y] -> T y

foldL :: Storage [y] => (s -> y -> s) -> s -> [y] -> s

foldR :: Storage [y] => (y -> s -> s) -> s -> [y] -> s

index :: Storage [y] => [y] -> Int -> y

Read0 Vector

Methods

toList :: Storage (Vector y) => Vector y -> [y]

toState :: Storage (Vector y) => Vector y -> T y

foldL :: Storage (Vector y) => (s -> y -> s) -> s -> Vector y -> s

foldR :: Storage (Vector y) => (y -> s -> s) -> s -> Vector y -> s

index :: Storage (Vector y) => Vector y -> Int -> y

Read0 Vector

Methods

toList :: Storage (Vector y) => Vector y -> [y]

toState :: Storage (Vector y) => Vector y -> T y

foldL :: Storage (Vector y) => (s -> y -> s) -> s -> Vector y -> s

foldR :: Storage (Vector y) => (y -> s -> s) -> s -> Vector y -> s

index :: Storage (Vector y) => Vector y -> Int -> y

Read0 T

Methods

toList :: Storage (T y) => T y -> [y]

toState :: Storage (T y) => T y -> T y

foldL :: Storage (T y) => (s -> y -> s) -> s -> T y -> s

foldR :: Storage (T y) => (y -> s -> s) -> s -> T y -> s

index :: Storage (T y) => T y -> Int -> y

(C time, Integral time) => Read0 (T time)

Methods

toList :: Storage (T time y) => T time y -> [y]

toState :: Storage (T time y) => T time y -> T y

foldL :: Storage (T time y) => (s -> y -> s) -> s -> T time y -> s

foldR :: Storage (T time y) => (y -> s -> s) -> s -> T time y -> s

index :: Storage (T time y) => T time y -> Int -> y

class (Read (sig y), Read0 sig, Storage (sig y)) => Read sig y

Instances

Read [] y

Storable y => Read Vector y

Storable y => Read Vector y

Read T y

(C time, Integral time) => Read (T time) y

class Read0 sig => Transform0 sig where

Minimal complete definition

cons, takeWhile, dropWhile, span, viewL, viewR, zipWithAppend, map, scanL, crochetL

Methods

cons :: Storage (sig y) => y -> sig y -> sig y

takeWhile :: Storage (sig y) => (y -> Bool) -> sig y -> sig y

dropWhile :: Storage (sig y) => (y -> Bool) -> sig y -> sig y

span :: Storage (sig y) => (y -> Bool) -> sig y -> (sig y, sig y)

viewL :: Storage (sig y) => sig y -> Maybe (y, sig y)

When using viewL for traversing a signal, it is certainly better to convert to State signal first, since this might involve optimized traversing like in case of Storable signals.

viewR :: Storage (sig y) => sig y -> Maybe (sig y, y)

zipWithAppend :: Storage (sig y) => (y -> y -> y) -> sig y -> sig y -> sig y

map :: (Storage (sig y0), Storage (sig y1)) => (y0 -> y1) -> sig y0 -> sig y1

scanL :: (Storage (sig y0), Storage (sig y1)) => (y1 -> y0 -> y1) -> y1 -> sig y0 -> sig y1

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

Instances

Transform0 []

Methods

cons :: Storage [y] => y -> [y] -> [y]

takeWhile :: Storage [y] => (y -> Bool) -> [y] -> [y]

dropWhile :: Storage [y] => (y -> Bool) -> [y] -> [y]

span :: Storage [y] => (y -> Bool) -> [y] -> ([y], [y])

viewL :: Storage [y] => [y] -> Maybe (y, [y])

viewR :: Storage [y] => [y] -> Maybe ([y], y)

zipWithAppend :: Storage [y] => (y -> y -> y) -> [y] -> [y] -> [y]

map :: (Storage [y0], Storage [y1]) => (y0 -> y1) -> [y0] -> [y1]

scanL :: (Storage [y0], Storage [y1]) => (y1 -> y0 -> y1) -> y1 -> [y0] -> [y1]

crochetL :: (Storage [y0], Storage [y1]) => (y0 -> s -> Maybe (y1, s)) -> s -> [y0] -> [y1]

Transform0 Vector

Methods

cons :: Storage (Vector y) => y -> Vector y -> Vector y

takeWhile :: Storage (Vector y) => (y -> Bool) -> Vector y -> Vector y

dropWhile :: Storage (Vector y) => (y -> Bool) -> Vector y -> Vector y

span :: Storage (Vector y) => (y -> Bool) -> Vector y -> (Vector y, Vector y)

viewL :: Storage (Vector y) => Vector y -> Maybe (y, Vector y)

viewR :: Storage (Vector y) => Vector y -> Maybe (Vector y, y)

zipWithAppend :: Storage (Vector y) => (y -> y -> y) -> Vector y -> Vector y -> Vector y

map :: (Storage (Vector y0), Storage (Vector y1)) => (y0 -> y1) -> Vector y0 -> Vector y1

scanL :: (Storage (Vector y0), Storage (Vector y1)) => (y1 -> y0 -> y1) -> y1 -> Vector y0 -> Vector y1

crochetL :: (Storage (Vector y0), Storage (Vector y1)) => (y0 -> s -> Maybe (y1, s)) -> s -> Vector y0 -> Vector y1

Transform0 Vector

Methods

cons :: Storage (Vector y) => y -> Vector y -> Vector y

takeWhile :: Storage (Vector y) => (y -> Bool) -> Vector y -> Vector y

dropWhile :: Storage (Vector y) => (y -> Bool) -> Vector y -> Vector y

span :: Storage (Vector y) => (y -> Bool) -> Vector y -> (Vector y, Vector y)

viewL :: Storage (Vector y) => Vector y -> Maybe (y, Vector y)

viewR :: Storage (Vector y) => Vector y -> Maybe (Vector y, y)

zipWithAppend :: Storage (Vector y) => (y -> y -> y) -> Vector y -> Vector y -> Vector y

map :: (Storage (Vector y0), Storage (Vector y1)) => (y0 -> y1) -> Vector y0 -> Vector y1

scanL :: (Storage (Vector y0), Storage (Vector y1)) => (y1 -> y0 -> y1) -> y1 -> Vector y0 -> Vector y1

crochetL :: (Storage (Vector y0), Storage (Vector y1)) => (y0 -> s -> Maybe (y1, s)) -> s -> Vector y0 -> Vector y1

Transform0 T

Methods

cons :: Storage (T y) => y -> T y -> T y

takeWhile :: Storage (T y) => (y -> Bool) -> T y -> T y

dropWhile :: Storage (T y) => (y -> Bool) -> T y -> T y

span :: Storage (T y) => (y -> Bool) -> T y -> (T y, T y)

viewL :: Storage (T y) => T y -> Maybe (y, T y)

viewR :: Storage (T y) => T y -> Maybe (T y, y)

zipWithAppend :: Storage (T y) => (y -> y -> y) -> T y -> T y -> T y

map :: (Storage (T y0), Storage (T y1)) => (y0 -> y1) -> T y0 -> T y1

scanL :: (Storage (T y0), Storage (T y1)) => (y1 -> y0 -> y1) -> y1 -> T y0 -> T y1

crochetL :: (Storage (T y0), Storage (T y1)) => (y0 -> s -> Maybe (y1, s)) -> s -> T y0 -> T y1

(C time, Integral time) => Transform0 (T time)

Methods

cons :: Storage (T time y) => y -> T time y -> T time y

takeWhile :: Storage (T time y) => (y -> Bool) -> T time y -> T time y

dropWhile :: Storage (T time y) => (y -> Bool) -> T time y -> T time y

span :: Storage (T time y) => (y -> Bool) -> T time y -> (T time y, T time y)

viewL :: Storage (T time y) => T time y -> Maybe (y, T time y)

viewR :: Storage (T time y) => T time y -> Maybe (T time y, y)

zipWithAppend :: Storage (T time y) => (y -> y -> y) -> T time y -> T time y -> T time y

map :: (Storage (T time y0), Storage (T time y1)) => (y0 -> y1) -> T time y0 -> T time y1

scanL :: (Storage (T time y0), Storage (T time y1)) => (y1 -> y0 -> y1) -> y1 -> T time y0 -> T time y1

crochetL :: (Storage (T time y0), Storage (T time y1)) => (y0 -> s -> Maybe (y1, s)) -> s -> T time y0 -> T time y1

class (Transform (sig y), Transform0 sig, Read sig y) => Transform sig y

Instances

Transform [] y

Storable y => Transform Vector y

Storable y => Transform Vector y

Transform T y

(C time, Integral time) => Transform (T time) y

newtype LazySize

This type is used for specification of the maximum size of strict packets. Packets can be smaller, can have different sizes in one signal. In some kinds of streams, like lists and stateful generators, the packet size is always 1. The packet size is not just a burden caused by efficiency, but we need control over packet size in applications with feedback.

ToDo: Make the element type of the corresponding signal a type parameter. This helps to distinguish chunk sizes of scalar and vectorised signals.

Constructors

LazySize Int

Instances

Eq LazySize

Methods

(==) :: LazySize -> LazySize -> Bool

(/=) :: LazySize -> LazySize -> Bool

Ord LazySize

Methods

compare :: LazySize -> LazySize -> Ordering

(<) :: LazySize -> LazySize -> Bool

(<=) :: LazySize -> LazySize -> Bool

(>) :: LazySize -> LazySize -> Bool

(>=) :: LazySize -> LazySize -> Bool

max :: LazySize -> LazySize -> LazySize

min :: LazySize -> LazySize -> LazySize

Show LazySize

Methods

showsPrec :: Int -> LazySize -> ShowS

show :: LazySize -> String

showList :: [LazySize] -> ShowS

Monoid LazySize

Methods

mempty :: LazySize

mappend :: LazySize -> LazySize -> LazySize

mconcat :: [LazySize] -> LazySize

Arbitrary LazySize

Methods

arbitrary :: Gen LazySize

shrink :: LazySize -> [LazySize]

C LazySize

Methods

toInteger :: LazySize -> Integer

C LazySize

Methods

toRational :: LazySize -> Rational

C LazySize

Methods

quot :: LazySize -> LazySize -> LazySize

rem :: LazySize -> LazySize -> LazySize

quotRem :: LazySize -> LazySize -> (LazySize, LazySize)

C LazySize

Methods

abs :: LazySize -> LazySize

signum :: LazySize -> LazySize

C LazySize

Methods

div :: LazySize -> LazySize -> LazySize

mod :: LazySize -> LazySize -> LazySize

divMod :: LazySize -> LazySize -> (LazySize, LazySize)

C LazySize

Methods

isZero :: LazySize -> Bool

C LazySize

Methods

split :: LazySize -> LazySize -> (LazySize, (Bool, LazySize))

C LazySize

Methods

idt :: LazySize

(<*>) :: LazySize -> LazySize -> LazySize

cumulate :: [LazySize] -> LazySize

C LazySize

Methods

(*) :: LazySize -> LazySize -> LazySize

one :: LazySize

fromInteger :: Integer -> LazySize

(^) :: LazySize -> Integer -> LazySize

C LazySize

Methods

zero :: LazySize

(+) :: LazySize -> LazySize -> LazySize

(-) :: LazySize -> LazySize -> LazySize

negate :: LazySize -> LazySize

Transform LazySize

Methods

take :: Int -> LazySize -> LazySize

drop :: Int -> LazySize -> LazySize

dropMarginRem :: Int -> Int -> LazySize -> (Int, LazySize)

splitAt :: Int -> LazySize -> (LazySize, LazySize)

reverse :: LazySize -> LazySize

Read LazySize

Methods

null :: LazySize -> Bool

length :: LazySize -> Int

defaultLazySize :: LazySize

This can be used for internal signals that have no observable effect on laziness. E.g. when you construct a list by repeat defaultLazySize zero we assume that zero is defined for all Additive types.

class Transform0 sig => Write0 sig where

We could provide the LazySize by a Reader monad, but we don't do that because we expect that the choice of the lazy size is more local than say the choice of the sample rate. E.g. there is no need to have the same laziness coarseness for multiple signal processors.

Minimal complete definition

fromList, repeat, replicate, iterate, iterateAssociative, unfoldR

Methods

fromList :: Storage (sig y) => LazySize -> [y] -> sig y

repeat :: Storage (sig y) => LazySize -> y -> sig y

replicate :: Storage (sig y) => LazySize -> Int -> y -> sig y

iterate :: Storage (sig y) => LazySize -> (y -> y) -> y -> sig y

iterateAssociative :: Storage (sig y) => LazySize -> (y -> y -> y) -> y -> sig y

unfoldR :: Storage (sig y) => LazySize -> (s -> Maybe (y, s)) -> s -> sig y

Instances

Write0 []

Methods

fromList :: Storage [y] => LazySize -> [y] -> [y]

repeat :: Storage [y] => LazySize -> y -> [y]

replicate :: Storage [y] => LazySize -> Int -> y -> [y]

iterate :: Storage [y] => LazySize -> (y -> y) -> y -> [y]

iterateAssociative :: Storage [y] => LazySize -> (y -> y -> y) -> y -> [y]

unfoldR :: Storage [y] => LazySize -> (s -> Maybe (y, s)) -> s -> [y]

Write0 Vector

Methods

fromList :: Storage (Vector y) => LazySize -> [y] -> Vector y

repeat :: Storage (Vector y) => LazySize -> y -> Vector y

replicate :: Storage (Vector y) => LazySize -> Int -> y -> Vector y

iterate :: Storage (Vector y) => LazySize -> (y -> y) -> y -> Vector y

iterateAssociative :: Storage (Vector y) => LazySize -> (y -> y -> y) -> y -> Vector y

unfoldR :: Storage (Vector y) => LazySize -> (s -> Maybe (y, s)) -> s -> Vector y

Write0 T

Methods

fromList :: Storage (T y) => LazySize -> [y] -> T y

repeat :: Storage (T y) => LazySize -> y -> T y

replicate :: Storage (T y) => LazySize -> Int -> y -> T y

iterate :: Storage (T y) => LazySize -> (y -> y) -> y -> T y

iterateAssociative :: Storage (T y) => LazySize -> (y -> y -> y) -> y -> T y

unfoldR :: Storage (T y) => LazySize -> (s -> Maybe (y, s)) -> s -> T y

(C time, Integral time) => Write0 (T time)

Methods

fromList :: Storage (T time y) => LazySize -> [y] -> T time y

repeat :: Storage (T time y) => LazySize -> y -> T time y

replicate :: Storage (T time y) => LazySize -> Int -> y -> T time y

iterate :: Storage (T time y) => LazySize -> (y -> y) -> y -> T time y

iterateAssociative :: Storage (T time y) => LazySize -> (y -> y -> y) -> y -> T time y

unfoldR :: Storage (T time y) => LazySize -> (s -> Maybe (y, s)) -> s -> T time y

class (Write0 sig, Transform sig y) => Write sig y

Instances

Write [] y

Storable y => Write Vector y

Write T y

(C time, Integral time) => Write (T time) y

readSVL :: (Storable a => Vector a -> b) -> Storage (Vector a) => Vector a -> b

writeSVL :: (Storable a => Vector a) -> Storage (Vector a) => Vector a

withStorableContext :: (ChunkSize -> a) -> LazySize -> a

readSV :: (Storable a => Vector a -> b) -> Storage (Vector a) => Vector a -> b

writeSV :: (Storable a => Vector a) -> Storage (Vector a) => Vector a

switchL :: Transform sig y => a -> (y -> sig y -> a) -> sig y -> a

switchR :: Transform sig y => a -> (sig y -> y -> a) -> sig y -> a

runViewL :: Read sig y => sig y -> (forall s. (s -> Maybe (y, s)) -> s -> x) -> x

runSwitchL :: Read sig y => sig y -> (forall s. (forall z. z -> (y -> s -> z) -> s -> z) -> s -> x) -> x

singleton :: Transform sig y => y -> sig y

mix :: (C y, Transform sig y) => sig y -> sig y -> sig y

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

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

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

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

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

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

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

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

takeStateMatch len xs keeps a prefix of xs of the same length and block structure as len and stores it in the same type of container as len.

delay :: Write sig y => LazySize -> y -> Int -> sig y -> sig y

delayLoop

Arguments

:: Transform sig y

=> (sig y -> sig y)

processor that shall be run in a feedback loop

-> sig y

prefix of the output, its length determines the delay

-> sig y

delayLoopOverlap

Arguments

:: (C y, Write sig y)

=> Int

-> (sig y -> sig y)

Processor that shall be run in a feedback loop. It's absolutely necessary that this function preserves the chunk structure and that it does not look a chunk ahead. That's guaranteed for processes that do not look ahead at all, like map, crochetL and all of type Causal.Process.

-> sig y

input

-> sig y

output has the same length as the input

sum :: (C a, Read sig a) => sig a -> a

sum1 :: (C a, Read sig a) => sig a -> a

foldMap :: (Read sig a, Monoid m) => (a -> m) -> sig a -> m

monoidConcatMap :: (Read sig a, Monoid m) => (a -> m) -> sig a -> m

Deprecated: Use foldMap instead.

tails :: Transform sig y => sig y -> T (sig y)

laxTail :: Transform sig y => sig y -> sig y

Like tail, but for an empty signal it simply returns an empty signal.

mapAdjacent :: (Read sig a, Transform sig a) => (a -> a -> a) -> sig a -> sig a

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

modifyModulated :: (Transform sig a, Transform sig 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, Read sig y) => sig t -> sig y -> y

fromState :: Write sig y => LazySize -> T y -> sig y

extendConstant :: Write sig y => LazySize -> sig y -> sig y

snoc :: Transform sig y => sig y -> y -> sig y

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

mapTailsAlt :: (Transform sig a, Write sig b) => LazySize -> (sig a -> b) -> sig a -> sig b

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

Only non-empty suffixes are processed. More oftenly we might need

zipWithTails :: (Read sig b, Transform2 sig a) =>
   (b -> sig a -> a) -> sig b -> sig a -> sig a

this would preserve the chunk structure of sig a, but it is a bit more hassle to implement that.

indexByDrop :: Transform sig a => sig a -> Int -> a

null :: Read sig => sig -> Bool

length :: Read sig => sig -> Int

empty :: Monoid sig => sig

cycle :: Monoid sig => sig -> sig

append :: Monoid sig => sig -> sig -> sig

concat :: Monoid sig => [sig] -> sig

take :: Transform sig => Int -> sig -> sig

drop :: Transform sig => Int -> sig -> sig

dropMarginRem :: Transform sig => Int -> Int -> sig -> (Int, sig)

splitAt :: Transform sig => Int -> sig -> (sig, sig)

reverse :: Transform sig => sig -> sig

lengthAtLeast :: Transform sig => Int -> sig -> Bool

Like lengthAtLeast n xs = length xs >= n, but is more efficient, because it is more lazy.

lengthAtMost :: Transform sig => Int -> sig -> Bool

sliceVertical :: Transform sig => Int -> sig -> T sig