Control.Monad.Trans.MSF.Except

MSFs in the ExceptT monad are monadic stream functions that can throw exceptions, i.e. return an exception value instead of a continuation. This module gives ways to throw exceptions in various ways, and to handle them through a monadic interface.

Throwing exceptions

throwOnCond :: Monad m => (a -> Bool) -> e -> MSF (ExceptT e m) a a

Throw the exception e whenever the function evaluates to True.

throwOnCondM :: Monad m => (a -> m Bool) -> e -> MSF (ExceptT e m) a a

Variant of throwOnCond for Kleisli arrows. | Throws the exception when the input is True.

throwOn :: Monad m => e -> MSF (ExceptT e m) Bool ()

Throw the exception when the input is True.

throwOn' :: Monad m => MSF (ExceptT e m) (Bool, e) ()

Variant of throwOn, where the exception may change every tick.

throwMaybe :: Monad m => MSF (ExceptT e m) (Maybe e) (Maybe a)

When the input is 'Just e', throw the exception e. (Does not output any actual data.)

throwS :: Monad m => MSF (ExceptT e m) e a

Immediately throw the incoming exception.

throw :: Monad m => e -> MSF (ExceptT e m) a b

Immediately throw the given exception.

pass :: Monad m => MSF (ExceptT e m) a a

Do not throw an exception.

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

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

Catching exceptions

catchS :: Monad m => MSF (ExceptT e m) a b -> (e -> MSF m a b) -> MSF m a b

Catch an exception in an MSF. As soon as an exception occurs, the current continuation is replaced by a new MSF, the exception handler, based on the exception value. For exception catching where the handler can throw further exceptions, see MSFExcept further below.

untilE :: Monad m => MSF m a b -> MSF m b (Maybe e) -> MSF (ExceptT e m) a b

Similar to Yampa's delayed switching. Looses a b in case of an exception.

exceptS :: Monad m => MSF (ExceptT e m) a b -> MSF m a (Either e b)

Escape an ExceptT layer by outputting the exception whenever it occurs. If an exception occurs, the current MSF continuation is tested again on the next input.

inExceptT :: Monad m => MSF (ExceptT e m) (ExceptT e m a) a

Embed an ExceptT value inside the MSF. Whenever the input value is an ordinary value, it is passed on. If it is an exception, it is raised.

tagged :: Monad m => MSF (ExceptT e1 m) a b -> MSF (ExceptT e2 m) (a, e2) b

In case an exception occurs in the first argument, replace the exception by the second component of the tuple.

Monad interface for Exception MSFs

newtype MSFExcept m a b e

MSFs with an ExceptT transformer layer are in fact monads in the exception type.

• return corresponds to throwing an exception immediately.
• '(>>=)' is exception handling: The first value throws an exception, while the Kleisli arrow handles the exception and produces a new signal function, which can throw exceptions in a different type.

Constructors

MSFExcept

Fields

• runMSFExcept :: MSF (ExceptT e m) a b

Instances

Monad m => Monad (MSFExcept m a b)

Monad instance for MSFExcept. Bind uses the exception as the "return" value in the monad.

Methods

(>>=) :: MSFExcept m a b a -> (a -> MSFExcept m a b b) -> MSFExcept m a b b

(>>) :: MSFExcept m a b a -> MSFExcept m a b b -> MSFExcept m a b b

return :: a -> MSFExcept m a b a

fail :: String -> MSFExcept m a b a

Monad m => Functor (MSFExcept m a b)

Functor instance for MSFs on the Either monad. Fmapping is the same as applying a transformation to the Left values.

Methods

fmap :: (a -> b) -> MSFExcept m a b a -> MSFExcept m a b b

(<$) :: a -> MSFExcept m a b b -> MSFExcept m a b a

Monad m => Applicative (MSFExcept m a b)

Applicative instance for MSFs on the Either monad. The function pure throws an exception.

Methods

pure :: a -> MSFExcept m a b a

(<*>) :: MSFExcept m a b (a -> b) -> MSFExcept m a b a -> MSFExcept m a b b

(*>) :: MSFExcept m a b a -> MSFExcept m a b b -> MSFExcept m a b b

(<*) :: MSFExcept m a b a -> MSFExcept m a b b -> MSFExcept m a b a

try :: MSF (ExceptT e m) a b -> MSFExcept m a b e

An alias for the |MSFExcept| constructor, used to enter the |MSFExcept| monad context. Execute an MSF in ExceptT until it raises an exception.

currentInput :: Monad m => MSFExcept m e b e

Immediately throw the current input as an exception.

data Empty

The empty type. As an exception type, it encodes "no exception possible".

safely :: Monad m => MSFExcept m a b Empty -> MSF m a b

If no exception can occur, the MSF can be executed without the ExceptT layer.

safe :: Monad m => MSF m a b -> MSFExcept m a b e

An MSF without an ExceptT layer never throws an exception, and can thus have an arbitrary exception type.

once :: Monad m => (a -> m e) -> MSFExcept m a b e

Inside the MSFExcept monad, execute an action of the wrapped monad. This passes the last input value to the action, but doesn't advance a tick.

once_ :: Monad m => m e -> MSFExcept m a b e

Variant of once without input.

step :: Monad m => (a -> m (b, e)) -> MSFExcept m a b e

Advances a single tick with the given Kleisli arrow, and then throws an exception.

module Control.Monad.Trans.Except