synthesizer-0.2: Audio signal processing coded in Haskell Source code Contents Index

Synthesizer.State.Signal

Contents functions consuming multiple lists functions based on foldL functions based on foldR Other functions

Description

ToDo: Better name for the module is certainly Synthesizer.Generator.Signal

Synopsis

data T a = forall s . Cons !(StateT s Maybe a) !s generate :: (acc -> Maybe (y, acc)) -> acc -> T y unfoldR :: (acc -> Maybe (y, acc)) -> acc -> T y generateInfinite :: (acc -> (y, acc)) -> acc -> T y fromList :: [y] -> T y toList :: T y -> [y] fromStorableSignal :: Storable a => T a -> T a toStorableSignal :: Storable a => ChunkSize -> T a -> T a toStorableSignalVary :: Storable a => LazySize -> T a -> T a iterate :: (a -> a) -> a -> T a iterateAssociative :: (a -> a -> a) -> a -> T a repeat :: a -> T a crochetL :: (x -> acc -> Maybe (y, acc)) -> acc -> T x -> T y scanL :: (acc -> x -> acc) -> acc -> T x -> T acc scanLClip :: (acc -> x -> acc) -> acc -> T x -> T acc map :: (a -> b) -> T a -> T b unzip :: T (a, b) -> (T a, T b) unzip3 :: T (a, b, c) -> (T a, T b, T c) delay1 :: a -> T a -> T a delay :: y -> Int -> T y -> T y take :: Int -> T a -> T a takeWhile :: (a -> Bool) -> T a -> T a replicate :: Int -> a -> T a zipWith :: (a -> b -> c) -> T a -> T b -> T c zipWithStorable :: (Storable b, Storable c) => (a -> b -> c) -> T a -> T b -> T c zipWith3 :: (a -> b -> c -> d) -> T a -> T b -> T c -> T d zipWith4 :: (a -> b -> c -> d -> e) -> T a -> T b -> T c -> T d -> T e zip :: T a -> T b -> T (a, b) zip3 :: T a -> T b -> T c -> T (a, b, c) zip4 :: T a -> T b -> T c -> T d -> T (a, b, c, d) foldL' :: (x -> acc -> acc) -> acc -> T x -> acc foldL :: (acc -> x -> acc) -> acc -> T x -> acc length :: T a -> Int foldR :: (x -> acc -> acc) -> acc -> T x -> acc null :: T a -> Bool empty :: T a singleton :: a -> T a cons :: a -> T a -> T a viewL :: T a -> Maybe (a, T a) viewR :: Storable a => T a -> Maybe (T a, a) viewRSize :: Storable a => ChunkSize -> T a -> Maybe (T a, a) switchL :: b -> (a -> T a -> b) -> T a -> b switchR :: Storable a => b -> (T a -> a -> b) -> T a -> b extendConstant :: T a -> T a drop :: Int -> T a -> T a dropMarginRem :: Int -> Int -> T a -> (Int, T a) dropMargin :: Int -> Int -> T a -> T a dropMatch :: T b -> T a -> T a index :: Int -> T a -> a splitAt :: Storable a => Int -> T a -> (T a, T a) splitAtSize :: Storable a => ChunkSize -> Int -> T a -> (T a, T a) dropWhile :: (a -> Bool) -> T a -> T a span :: Storable a => (a -> Bool) -> T a -> (T a, T a) spanSize :: Storable a => ChunkSize -> (a -> Bool) -> T a -> (T a, T a) cycle :: T a -> T a mix :: C a => T a -> T a -> T a sub :: C a => T a -> T a -> T a neg :: C a => T a -> T a append :: T a -> T a -> T a appendStored :: Storable a => T a -> T a -> T a appendStoredSize :: Storable a => ChunkSize -> T a -> T a -> T a concat :: [T a] -> T a concatStored :: Storable a => [T a] -> T a concatStoredSize :: Storable a => ChunkSize -> [T a] -> T a reverse :: T a -> T a reverseStored :: Storable a => T a -> T a reverseStoredSize :: Storable a => ChunkSize -> T a -> T a sum :: C a => T a -> a maximum :: Ord a => T a -> a init :: T y -> T y sliceVert :: Int -> T y -> [T y] zapWith :: (a -> a -> b) -> T a -> T b zapWithAlt :: (a -> a -> b) -> T a -> T b modifyStatic :: Simple s ctrl a b -> ctrl -> T a -> T b modifyModulated :: Simple s ctrl a b -> T ctrl -> T a -> T b linearComb :: C t y => T t -> T y -> y mapTails :: (T y0 -> y1) -> T y0 -> T y1 zipWithTails :: (y0 -> T y1 -> y2) -> T y0 -> T y1 -> T y2 zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y zipStep :: (a -> a -> a) -> (T a, T a) -> Maybe (a, (T a, T a)) delayLoop :: (T y -> T y) -> T y -> T y delayLoopOverlap :: C y => Int -> (T y -> T y) -> T y -> T y sequence_ :: Monad m => T (m a) -> m () mapM_ :: Monad m => (a -> m ()) -> T a -> m () monoidConcat :: Monoid m => T m -> m monoidConcatMap :: Monoid m => (a -> m) -> T a -> m

Documentation

data T a Source

Cf. StreamFusion Data.Stream Constructors forall s . Cons !(StateT s Maybe a) !s Instances Functor T C T C T Write T y Transform T y Read T y C T y Transform T y0 y1 C Flat T T C y yv => C y (T yv) Show y => Show (T y) Monoid (T y) C y => C (T y) Transform (T y) Read (T y)

generate :: (acc -> Maybe (y, acc)) -> acc -> T y Source

unfoldR :: (acc -> Maybe (y, acc)) -> acc -> T y Source

