Safe Haskell	Safe-Inferred
Language	Haskell2010

Synthesizer.State.Signal

Contents

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

Description

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

Synopsis

data T a = forall s. Cons !(StateT s Maybe a) !s
runViewL :: T y -> (forall s. (s -> Maybe (y, s)) -> s -> x) -> x
runSwitchL :: T y -> (forall s. (forall z. z -> (y -> s -> z) -> s -> z) -> s -> x) -> x
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
fromStrictStorableSignal :: Storable a => Vector a -> T a
toStorableSignal :: Storable a => ChunkSize -> T a -> T a
toStrictStorableSignal :: Storable a => Int -> T a -> Vector a
toStorableSignalVary :: Storable a => LazySize -> T a -> T a
fromPiecewiseConstant :: (C time, Integral time) => T time 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
foldL1 :: (x -> x -> x) -> T x -> x
length :: T a -> Int
equal :: Eq a => T a -> T a -> Bool
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
liftA2 :: (a -> b -> c) -> T a -> T b -> T c
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
mapAdjacent :: (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
zipWithTails1 :: (y0 -> T y1 -> y2) -> T y0 -> T y1 -> T y2
zipWithTailsInf :: (y0 -> T y1 -> y2) -> T y0 -> T y1 -> T y2
zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y
zipStep :: (s -> Maybe (a, s)) -> (t -> Maybe (a, t)) -> (a -> a -> a) -> (s, t) -> Maybe (a, (s, t))
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 ()
fold :: Monoid m => T m -> m
monoidConcat :: Monoid m => T m -> m
foldMap :: Monoid m => (a -> m) -> T a -> m
monoidConcatMap :: Monoid m => (a -> m) -> T a -> m
catMaybes :: T (Maybe a) -> T a
flattenPairs :: T (a, a) -> T a
interleave :: T y -> T y -> T y
interleaveAlt :: T y -> T y -> T y

Documentation

data T a Source #

Cf. StreamFusion Data.Stream

Constructors

forall s. Cons !(StateT s Maybe a) !s

Instances

Instances details

Foldable T Source #
Instance details Defined in Synthesizer.State.Signal Methods fold :: Monoid m => T m -> m # foldMap :: Monoid m => (a -> m) -> T a -> m # foldMap' :: Monoid m => (a -> m) -> T a -> m # foldr :: (a -> b -> b) -> b -> T a -> b # foldr' :: (a -> b -> b) -> b -> T a -> b # foldl :: (b -> a -> b) -> b -> T a -> b # foldl' :: (b -> a -> b) -> b -> T a -> b # foldr1 :: (a -> a -> a) -> T a -> a # foldl1 :: (a -> a -> a) -> T a -> a # toList :: T a -> [a] # null :: T a -> Bool # length :: T a -> Int # elem :: Eq a => a -> T a -> Bool # maximum :: Ord a => T a -> a # minimum :: Ord a => T a -> a # sum :: Num a => T a -> a # product :: Num a => T a -> a #
Applicative T Source #
Instance details Defined in Synthesizer.State.Signal Methods pure :: a -> T a # (<>) :: T (a -> b) -> T a -> T b # liftA2 :: (a -> b -> c) -> T a -> T b -> T c # (>) :: T a -> T b -> T b # (<*) :: T a -> T b -> T a #
Functor T Source #
Instance details Defined in Synthesizer.State.Signal Methods fmap :: (a -> b) -> T a -> T b # (<$) :: a -> T b -> T a #
Monad T Source #
Instance details Defined in Synthesizer.State.Signal Methods (>>=) :: T a -> (a -> T b) -> T b # (>>) :: T a -> T b -> T b # return :: a -> T a #
C T Source #
Instance details Defined in Synthesizer.State.Signal Methods format :: Show x => Int -> T x -> ShowS Source #
Read0 T Source #
Instance details Defined in Synthesizer.Generic.Signal Methods toList :: Storage (T y) => T y -> [y] Source # toState :: Storage (T y) => T y -> T y Source # foldL :: Storage (T y) => (s -> y -> s) -> s -> T y -> s Source # foldR :: Storage (T y) => (y -> s -> s) -> s -> T y -> s Source # index :: Storage (T y) => T y -> Int -> y Source #
Transform0 T Source #
Instance details Defined in Synthesizer.Generic.Signal Methods cons :: Storage (T y) => y -> T y -> T y Source # takeWhile :: Storage (T y) => (y -> Bool) -> T y -> T y Source # dropWhile :: Storage (T y) => (y -> Bool) -> T y -> T y Source # span :: Storage (T y) => (y -> Bool) -> T y -> (T y, T y) Source # viewL :: Storage (T y) => T y -> Maybe (y, T y) Source # viewR :: Storage (T y) => T y -> Maybe (T y, y) Source # zipWithAppend :: Storage (T y) => (y -> y -> y) -> T y -> T y -> T y Source # map :: (Storage (T y0), Storage (T y1)) => (y0 -> y1) -> T y0 -> T y1 Source # scanL :: (Storage (T y0), Storage (T y1)) => (y1 -> y0 -> y1) -> y1 -> T y0 -> T y1 Source # crochetL :: (Storage (T y0), Storage (T y1)) => (y0 -> s -> Maybe (y1, s)) -> s -> T y0 -> T y1 Source #
Write0 T Source #
Instance details Defined in Synthesizer.Generic.Signal Methods fromList :: Storage (T y) => LazySize -> [y] -> T y Source # repeat :: Storage (T y) => LazySize -> y -> T y Source # replicate :: Storage (T y) => LazySize -> Int -> y -> T y Source # iterate :: Storage (T y) => LazySize -> (y -> y) -> y -> T y Source # iterateAssociative :: Storage (T y) => LazySize -> (y -> y -> y) -> y -> T y Source # unfoldR :: Storage (T y) => LazySize -> (s -> Maybe (y, s)) -> s -> T y Source #
Write T y Source #
Instance details Defined in Synthesizer.ChunkySize.Signal Methods unfoldRN :: T0 -> (s -> Maybe (y, s)) -> s -> T y Source #
Read T y Source #
Instance details Defined in Synthesizer.Generic.Signal
Transform T y Source #
Instance details Defined in Synthesizer.Generic.Signal
Write T y Source #
Instance details Defined in Synthesizer.Generic.Signal
C y yv => C y (T yv) Source #
Instance details Defined in Synthesizer.State.Signal Methods (*>) :: y -> T yv -> T yv #
Monoid (T y) Source #
Instance details Defined in Synthesizer.State.Signal Methods mempty :: T y # mappend :: T y -> T y -> T y # mconcat :: [T y] -> T y #
Semigroup (T y) Source #
Instance details Defined in Synthesizer.State.Signal Methods (<>) :: T y -> T y -> T y # sconcat :: NonEmpty (T y) -> T y # stimes :: Integral b => b -> T y -> T y #
Show y => Show (T y) Source #
Instance details Defined in Synthesizer.State.Signal Methods showsPrec :: Int -> T y -> ShowS # show :: T y -> String # showList :: [T y] -> ShowS #
Eq y => Eq (T y) Source #
Instance details Defined in Synthesizer.State.Signal Methods (==) :: T y -> T y -> Bool # (/=) :: T y -> T y -> Bool #
C y => C (T y) Source #
Instance details Defined in Synthesizer.State.Signal Methods zero :: T y # (+) :: T y -> T y -> T y # (-) :: T y -> T y -> T y # negate :: T y -> T y #
Read (T y) Source #
Instance details Defined in Synthesizer.ChunkySize.Cut Methods length :: T y -> T0 Source #
Transform (T y) Source #
Instance details Defined in Synthesizer.ChunkySize.Cut Methods take :: T0 -> T y -> T y Source # drop :: T0 -> T y -> T y Source # splitAt :: T0 -> T y -> (T y, T y) Source #
NFData y => NormalForm (T y) Source #
Instance details Defined in Synthesizer.Generic.Cut Methods evaluateHead :: T y -> () Source #
Read (T y) Source #
Instance details Defined in Synthesizer.Generic.Cut Methods null :: T y -> Bool Source # length :: T y -> Int Source #
Transform (T y) Source #
Instance details Defined in Synthesizer.Generic.Cut Methods take :: Int -> T y -> T y Source # drop :: Int -> T y -> T y Source # dropMarginRem :: Int -> Int -> T y -> (Int, T y) Source # splitAt :: Int -> T y -> (T y, T y) Source # reverse :: T y -> T y Source #
Storage (T y) Source #
Instance details Defined in Synthesizer.Generic.Signal Associated Types data Constraints (T y) Source # Methods constraints :: T y -> Constraints (T y) Source #
type ProcessOf T Source #
Instance details Defined in Synthesizer.Causal.Process type ProcessOf T = T
data Constraints (T y) Source #
Instance details Defined in Synthesizer.Generic.Signal data Constraints (T y) = StateConstraints

runViewL :: T y -> (forall s. (s -> Maybe (y, s)) -> s -> x) -> x Source #

It is a common pattern to use switchL or viewL in a loop in order to traverse a signal. However this needs repeated packing and unpacking of the viewL function and the state. It seems that GHC is not clever enough to detect, that the view function does not change. With runViewL you can unpack a stream once and use an efficient viewL in the loop.

runSwitchL :: T y -> (forall s. (forall z. z -> (y -> s -> z) -> s -> z) -> s -> x) -> x Source #

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 #

fromStrictStorableSignal :: Storable a => Vector a -> T a Source #

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

toStrictStorableSignal :: Storable a => Int -> T a -> Vector a Source #

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

fromPiecewiseConstant :: (C time, Integral time) => T time 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 #