Safe Haskell	None
Language	Haskell2010

Control.Effects.Signal

Description

This effect 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 effectively allows you to have recoverable exceptions at the throw site, instead of just at the handling site.

Synopsis

data ResumeOrBreak b c
- = Resume b
- | Break c
newtype Signal a b m = SignalMethods {
- _signal :: a -> m b
}
throwSignal :: MonadEffect (Throw a) m => a -> m b
handleSignal :: forall a b c m. Monad m => (a -> m (ResumeOrBreak b c)) -> RuntimeImplemented (Signal a b) (ExceptT c m) c -> m c
type Throw e = Signal e Void
handleException :: forall a c m. Monad m => (a -> m c) -> ExceptT a m c -> m c
handleToEither :: forall e a m. ExceptT e m a -> m (Either e a)
module Control.Effects
module Control.Monad.Trans.Except
newtype MaybeT (m :: Type -> Type) a = MaybeT {
- runMaybeT :: m (Maybe a)
}
discardAllExceptions :: MaybeT m a -> m (Maybe a)
showAllExceptions :: Functor m => ExceptT SomeSignal m a -> m (Either Text a)
newtype HandleException e m = HandleExceptionMethods {
- _handleWithoutDiscarding :: forall a. (e -> m a) -> m a -> m a
}
handleWithoutDiscarding :: forall e m a. MonadEffect (HandleException e) m => (e -> m a) -> m a -> m a
handleToEitherRecursive :: MonadEffect (HandleException e) m => m a -> m (Either e a)
data SomeSignal
signal :: forall a b m. MonadEffect (Signal a b) m => a -> m b

Documentation

data ResumeOrBreak b c Source #

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

newtype Signal a b m Source #

Constructors

SignalMethods
Fields _signal :: a -> m b

Instances