generateInfinite :: (acc -> (y, acc)) -> acc -> T y Source

fromList :: [y] -> T y Source

toList :: T y -> [y] Source

fromStorableSignal :: Storable a => T a -> T a Source

toStorableSignal :: Storable a => ChunkSize -> T a -> T a Source

toStorableSignalVary :: Storable a => LazySize -> T a -> T a Source

iterate :: (a -> a) -> a -> T a Source

iterateAssociative :: (a -> a -> a) -> a -> T a Source

repeat :: a -> T a Source

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

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

scanLClip :: (acc -> x -> acc) -> acc -> T x -> T acc Source

input and output have equal length, that's better for fusion

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

unzip :: T (a, b) -> (T a, T b) Source

This function will recompute the input lists and is thus probably not what you want. If you want to avoid recomputation please consider Causal.Process.

unzip3 :: T (a, b, c) -> (T a, T b, T c) Source

delay1 :: a -> T a -> T a Source

This is a fusion friendly implementation of delay. However, in order to be a crochetL the output has the same length as the input, that is, the last element is removed - at least for finite input.

delay :: y -> Int -> T y -> T y Source

take :: Int -> T a -> T a Source

takeWhile :: (a -> Bool) -> T a -> T a Source

replicate :: Int -> a -> T a Source

functions consuming multiple lists

zipWith :: (a -> b -> c) -> T a -> T b -> T c Source

zipWithStorable :: (Storable b, Storable c) => (a -> b -> c) -> T a -> T b -> T c Source

zipWith3 :: (a -> b -> c -> d) -> T a -> T b -> T c -> T d Source

zipWith4 :: (a -> b -> c -> d -> e) -> T a -> T b -> T c -> T d -> T e Source

zip :: T a -> T b -> T (a, b) Source

zip3 :: T a -> T b -> T c -> T (a, b, c) Source

zip4 :: T a -> T b -> T c -> T d -> T (a, b, c, d) Source

functions based on foldL

foldL' :: (x -> acc -> acc) -> acc -> T x -> acc Source

foldL :: (acc -> x -> acc) -> acc -> T x -> acc Source

length :: T a -> Int Source

functions based on foldR

foldR :: (x -> acc -> acc) -> acc -> T x -> acc Source

Other functions

null :: T a -> Bool Source

empty :: T a Source

singleton :: a -> T a Source

cons :: a -> T a -> T a Source

This is expensive and should not be used to construct lists iteratively!

viewL :: T a -> Maybe (a, T a) Source

viewR :: Storable a => T a -> Maybe (T a, a) Source

viewRSize :: Storable a => ChunkSize -> T a -> Maybe (T a, a) Source

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

switchR :: Storable a => b -> (T a -> a -> b) -> T a -> b Source

extendConstant :: T a -> T a Source

This implementation requires that the input generator has to check repeatedly whether it is finished.

drop :: Int -> T a -> T a Source

dropMarginRem :: Int -> Int -> T a -> (Int, T a) Source

This implementation expects that looking ahead is cheap.

dropMargin :: Int -> Int -> T a -> T a Source

dropMatch :: T b -> T a -> T a Source

index :: Int -> T a -> a Source

splitAt :: Storable a => Int -> T a -> (T a, T a) Source

splitAtSize :: Storable a => ChunkSize -> Int -> T a -> (T a, T a) Source

dropWhile :: (a -> Bool) -> T a -> T a Source

span :: Storable a => (a -> Bool) -> T a -> (T a, T a) Source

spanSize :: Storable a => ChunkSize -> (a -> Bool) -> T a -> (T a, T a) Source

cycle :: T a -> T a Source

mix :: C a => T a -> T a -> T a Source

sub :: C a => T a -> T a -> T a Source

neg :: C a => T a -> T a Source

append :: T a -> T a -> T a Source

appendStored :: Storable a => T a -> T a -> T a Source

appendStoredSize :: Storable a => ChunkSize -> T a -> T a -> T a Source

concat :: [T a] -> T a Source

certainly inefficient because of frequent list deconstruction

concatStored :: Storable a => [T a] -> T a Source

concatStoredSize :: Storable a => ChunkSize -> [T a] -> T a Source

reverse :: T a -> T a Source

reverseStored :: Storable a => T a -> T a Source

reverseStoredSize :: Storable a => ChunkSize -> T a -> T a Source

sum :: C a => T a -> a Source

maximum :: Ord a => T a -> a Source

init :: T y -> T y Source

sliceVert :: Int -> T y -> [T y] Source

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

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

modifyStatic :: Simple s ctrl a b -> ctrl -> T a -> T b Source

modifyModulated :: Simple s ctrl a b -> T ctrl -> T a -> T b Source

Here the control may vary over the time.

linearComb :: C t y => T t -> T y -> y Source

mapTails :: (T y0 -> y1) -> T y0 -> T y1 Source

zipWithTails :: (y0 -> T y1 -> y2) -> T y0 -> T y1 -> T y2 Source

zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y Source

zipStep :: (a -> a -> a) -> (T a, T a) -> Maybe (a, (T a, T a)) Source

delayLoop Source

:: => T y -> T y processor that shall be run in a feedback loop -> T y prefix of the output, its length determines the delay -> T y

delayLoopOverlap Source

:: C y => Int -> T y -> T y processor that shall be run in a feedback loop -> T y input -> T y output has the same length as the input

sequence_ :: Monad m => T (m a) -> m () Source

mapM_ :: Monad m => (a -> m ()) -> T a -> m () Source

monoidConcat :: Monoid m => T m -> m Source

Counterpart to Data.Monoid.mconcat.

monoidConcatMap :: Monoid m => (a -> m) -> T a -> m Source

Produced by Haddock version 2.4.2