Copyright	(c) Ivan Perez and Manuel Baerenz 2016
License	BSD3
Maintainer	ivan.perez@keera.co.uk
Safe Haskell	Safe-Inferred
Language	Haskell2010

Control.Monad.Trans.MSF.Maybe

Description

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.

Synopsis

exit :: Monad m => MSF (MaybeT m) a b
exitWhen :: Monad m => (a -> Bool) -> MSF (MaybeT m) a a
exitIf :: Monad m => MSF (MaybeT m) Bool ()
maybeExit :: Monad m => MSF (MaybeT m) (Maybe a) a
inMaybeT :: Monad m => MSF (MaybeT m) (Maybe a) a
untilMaybe :: Monad m => MSF m a b -> MSF m b Bool -> MSF (MaybeT m) a b
catchMaybe :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF m a b -> MSF m a b
exceptToMaybeS :: (Functor m, Monad m) => MSF (ExceptT e m) a b -> MSF (MaybeT m) a b
listToMaybeS :: (Functor m, Monad m) => [b] -> MSF (MaybeT m) a b
runMaybeS :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF m a (Maybe b)
reactimateMaybe :: (Functor m, Monad m) => MSF (MaybeT m) () () -> m ()
embed_ :: (Functor m, Monad m) => MSF m a () -> [a] -> m ()
newtype MaybeT (m :: Type -> Type) a = MaybeT {
- runMaybeT :: m (Maybe a)
}
mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
hoistMaybe :: forall (m :: Type -> Type) b. Applicative m => Maybe b -> MaybeT m b
maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
maybeToExceptS :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF (ExceptT () m) a b

Documentation

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

Throw the exception immediately.

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

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

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

Exit when the incoming value is True.

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

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

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

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

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

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 Source #

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

exceptToMaybeS :: (Functor m, Monad m) => MSF (ExceptT e m) a b -> MSF (MaybeT m) a b Source #

Convert exceptions into Nothing, discarding the exception value.

listToMaybeS :: (Functor m, Monad m) => [b] -> MSF (MaybeT m) a b Source #

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

runMaybeS :: (Functor m, Monad m) => MSF (MaybeT m) a b -> MSF m a (Maybe b) Source #

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.

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

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

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

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

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

Instances details

MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadSplit g m => MonadSplit g (MaybeT m)
Instance details Defined in Control.Monad.Random.Class Methods getSplit :: MaybeT m g #
Functor m => Generic1 (MaybeT m :: Type -> Type)
Instance details Defined in Control.Monad.Trans.Maybe Associated Types type Rep1 (MaybeT m) :: k -> Type # Methods from1 :: forall (a :: k). MaybeT m a -> Rep1 (MaybeT m) a # to1 :: forall (a :: k). Rep1 (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 α #
MonadInterleave m => MonadInterleave (MaybeT m)
Instance details Defined in Control.Monad.Random.Class Methods interleave :: MaybeT m 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] #
Monad m => MonadFail (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> 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 #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
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) #
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 # 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 #
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 #
Contravariant m => Contravariant (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a' -> a) -> MaybeT m a -> MaybeT m a' # (>$) :: b -> MaybeT m b -> MaybeT m 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) #
(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] #
(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 #
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 #
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 #
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 #
Generic (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Associated Types type Rep (MaybeT m a) :: Type -> Type # Methods from :: MaybeT m a -> Rep (MaybeT m a) x # to :: Rep (MaybeT m a) x -> 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 #
(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 #
type Rep1 (MaybeT m :: Type -> Type)
Instance details Defined in Control.Monad.Trans.Maybe type Rep1 (MaybeT m :: Type -> Type) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.0" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 Maybe)))
type Rep (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe type Rep (MaybeT m a) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.0" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Maybe a)))))

mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b #

Transform the computation inside a MaybeT.

runMaybeT (mapMaybeT f m) = f (runMaybeT m)

hoistMaybe :: forall (m :: Type -> Type) b. Applicative m => Maybe b -> MaybeT m b #

Convert a Maybe computation to MaybeT.

maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a #

Convert a MaybeT computation to ExceptT, with a default exception value.

exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a #

Convert a ExceptT computation to MaybeT, discarding the value of any exception.

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

Converts an MSF in MaybeT to an MSF in ExceptT. Whenever Nothing is thrown, throw () instead.