Control.Monad.Trans.Continue

This monad transformer extends a monad with the ability to handle multiple terminating cases.

A sequence of actions terminates normally, producing a value, only if none of the actions in the sequence are Stop or Failure. If one action is Stop or Failure, the rest of the sequence is skipped and the composite action exits with that result.

ContinueT

newtype ContinueT x m a

A monad transfomer that extends the Continue monad.

Computations are stopes, failures or normal values.

The return function returns a normal value, while >>= exits on the first stop or failure.

Constructors

ContinueT

Fields

• runContinueT :: m (Continue x a)

Instances

MonadTrans (ContinueT x)

Methods

lift :: Monad m => m a -> ContinueT x m a

Monad m => Monad (ContinueT x m)

Methods

(>>=) :: ContinueT x m a -> (a -> ContinueT x m b) -> ContinueT x m b

(>>) :: ContinueT x m a -> ContinueT x m b -> ContinueT x m b

return :: a -> ContinueT x m a

fail :: String -> ContinueT x m a

Functor m => Functor (ContinueT x m)

Methods

fmap :: (a -> b) -> ContinueT x m a -> ContinueT x m b

(<$) :: a -> ContinueT x m b -> ContinueT x m a

(Applicative m, Monad m) => Applicative (ContinueT x m)

Methods

pure :: a -> ContinueT x m a

(<*>) :: ContinueT x m (a -> b) -> ContinueT x m a -> ContinueT x m b

(*>) :: ContinueT x m a -> ContinueT x m b -> ContinueT x m b

(<*) :: ContinueT x m a -> ContinueT x m b -> ContinueT x m a

Foldable m => Foldable (ContinueT x m)

Methods

fold :: Monoid m => ContinueT x m m -> m

foldMap :: Monoid m => (a -> m) -> ContinueT x m a -> m

foldr :: (a -> b -> b) -> b -> ContinueT x m a -> b

foldr' :: (a -> b -> b) -> b -> ContinueT x m a -> b

foldl :: (b -> a -> b) -> b -> ContinueT x m a -> b

foldl' :: (b -> a -> b) -> b -> ContinueT x m a -> b

foldr1 :: (a -> a -> a) -> ContinueT x m a -> a

foldl1 :: (a -> a -> a) -> ContinueT x m a -> a

toList :: ContinueT x m a -> [a]

null :: ContinueT x m a -> Bool

length :: ContinueT x m a -> Int

elem :: Eq a => a -> ContinueT x m a -> Bool

maximum :: Ord a => ContinueT x m a -> a

minimum :: Ord a => ContinueT x m a -> a

sum :: Num a => ContinueT x m a -> a

product :: Num a => ContinueT x m a -> a

Traversable m => Traversable (ContinueT x m)

Methods

traverse :: Applicative f => (a -> f b) -> ContinueT x m a -> f (ContinueT x m b)

sequenceA :: Applicative f => ContinueT x m (f a) -> f (ContinueT x m a)

mapM :: Monad m => (a -> m b) -> ContinueT x m a -> m (ContinueT x m b)

sequence :: Monad m => ContinueT x m (m a) -> m (ContinueT x m a)

MonadIO m => MonadIO (ContinueT x m)

Methods

liftIO :: IO a -> ContinueT x m a

stop :: Applicative m => ContinueT x m a

Singal a stop.

• runContinueT stop = return Stop

failure :: Applicative m => x -> ContinueT x m a

Singal a failure value x.

• runContinueT (failure x) = return (Failure x)

continue :: Applicative m => a -> ContinueT x m a

Singal a continue value x.

• runContinueT (continue x) = return (Continue x)

hoistContinue :: Monad m => Continue x a -> ContinueT x m a

Lift an Continue into an ContinueT

mapContinueT :: (m (Continue x a) -> n (Continue y b)) -> ContinueT x m a -> ContinueT y n b

Map the unwrapped computation using the given function.

runContinueT (mapContinueT f m) = f (runContinueT m)

bimapContinueT :: Functor m => (x -> y) -> (a -> b) -> ContinueT x m a -> ContinueT y m b

Map over both failure and continue.

firstContinueT :: Functor m => (x -> y) -> ContinueT x m a -> ContinueT y m a

Map over failure.

secondContinueT :: Functor m => (a -> b) -> ContinueT x m a -> ContinueT x m b

Map over continue.

mapFailure :: Functor m => (x -> y) -> ContinueT x m a -> ContinueT y m a

Map over failure.

stopFromNothing :: Applicative m => Maybe a -> ContinueT x m a

Lift an Maybe into an ContinueT

• runContinueT (stopFromNothing Nothing) = return Stop

• runContinueT (stopFromNothing (Just a)) = return (Continue a)

hoistEither :: Applicative m => Either x a -> ContinueT x m a

Lift an Either into an ContinueT

• runContinueT (hoistEither (Left x)) = return (Failure x)

• runContinueT (hoistEither (Right a)) = return (Continue a)

EitherT / ExceptT extensions

liftEitherT :: Monad m => ExceptT x m a -> ContinueT x m a

Utility function for EitherT pattern synonym over ExceptT

liftExceptT :: Monad m => ExceptT x m a -> ContinueT x m a

Convert an ExceptT into an ContinueT

• runExceptT (return (Left x)) = failure x

• runExceptT (return (Right a)) = continue a

runToEitherT :: Monad m => ContinueT x m () -> ExceptT x m ()

Utility function for EitherT pattern synonym over ExceptT

runToExceptT :: Monad m => ContinueT x m () -> ExceptT x m ()

Convert an ContinueT into an ExceptT

• runExceptT (runToExceptT (continue a)) = return (Right a)

• runExceptT (runToExceptT (failure x)) = return (Left x)

• runExceptT (runToExceptT stop) = return (Right ())