Control.Monad.Trans.MSF.Maybe

The Maybe monad is very versatile. It can stand for default arguments, for absent values, and for (nondescript) exceptions. The latter viewpoint is most natural in the context of MSFs.

Throwing Nothing as an exception ("exiting")

exit :: Monad m => MSF (MaybeT m) a b

Throw the exception immediately.

exitWhen :: Monad m => (a -> Bool) -> MSF (MaybeT m) a a

Throw the exception when the condition becomes true on the input.

exitIf :: Monad m => MSF (MaybeT m) Bool ()

Exit when the incoming value is True.

maybeExit :: Monad m => MSF (MaybeT m) (Maybe a) a

Just a is passed along, Nothing causes the whole MSF to exit.

inMaybeT :: Monad m => MSF (MaybeT m) (Maybe a) a

Embed a Maybe value in the MaybeT layer. Identical to maybeExit.

Catching Maybe exceptions

untilMaybe :: Monad m => MSF m a b -> MSF m b Bool -> MSF (MaybeT m) a b

Run the first msf until the second one produces True from the output of the first.

catchMaybe :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF m a b -> MSF m a b

When an exception occurs in the first msf, the second msf is executed from there.

Converting to and from MaybeT

listToMaybeS :: Monad m => [b] -> MSF (MaybeT m) a b

Converts a list to an MSF in MaybeT, which outputs an element of the list at each step, throwing Nothing when the list ends.

Running MaybeT

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

Remove the MaybeT layer by outputting Nothing when the exception occurs. The continuation in which the exception occurred is then tested on the next input.

runMaybeS'' :: Monad m => MSF (MaybeT m) a b -> MSF m a (Maybe b)

Different implementation, to study performance.

reactimateMaybe :: (Functor m, Monad m) => MSF (MaybeT m) () () -> m ()

Reactimates an MSF in the MaybeT monad until it throws Nothing.

embed_ :: (Functor m, Monad m) => MSF m a () -> [a] -> m ()

Run an MSF fed from a list, discarding results. Useful when one needs to combine effects and streams (i.e., for testing purposes).

module Control.Monad.Trans.Maybe

maybeToExceptS :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF (ExceptT () m) a b

Whenever Nothing is thrown, throw '()' instead.