Control.Effects.Signal

Documentation

class MonadEffect (Signal a b) m => MonadEffectSignal a b m | m a -> b where

This class allows you to "throw" a signal. For the most part signals are the same as checked exceptions. The difference here is that the handler has the option to provide the value that will be the result _of calling the signal function_. This effectibvely allows you to have recoverable exceptions at the call site, instead of just at the handling site.

This class can be considered an alias for MonadEffect (Signal a b) so your code isn't required to provide any instances.

Methods

signal :: a -> m b

There are no restrictions on the type of values that can be thrown or returned.

Instances

(MonadEffectSignal a b m, MonadTrans t, Monad (t m)) => MonadEffectSignal a b (t m)

Methods

signal :: a -> t m b

Monad m => MonadEffectSignal e Void (ExceptT e m)

Methods

signal :: e -> ExceptT e m Void

data ResumeOrBreak b c

The handle function will return a value of this type.

Constructors

Resume b

Give a value to the caller of signal and keep going.

Break c

Continue the execution after the handler. The handler will return this value

throwSignal :: Throws a m => a -> m b

Throw a signal with no possible recovery. The handler is forced to only return the Break constructor because it cannot construct a Void value.

If this function is used along with handleAsException, this module behaves like regular checked exceptions.

handleSignal :: Monad m => (a -> m (ResumeOrBreak b c)) -> EffectHandler (Signal a b) (ExceptT c m) c -> m c

Handle signals of a computation. The handler function has the option to provide a value to the caller of signal and continue execution there, or do what regular exception handlers do and continue execution after the handler.

handleAsException :: Monad m => (a -> m c) -> EffectHandler (Signal a b) (ExceptT c m) c -> m c

This handler can only behave like a regular exception handler. If used along with throwSignal this module behaves like regular checked exceptions.

type Throws e m = MonadEffectSignal e Void m

handleException :: Monad m => (a -> m c) -> ExceptT a m c -> m c

In case only throwSignal is used then the function signatures will have a Throws a m constraint or, equivalently, a MonadEffectSignal a Void m constraint. In those cases you can use this function to handle their exceptions. This function will not work for handing other signals because ExceptT doesn't satisfy other constraints.

The advantage of using this handler is that your inferred transformer stack will have one less layer which can potentially lead to slight performance increases.

handleToEither :: ExceptT e m a -> m (Either e a)

See documentation for handleException. This handler gives you an Either.

module Control.Effects