Effect (Signal a b) Source #
Instance details Defined in Control.Effects.Signal Associated Types type CanLift (Signal a b) t :: Constraint Source # type ExtraConstraint (Signal a b) m :: Constraint Source # Methods liftThrough :: (CanLift (Signal a b) t, Monad m, Monad (t m)) => Signal a b m -> Signal a b (t m) Source # mergeContext :: Monad m => m (Signal a b m) -> Signal a b m Source #
(TypeError (UnhandledError a b) :: Constraint) => MonadEffect (Signal a b) IO Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal a b IO Source #
Monad m => MonadEffect (Signal a b) (MaybeT m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal a b (MaybeT m) Source #
(Show e, Monad m) => MonadEffect (Signal e b) (ExceptT SomeSignal m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal e b (ExceptT SomeSignal m) Source #
Monad m => MonadEffect (Signal e b) (ExceptT e m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal e b (ExceptT e m) Source #
(Monad m, b ~ c) => MonadEffect (Signal a c) (RuntimeImplemented (Signal a b) m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal a c (RuntimeImplemented (Signal a b) m) Source #
Generic (Signal a b m) Source #
Instance details Defined in Control.Effects.Signal Associated Types type Rep (Signal a b m) :: Type -> Type # Methods from :: Signal a b m -> Rep (Signal a b m) x # to :: Rep (Signal a b m) x -> Signal a b m #
type CanLift (Signal a b) t Source #
Instance details Defined in Control.Effects.Signal type CanLift (Signal a b) t = MonadTrans t
type ExtraConstraint (Signal a b) m Source #
Instance details Defined in Control.Effects.Signal type ExtraConstraint (Signal a b) m = ()
type Rep (Signal a b m) Source #
Instance details Defined in Control.Effects.Signal type Rep (Signal a b m) = D1 (MetaData "Signal" "Control.Effects.Signal" "simple-effects-0.13.0.0-CkkfVtQm23r7lDFbMuonrn" True) (C1 (MetaCons "SignalMethods" PrefixI True) (S1 (MetaSel (Just "_signal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (a -> m b))))

throwSignal :: MonadEffect (Throw a) m => a -> m b Source #

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 :: forall a b c m. Monad m => (a -> m (ResumeOrBreak b c)) -> RuntimeImplemented (Signal a b) (ExceptT c m) c -> m c Source #

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.

type Throw e = Signal e Void Source #

handleException :: forall a c m. Monad m => (a -> m c) -> ExceptT a m c -> m c Source #

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

handleToEither :: forall e a m. ExceptT e m a -> m (Either e a) Source #

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

module Control.Effects

module Control.Monad.Trans.Except

newtype MaybeT (m :: Type -> Type) a #

The parameterizable maybe monad, obtained by composing an arbitrary monad with the Maybe monad.

Computations are actions that may produce a value or exit.

The return function yields a computation that produces that value, while >>= sequences two subcomputations, exiting if either computation does.

Constructors

MaybeT
Fields runMaybeT :: m (Maybe a)

Instances

MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadTransControl MaybeT
Instance details Defined in Control.Monad.Trans.Control Associated Types type StT MaybeT a :: Type # Methods liftWith :: Monad m => (Run MaybeT -> m a) -> MaybeT m a # restoreT :: Monad m => m (StT MaybeT a) -> MaybeT m a #
RunnableTrans MaybeT Source #
Instance details Defined in Control.Monad.Runnable Associated Types type TransformerState MaybeT m :: Type Source # type TransformerResult MaybeT a :: Type Source # Methods currentTransState :: Monad m => MaybeT m (TransformerState MaybeT m) Source # restoreTransState :: Monad m => TransformerResult MaybeT a -> MaybeT m a Source # runTransformer :: Monad m => MaybeT m a -> TransformerState MaybeT m -> m (TransformerResult MaybeT a) Source #
MonadSplit g m => MonadSplit g (MaybeT m)
Instance details Defined in Control.Monad.Random.Class Methods getSplit :: MaybeT m g #
MonadBaseControl b m => MonadBaseControl b (MaybeT m)
Instance details Defined in Control.Monad.Trans.Control Associated Types type StM (MaybeT m) a :: Type # Methods liftBaseWith :: (RunInBase (MaybeT m) b -> b a) -> MaybeT m a # restoreM :: StM (MaybeT m) a -> MaybeT m a #
MonadBase b m => MonadBase b (MaybeT m)
Instance details Defined in Control.Monad.Base Methods liftBase :: b α -> MaybeT m α #
MonadState s m => MonadState s (MaybeT m)
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
MonadReader r m => MonadReader r (MaybeT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadEffect Bracket m => MonadEffect Bracket (MaybeT m) Source #
Instance details Defined in Control.Effects.Resource Methods effect :: Bracket (MaybeT m) Source #
Monad m => Monad (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a # fail :: String -> MaybeT m a #
Functor m => Functor (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
MonadFix m => MonadFix (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mfix :: (a -> MaybeT m a) -> MaybeT m a #
Monad m => MonadFail (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a #
(Functor m, Monad m) => Applicative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a # (<>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # (>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Foldable f => Foldable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] # null :: MaybeT f a -> Bool # length :: MaybeT f a -> Int # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # sum :: Num a => MaybeT f a -> a # product :: Num a => MaybeT f a -> a #
Traversable f => Traversable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
Monad m => MonadPlus (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadRandom m => MonadRandom (MaybeT m)
Instance details Defined in Control.Monad.Random.Class Methods getRandomR :: Random a => (a, a) -> MaybeT m a # getRandom :: Random a => MaybeT m a # getRandomRs :: Random a => (a, a) -> MaybeT m [a] # getRandoms :: Random a => MaybeT m [a] #
MonadInterleave m => MonadInterleave (MaybeT m)
Instance details Defined in Control.Monad.Random.Class Methods interleave :: MaybeT m a -> MaybeT m a #
Contravariant m => Contravariant (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a -> b) -> MaybeT m b -> MaybeT m a # (>$) :: b -> MaybeT m b -> MaybeT m a #
Eq1 m => Eq1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftEq :: (a -> b -> Bool) -> MaybeT m a -> MaybeT m b -> Bool #
Ord1 m => Ord1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftCompare :: (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering #
Read1 m => Read1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeT m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MaybeT m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MaybeT m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MaybeT m a] #
Show1 m => Show1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeT m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MaybeT m a] -> ShowS #
MonadZip m => MonadZip (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzip :: MaybeT m a -> MaybeT m b -> MaybeT m (a, b) # mzipWith :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # munzip :: MaybeT m (a, b) -> (MaybeT m a, MaybeT m b) #
(Functor m, Monad m) => Alternative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<\|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
MonadThrow m => MonadThrow (MaybeT m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> MaybeT m a #
MonadCatch m => MonadCatch (MaybeT m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadMask m => MonadMask (MaybeT m)	Since: exceptions-0.10.0
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #
PrimMonad m => PrimMonad (MaybeT m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (MaybeT m) :: Type # Methods primitive :: (State# (PrimState (MaybeT m)) -> (#State# (PrimState (MaybeT m)), a#)) -> MaybeT m a #
(Eq1 m, Eq a) => Eq (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Ord1 m, Ord a) => Ord (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods compare :: MaybeT m a -> MaybeT m a -> Ordering # (<) :: MaybeT m a -> MaybeT m a -> Bool # (<=) :: MaybeT m a -> MaybeT m a -> Bool # (>) :: MaybeT m a -> MaybeT m a -> Bool # (>=) :: MaybeT m a -> MaybeT m a -> Bool # max :: MaybeT m a -> MaybeT m a -> MaybeT m a # min :: MaybeT m a -> MaybeT m a -> MaybeT m a #
(Read1 m, Read a) => Read (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods readsPrec :: Int -> ReadS (MaybeT m a) # readList :: ReadS [MaybeT m a] # readPrec :: ReadPrec (MaybeT m a) # readListPrec :: ReadPrec [MaybeT m a] #
(Show1 m, Show a) => Show (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods showsPrec :: Int -> MaybeT m a -> ShowS # show :: MaybeT m a -> String # showList :: [MaybeT m a] -> ShowS #
Monad m => MonadEffect (Signal a b) (MaybeT m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal a b (MaybeT m) Source #
type StT MaybeT a
Instance details Defined in Control.Monad.Trans.Control type StT MaybeT a = Maybe a
type TransformerState MaybeT m Source #
Instance details Defined in Control.Monad.Runnable type TransformerState MaybeT m = ()
type TransformerResult MaybeT a Source #
Instance details Defined in Control.Monad.Runnable type TransformerResult MaybeT a = Maybe a
type PrimState (MaybeT m)
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m
type StM (MaybeT m) a
Instance details Defined in Control.Monad.Trans.Control type StM (MaybeT m) a = ComposeSt MaybeT m a

discardAllExceptions :: MaybeT m a -> m (Maybe a) Source #

Discard all the Throw and Signal effects. If any exception was thrown the result will be Nothing.

showAllExceptions :: Functor m => ExceptT SomeSignal m a -> m (Either Text a) Source #

Satisfies all the Throw and Signal constraints if they all throw Showable exceptions. The first thrown exception will be shown and returned as a Left result.

newtype HandleException e m Source #

Constructors

HandleExceptionMethods
Fields _handleWithoutDiscarding :: forall a. (e -> m a) -> m a -> m a

Instances

Effect (HandleException e) Source #
Instance details Defined in Control.Effects.Signal Associated Types type CanLift (HandleException e) t :: Constraint Source # type ExtraConstraint (HandleException e) m :: Constraint Source # Methods liftThrough :: (CanLift (HandleException e) t, Monad m, Monad (t m)) => HandleException e m -> HandleException e (t m) Source # mergeContext :: Monad m => m (HandleException e m) -> HandleException e m Source #
Monad m => MonadEffect (HandleException e) (ExceptT e m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: HandleException e (ExceptT e m) Source #
type CanLift (HandleException e) t Source #
Instance details Defined in Control.Effects.Signal type CanLift (HandleException e) t = RunnableTrans t
type ExtraConstraint (HandleException e) m Source #
Instance details Defined in Control.Effects.Signal type ExtraConstraint (HandleException e) m = ()

handleWithoutDiscarding :: forall e m a. MonadEffect (HandleException e) m => (e -> m a) -> m a -> m a Source #

Use this function to handle exceptions without discarding the Throw effect. You'll want to use this if you're writing a recursive function. Using the regular handlers in that case will result with infinite types.

Since this function doesn't discard constraints, you still need to handle the exception on the whole computation.

Here's a slightly contrived example.

  data NotFound = NotFound
  data Tree a = Leaf a | Node (Tree a) (Tree a)
  data Step = GoLeft | GoRight
  findIndex :: (Handles NotFound m, Eq a) => a -> Tree a -> m [Step]
  findIndex x (Leaf a) | x == a    = return []
                       | otherwise = throwSignal NotFound
  findIndex x (Node l r) = ((GoLeft :) $ findIndex x l)
      & handleWithoutDiscarding (NotFound -> (GoRight :) $ findIndex x r)

Note: When you finally handle the exception effect, the order in which you handle it and other effects determines whether handleWithoutDiscarding rolls back other effects if an exception occured or it preserves all of them up to the point of the exception. Handling exceptions last and handling them first will produce the former and latter behaviour respectively.

handleToEitherRecursive :: MonadEffect (HandleException e) m => m a -> m (Either e a) Source #

handleToEither that doesn't discard Throws constraints. See documentation for handleWithoutDiscarding.

data SomeSignal Source #

Instances

Eq SomeSignal Source #
Instance details Defined in Control.Effects.Signal Methods (==) :: SomeSignal -> SomeSignal -> Bool # (/=) :: SomeSignal -> SomeSignal -> Bool #
Ord SomeSignal Source #
Instance details Defined in Control.Effects.Signal Methods compare :: SomeSignal -> SomeSignal -> Ordering # (<) :: SomeSignal -> SomeSignal -> Bool # (<=) :: SomeSignal -> SomeSignal -> Bool # (>) :: SomeSignal -> SomeSignal -> Bool # (>=) :: SomeSignal -> SomeSignal -> Bool # max :: SomeSignal -> SomeSignal -> SomeSignal # min :: SomeSignal -> SomeSignal -> SomeSignal #
Read SomeSignal Source #
Instance details Defined in Control.Effects.Signal Methods readsPrec :: Int -> ReadS SomeSignal # readList :: ReadS [SomeSignal] # readPrec :: ReadPrec SomeSignal # readListPrec :: ReadPrec [SomeSignal] #
Show SomeSignal Source #
Instance details Defined in Control.Effects.Signal Methods showsPrec :: Int -> SomeSignal -> ShowS # show :: SomeSignal -> String # showList :: [SomeSignal] -> ShowS #
(Show e, Monad m) => MonadEffect (Signal e b) (ExceptT SomeSignal m) Source #
Instance details Defined in Control.Effects.Signal Methods effect :: Signal e b (ExceptT SomeSignal m) Source #

signal :: forall a b m. MonadEffect (Signal a b) m => a -> m b Source #