Data.MonadicStreamFunction.Util

Useful auxiliary functions and definitions.

Streams and sinks

type MStream m a = MSF m () a

A stream is an MSF that produces outputs, while ignoring the input. It can obtain the values from a monadic context.

type MSink m a = MSF m a ()

A sink is an MSF that consumes inputs, while producing no output. It can consume the values with side effects.

Analogues of map and fmap

mapMaybeS :: Monad m => MSF m a b -> MSF m (Maybe a) (Maybe b)

Apply an MSF to every input. Freezes temporarily if the input is Nothing, and continues as soon as a Just is received.

Adding side effects

withSideEffect :: Monad m => (a -> m b) -> MSF m a a

Applies a function to produce an additional side effect and passes the input unchanged.

withSideEffect_ :: Monad m => m b -> MSF m a a

Produces an additional side effect and passes the input unchanged.

Delays

iPre

Arguments

:: Monad m

=> a

First output

-> MSF m a a

Delay a signal by one sample.

iPost :: Monad m => b -> MSF m a b -> MSF m a b

Preprends a fixed output to an MSF. The first input is completely ignored.

next :: Monad m => b -> MSF m a b -> MSF m a b

Preprends a fixed output to an MSF, shifting the output.

fifo :: Monad m => MSF m [a] (Maybe a)

Buffers and returns the elements in FIFO order, returning Nothing whenever the buffer is empty.

Folding

Folding for VectorSpace instances

count :: (Num n, Monad m) => MSF m a n

Count the number of simulation steps. Produces 1, 2, 3,...

sumS :: (VectorSpace v s, Monad m) => MSF m v v

Sums the inputs, starting from zero.

sumFrom :: (VectorSpace v s, Monad m) => v -> MSF m v v

Sums the inputs, starting from an initial vector.

Folding for monoids

mappendS :: (Monoid n, Monad m) => MSF m n n

Accumulate the inputs, starting from mempty.

mappendFrom :: (Monoid n, Monad m) => n -> MSF m n n

Accumulate the inputs, starting from an initial monoid value.

Generic folding / accumulation

accumulateWith :: Monad m => (a -> s -> s) -> s -> MSF m a s

Applies a function to the input and an accumulator, outputting the updated accumulator. Equal to f s0 -> feedback s0 $ arr (uncurry f >>> dup).

mealy :: Monad m => (a -> s -> (b, s)) -> s -> MSF m a b

Applies a transfer function to the input and an accumulator, returning the updated accumulator and output.

Unfolding

unfold :: Monad m => (a -> (b, a)) -> a -> MSF m () b

Generate outputs using a step-wise generation function and an initial value.

repeatedly :: Monad m => (a -> a) -> a -> MSF m () a

Generate outputs using a step-wise generation function and an initial value. Version of unfold in which the output and the new accumulator are the same. Should be equal to f a -> unfold (f >>> dup) a.

Debugging

trace :: Show a => String -> MSF IO a a

Outputs every input sample, with a given message prefix.

traceWith :: (Monad m, Show a) => (String -> m ()) -> String -> MSF m a a

Outputs every input sample, with a given message prefix, using an auxiliary printing function.

traceWhen :: (Monad m, Show a) => (a -> Bool) -> (String -> m ()) -> String -> MSF m a a

Outputs every input sample, with a given message prefix, using an auxiliary printing function, when a condition is met.

pauseOn :: Show a => (a -> Bool) -> String -> MSF IO a a

Outputs every input sample, with a given message prefix, when a condition is met, and waits for some input / enter to continue.