synthesizer-core-0.2: Audio signal processing coded in Haskell: Low level part Source code Contents Index

Synthesizer.FusionList.Signal

Contents functions based on generate functions based on crochetL functions consuming multiple lists functions based on reduceL Fusion helpers Other functions

Synopsis

newtype T y = Cons { decons :: [y] } 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] toStorableSignal :: Storable y => ChunkSize -> T y -> Vector y fromStorableSignal :: Storable y => Vector y -> T y 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 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) reduceL :: (x -> acc -> Maybe acc) -> acc -> T x -> acc foldL' :: (x -> acc -> acc) -> acc -> T x -> acc foldL :: (acc -> x -> acc) -> acc -> T x -> acc lengthSlow :: T a -> Int zipWithGenerate :: (a -> b -> c) -> (acc -> Maybe (a, acc)) -> acc -> T b -> T c zipWithCrochetL :: (a -> b -> c) -> (x -> acc -> Maybe (a, acc)) -> acc -> T x -> T b -> T c mixGenerate :: C a => (a -> a -> a) -> (acc -> Maybe (a, acc)) -> acc -> T a -> T a crochetLCons :: (a -> acc -> Maybe (b, acc)) -> acc -> a -> T a -> T b reduceLCons :: (a -> acc -> Maybe acc) -> acc -> a -> T a -> acc zipWithCons :: (a -> b -> c) -> a -> T a -> T b -> T c null :: T a -> Bool empty :: T a singleton :: a -> T a cons :: a -> T a -> T a length :: T a -> Int viewL :: T a -> Maybe (a, T a) viewR :: T a -> Maybe (T a, a) extendConstant :: T a -> T a tail :: T a -> T a head :: T a -> a drop :: Int -> T a -> T a dropMarginRem :: Int -> Int -> T a -> (Int, T a) dropMargin :: Int -> Int -> T a -> T a index :: Int -> T a -> a splitAt :: Int -> T a -> (T a, T a) dropWhile :: (a -> Bool) -> T a -> T a span :: (a -> Bool) -> T a -> (T a, T a) mapAccumL :: (acc -> x -> (acc, y)) -> acc -> T x -> (acc, T y) mapAccumR :: (acc -> x -> (acc, y)) -> acc -> T x -> (acc, T y) 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 concat :: [T a] -> T a reverse :: T a -> T a sum :: C a => T a -> a maximum :: Ord a => T a -> a tails :: T y -> [T y] init :: T y -> T y sliceVert :: Int -> T y -> [T y] zapWith :: (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 zipWithRest :: (y0 -> y0 -> y1) -> T y0 -> T y0 -> (T y1, (Bool, T y0)) zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y delayLoop :: (T y -> T y) -> T y -> T y delayLoopOverlap :: C y => Int -> (T y -> T y) -> T y -> T y recourse :: (acc -> Maybe acc) -> acc -> acc

Documentation

newtype T y Source

Constructors Cons decons :: [y] Instances Functor T C T Write T y Transform T y Read T y 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)

functions based on generate

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

toStorableSignal :: Storable y => ChunkSize -> T y -> Vector y Source

fromStorableSignal :: Storable y => Vector y -> T y Source

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

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

repeat :: a -> T a Source

functions based on crochetL

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

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

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 reduceL

reduceL :: (x -> acc -> Maybe acc) -> acc -> T x -> acc Source

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

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

lengthSlow :: T a -> Int Source

can be used to check against native length implementation

Fusion helpers

zipWithGenerate :: (a -> b -> c) -> (acc -> Maybe (a, acc)) -> acc -> T b -> T c Source

zipWithCrochetL :: (a -> b -> c) -> (x -> acc -> Maybe (a, acc)) -> acc -> T x -> T b -> T c Source

mixGenerate :: C a => (a -> a -> a) -> (acc -> Maybe (a, acc)) -> acc -> T a -> T a Source

crochetLCons :: (a -> acc -> Maybe (b, acc)) -> acc -> a -> T a -> T b Source

reduceLCons :: (a -> acc -> Maybe acc) -> acc -> a -> T a -> acc Source

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

Other functions

null :: T a -> Bool Source

empty :: T a Source

singleton :: a -> T a Source

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

length :: T a -> Int Source

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

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

extendConstant :: T a -> T a Source

tail :: T a -> T a Source

head :: T a -> a Source

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

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

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

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

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

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

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

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

mapAccumR :: (acc -> x -> (acc, y)) -> acc -> T x -> (acc, T y) 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

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

reverse :: T a -> T a Source

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

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

tails :: T y -> [T y] Source

init :: T y -> T y Source

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

zapWith :: (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

zipWithRest :: (y0 -> y0 -> y1) -> T y0 -> T y0 -> (T y1, (Bool, T y0)) Source

zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y 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

recourse :: (acc -> Maybe acc) -> acc -> acc Source

Produced by Haddock version 2.4.2