{-# LANGUAGE CPP #-} #if __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Safe #-} #endif #if __GLASGOW_HASKELL__ >= 710 {-# LANGUAGE AutoDeriveTypeable #-} #endif ----------------------------------------------------------------------------- -- | -- Module : Control.Monad.Trans.Maybe -- Copyright : (c) 2007 Yitzak Gale, Eric Kidd -- License : BSD-style (see the file LICENSE) -- -- Maintainer : R.Paterson@city.ac.uk -- Stability : experimental -- Portability : portable -- -- The 'MaybeT' monad transformer extends a monad with the ability to exit -- the computation without returning a value. -- -- A sequence of actions produces a value only if all the actions in -- the sequence do. If one exits, the rest of the sequence is skipped -- and the composite action exits. -- -- For a variant allowing a range of exception values, see -- "Control.Monad.Trans.Except". ----------------------------------------------------------------------------- module Control.Monad.Trans.Maybe ( -- * The MaybeT monad transformer MaybeT(..), mapMaybeT, -- * Monad transformations maybeToExceptT, exceptToMaybeT, -- * Lifting other operations liftCallCC, liftCatch, liftListen, liftPass, ) where import Control.Monad.IO.Class import Control.Monad.Signatures import Control.Monad.Trans.Class import Control.Monad.Trans.Except (ExceptT(..)) import Data.Functor.Classes #if MIN_VERSION_base(4,12,0) import Data.Functor.Contravariant #endif import Control.Applicative import Control.Monad (MonadPlus(mzero, mplus), liftM) #if MIN_VERSION_base(4,9,0) import qualified Control.Monad.Fail as Fail #endif import Control.Monad.Fix (MonadFix(mfix)) #if MIN_VERSION_base(4,4,0) import Control.Monad.Zip (MonadZip(mzipWith)) #endif import Data.Foldable (Foldable(foldMap)) import Data.Maybe (fromMaybe) import Data.Traversable (Traversable(traverse)) -- | 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. newtype MaybeT m a = MaybeT { forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT :: m (Maybe a) } instance (Eq1 m) => Eq1 (MaybeT m) where liftEq :: forall a b. (a -> b -> Bool) -> MaybeT m a -> MaybeT m b -> Bool liftEq a -> b -> Bool eq (MaybeT m (Maybe a) x) (MaybeT m (Maybe b) y) = (Maybe a -> Maybe b -> Bool) -> m (Maybe a) -> m (Maybe b) -> Bool forall a b. (a -> b -> Bool) -> m a -> m b -> Bool forall (f :: * -> *) a b. Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool liftEq ((a -> b -> Bool) -> Maybe a -> Maybe b -> Bool forall a b. (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool forall (f :: * -> *) a b. Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool liftEq a -> b -> Bool eq) m (Maybe a) x m (Maybe b) y {-# INLINE liftEq #-} instance (Ord1 m) => Ord1 (MaybeT m) where liftCompare :: forall a b. (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering liftCompare a -> b -> Ordering comp (MaybeT m (Maybe a) x) (MaybeT m (Maybe b) y) = (Maybe a -> Maybe b -> Ordering) -> m (Maybe a) -> m (Maybe b) -> Ordering forall a b. (a -> b -> Ordering) -> m a -> m b -> Ordering forall (f :: * -> *) a b. Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering liftCompare ((a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering forall a b. (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering forall (f :: * -> *) a b. Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering liftCompare a -> b -> Ordering comp) m (Maybe a) x m (Maybe b) y {-# INLINE liftCompare #-} instance (Read1 m) => Read1 (MaybeT m) where liftReadsPrec :: forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeT m a) liftReadsPrec Int -> ReadS a rp ReadS [a] rl = (String -> ReadS (MaybeT m a)) -> Int -> ReadS (MaybeT m a) forall a. (String -> ReadS a) -> Int -> ReadS a readsData ((String -> ReadS (MaybeT m a)) -> Int -> ReadS (MaybeT m a)) -> (String -> ReadS (MaybeT m a)) -> Int -> ReadS (MaybeT m a) forall a b. (a -> b) -> a -> b $ (Int -> ReadS (m (Maybe a))) -> String -> (m (Maybe a) -> MaybeT m a) -> String -> ReadS (MaybeT m a) forall a t. (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t readsUnaryWith ((Int -> ReadS (Maybe a)) -> ReadS [Maybe a] -> Int -> ReadS (m (Maybe a)) forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (m a) forall (f :: * -> *) a. Read1 f => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a) liftReadsPrec Int -> ReadS (Maybe a) rp' ReadS [Maybe a] rl') String "MaybeT" m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT where rp' :: Int -> ReadS (Maybe a) rp' = (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) forall (f :: * -> *) a. Read1 f => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a) liftReadsPrec Int -> ReadS a rp ReadS [a] rl rl' :: ReadS [Maybe a] rl' = (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] forall (f :: * -> *) a. Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a] liftReadList Int -> ReadS a rp ReadS [a] rl instance (Show1 m) => Show1 (MaybeT m) where liftShowsPrec :: forall a. (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeT m a -> ShowS liftShowsPrec Int -> a -> ShowS sp [a] -> ShowS sl Int d (MaybeT m (Maybe a) m) = (Int -> m (Maybe a) -> ShowS) -> String -> Int -> m (Maybe a) -> ShowS forall a. (Int -> a -> ShowS) -> String -> Int -> a -> ShowS showsUnaryWith ((Int -> Maybe a -> ShowS) -> ([Maybe a] -> ShowS) -> Int -> m (Maybe a) -> ShowS forall a. (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> m a -> ShowS forall (f :: * -> *) a. Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS liftShowsPrec Int -> Maybe a -> ShowS sp' [Maybe a] -> ShowS sl') String "MaybeT" Int d m (Maybe a) m where sp' :: Int -> Maybe a -> ShowS sp' = (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS forall a. (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS forall (f :: * -> *) a. Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS liftShowsPrec Int -> a -> ShowS sp [a] -> ShowS sl sl' :: [Maybe a] -> ShowS sl' = (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS forall a. (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS forall (f :: * -> *) a. Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS liftShowList Int -> a -> ShowS sp [a] -> ShowS sl instance (Eq1 m, Eq a) => Eq (MaybeT m a) where == :: MaybeT m a -> MaybeT m a -> Bool (==) = MaybeT m a -> MaybeT m a -> Bool forall (f :: * -> *) a. (Eq1 f, Eq a) => f a -> f a -> Bool eq1 instance (Ord1 m, Ord a) => Ord (MaybeT m a) where compare :: MaybeT m a -> MaybeT m a -> Ordering compare = MaybeT m a -> MaybeT m a -> Ordering forall (f :: * -> *) a. (Ord1 f, Ord a) => f a -> f a -> Ordering compare1 instance (Read1 m, Read a) => Read (MaybeT m a) where readsPrec :: Int -> ReadS (MaybeT m a) readsPrec = Int -> ReadS (MaybeT m a) forall (f :: * -> *) a. (Read1 f, Read a) => Int -> ReadS (f a) readsPrec1 instance (Show1 m, Show a) => Show (MaybeT m a) where showsPrec :: Int -> MaybeT m a -> ShowS showsPrec = Int -> MaybeT m a -> ShowS forall (f :: * -> *) a. (Show1 f, Show a) => Int -> f a -> ShowS showsPrec1 -- | Transform the computation inside a @MaybeT@. -- -- * @'runMaybeT' ('mapMaybeT' f m) = f ('runMaybeT' m)@ mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b mapMaybeT :: forall (m :: * -> *) a (n :: * -> *) b. (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b mapMaybeT m (Maybe a) -> n (Maybe b) f = n (Maybe b) -> MaybeT n b forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (n (Maybe b) -> MaybeT n b) -> (MaybeT m a -> n (Maybe b)) -> MaybeT m a -> MaybeT n b forall b c a. (b -> c) -> (a -> b) -> a -> c . m (Maybe a) -> n (Maybe b) f (m (Maybe a) -> n (Maybe b)) -> (MaybeT m a -> m (Maybe a)) -> MaybeT m a -> n (Maybe b) forall b c a. (b -> c) -> (a -> b) -> a -> c . MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT {-# INLINE mapMaybeT #-} -- | Convert a 'MaybeT' computation to 'ExceptT', with a default -- exception value. maybeToExceptT :: (Functor m) => e -> MaybeT m a -> ExceptT e m a maybeToExceptT :: forall (m :: * -> *) e a. Functor m => e -> MaybeT m a -> ExceptT e m a maybeToExceptT e e (MaybeT m (Maybe a) m) = m (Either e a) -> ExceptT e m a forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a ExceptT (m (Either e a) -> ExceptT e m a) -> m (Either e a) -> ExceptT e m a forall a b. (a -> b) -> a -> b $ (Maybe a -> Either e a) -> m (Maybe a) -> m (Either e a) forall a b. (a -> b) -> m a -> m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap (Either e a -> (a -> Either e a) -> Maybe a -> Either e a forall b a. b -> (a -> b) -> Maybe a -> b maybe (e -> Either e a forall a b. a -> Either a b Left e e) a -> Either e a forall a b. b -> Either a b Right) m (Maybe a) m {-# INLINE maybeToExceptT #-} -- | Convert a 'ExceptT' computation to 'MaybeT', discarding the -- value of any exception. exceptToMaybeT :: (Functor m) => ExceptT e m a -> MaybeT m a exceptToMaybeT :: forall (m :: * -> *) e a. Functor m => ExceptT e m a -> MaybeT m a exceptToMaybeT (ExceptT m (Either e a) m) = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a forall a b. (a -> b) -> a -> b $ (Either e a -> Maybe a) -> m (Either e a) -> m (Maybe a) forall a b. (a -> b) -> m a -> m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((e -> Maybe a) -> (a -> Maybe a) -> Either e a -> Maybe a forall a c b. (a -> c) -> (b -> c) -> Either a b -> c either (Maybe a -> e -> Maybe a forall a b. a -> b -> a const Maybe a forall a. Maybe a Nothing) a -> Maybe a forall a. a -> Maybe a Just) m (Either e a) m {-# INLINE exceptToMaybeT #-} instance (Functor m) => Functor (MaybeT m) where fmap :: forall a b. (a -> b) -> MaybeT m a -> MaybeT m b fmap a -> b f = (m (Maybe a) -> m (Maybe b)) -> MaybeT m a -> MaybeT m b forall (m :: * -> *) a (n :: * -> *) b. (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b mapMaybeT ((Maybe a -> Maybe b) -> m (Maybe a) -> m (Maybe b) forall a b. (a -> b) -> m a -> m b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((a -> b) -> Maybe a -> Maybe b forall a b. (a -> b) -> Maybe a -> Maybe b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap a -> b f)) {-# INLINE fmap #-} instance (Foldable f) => Foldable (MaybeT f) where foldMap :: forall m a. Monoid m => (a -> m) -> MaybeT f a -> m foldMap a -> m f (MaybeT f (Maybe a) a) = (Maybe a -> m) -> f (Maybe a) -> m forall m a. Monoid m => (a -> m) -> f a -> m forall (t :: * -> *) m a. (Foldable t, Monoid m) => (a -> m) -> t a -> m foldMap ((a -> m) -> Maybe a -> m forall m a. Monoid m => (a -> m) -> Maybe a -> m forall (t :: * -> *) m a. (Foldable t, Monoid m) => (a -> m) -> t a -> m foldMap a -> m f) f (Maybe a) a {-# INLINE foldMap #-} instance (Traversable f) => Traversable (MaybeT f) where traverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> MaybeT f a -> f (MaybeT f b) traverse a -> f b f (MaybeT f (Maybe a) a) = f (Maybe b) -> MaybeT f b forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (f (Maybe b) -> MaybeT f b) -> f (f (Maybe b)) -> f (MaybeT f b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> (Maybe a -> f (Maybe b)) -> f (Maybe a) -> f (f (Maybe b)) forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) forall (f :: * -> *) a b. Applicative f => (a -> f b) -> f a -> f (f b) traverse ((a -> f b) -> Maybe a -> f (Maybe b) forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) forall (f :: * -> *) a b. Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) traverse a -> f b f) f (Maybe a) a {-# INLINE traverse #-} instance (Functor m, Monad m) => Applicative (MaybeT m) where pure :: forall a. a -> MaybeT m a pure = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> (a -> m (Maybe a)) -> a -> MaybeT m a forall b c a. (b -> c) -> (a -> b) -> a -> c . Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe a -> m (Maybe a)) -> (a -> Maybe a) -> a -> m (Maybe a) forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> Maybe a forall a. a -> Maybe a Just {-# INLINE pure #-} MaybeT m (a -> b) mf <*> :: forall a b. MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b <*> MaybeT m a mx = m (Maybe b) -> MaybeT m b forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe b) -> MaybeT m b) -> m (Maybe b) -> MaybeT m b forall a b. (a -> b) -> a -> b $ do Maybe (a -> b) mb_f <- MaybeT m (a -> b) -> m (Maybe (a -> b)) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m (a -> b) mf case Maybe (a -> b) mb_f of Maybe (a -> b) Nothing -> Maybe b -> m (Maybe b) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe b forall a. Maybe a Nothing Just a -> b f -> do Maybe a mb_x <- MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a mx case Maybe a mb_x of Maybe a Nothing -> Maybe b -> m (Maybe b) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe b forall a. Maybe a Nothing Just a x -> Maybe b -> m (Maybe b) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (b -> Maybe b forall a. a -> Maybe a Just (a -> b f a x)) {-# INLINE (<*>) #-} MaybeT m a m *> :: forall a b. MaybeT m a -> MaybeT m b -> MaybeT m b *> MaybeT m b k = MaybeT m a m MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b forall a b. MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b >>= \a _ -> MaybeT m b k {-# INLINE (*>) #-} instance (Functor m, Monad m) => Alternative (MaybeT m) where empty :: forall a. MaybeT m a empty = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe a forall a. Maybe a Nothing) {-# INLINE empty #-} MaybeT m a x <|> :: forall a. MaybeT m a -> MaybeT m a -> MaybeT m a <|> MaybeT m a y = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a forall a b. (a -> b) -> a -> b $ do Maybe a v <- MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a x case Maybe a v of Maybe a Nothing -> MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a y Just a _ -> Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe a v {-# INLINE (<|>) #-} instance (Monad m) => Monad (MaybeT m) where #if !(MIN_VERSION_base(4,8,0)) return = MaybeT . return . Just {-# INLINE return #-} #endif MaybeT m a x >>= :: forall a b. MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b >>= a -> MaybeT m b f = m (Maybe b) -> MaybeT m b forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe b) -> MaybeT m b) -> m (Maybe b) -> MaybeT m b forall a b. (a -> b) -> a -> b $ do Maybe a v <- MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a x case Maybe a v of Maybe a Nothing -> Maybe b -> m (Maybe b) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe b forall a. Maybe a Nothing Just a y -> MaybeT m b -> m (Maybe b) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT (a -> MaybeT m b f a y) {-# INLINE (>>=) #-} #if !(MIN_VERSION_base(4,13,0)) fail _ = MaybeT (return Nothing) {-# INLINE fail #-} #endif #if MIN_VERSION_base(4,9,0) instance (Monad m) => Fail.MonadFail (MaybeT m) where fail :: forall a. String -> MaybeT m a fail String _ = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe a forall a. Maybe a Nothing) {-# INLINE fail #-} #endif instance (Monad m) => MonadPlus (MaybeT m) where mzero :: forall a. MaybeT m a mzero = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe a forall a. Maybe a Nothing) {-# INLINE mzero #-} mplus :: forall a. MaybeT m a -> MaybeT m a -> MaybeT m a mplus MaybeT m a x MaybeT m a y = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a forall a b. (a -> b) -> a -> b $ do Maybe a v <- MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a x case Maybe a v of Maybe a Nothing -> MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a y Just a _ -> Maybe a -> m (Maybe a) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return Maybe a v {-# INLINE mplus #-} instance (MonadFix m) => MonadFix (MaybeT m) where mfix :: forall a. (a -> MaybeT m a) -> MaybeT m a mfix a -> MaybeT m a f = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT ((Maybe a -> m (Maybe a)) -> m (Maybe a) forall a. (a -> m a) -> m a forall (m :: * -> *) a. MonadFix m => (a -> m a) -> m a mfix (MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT (MaybeT m a -> m (Maybe a)) -> (Maybe a -> MaybeT m a) -> Maybe a -> m (Maybe a) forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> MaybeT m a f (a -> MaybeT m a) -> (Maybe a -> a) -> Maybe a -> MaybeT m a forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> Maybe a -> a forall a. a -> Maybe a -> a fromMaybe a forall {a}. a bomb)) where bomb :: a bomb = String -> a forall a. HasCallStack => String -> a error String "mfix (MaybeT): inner computation returned Nothing" {-# INLINE mfix #-} instance MonadTrans MaybeT where lift :: forall (m :: * -> *) a. Monad m => m a -> MaybeT m a lift = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> (m a -> m (Maybe a)) -> m a -> MaybeT m a forall b c a. (b -> c) -> (a -> b) -> a -> c . (a -> Maybe a) -> m a -> m (Maybe a) forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM a -> Maybe a forall a. a -> Maybe a Just {-# INLINE lift #-} instance (MonadIO m) => MonadIO (MaybeT m) where liftIO :: forall a. IO a -> MaybeT m a liftIO = m a -> MaybeT m a forall (m :: * -> *) a. Monad m => m a -> MaybeT m a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift (m a -> MaybeT m a) -> (IO a -> m a) -> IO a -> MaybeT m a forall b c a. (b -> c) -> (a -> b) -> a -> c . IO a -> m a forall a. IO a -> m a forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO {-# INLINE liftIO #-} #if MIN_VERSION_base(4,4,0) instance (MonadZip m) => MonadZip (MaybeT m) where mzipWith :: forall a b c. (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c mzipWith a -> b -> c f (MaybeT m (Maybe a) a) (MaybeT m (Maybe b) b) = m (Maybe c) -> MaybeT m c forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe c) -> MaybeT m c) -> m (Maybe c) -> MaybeT m c forall a b. (a -> b) -> a -> b $ (Maybe a -> Maybe b -> Maybe c) -> m (Maybe a) -> m (Maybe b) -> m (Maybe c) forall a b c. (a -> b -> c) -> m a -> m b -> m c forall (m :: * -> *) a b c. MonadZip m => (a -> b -> c) -> m a -> m b -> m c mzipWith ((a -> b -> c) -> Maybe a -> Maybe b -> Maybe c forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c forall (f :: * -> *) a b c. Applicative f => (a -> b -> c) -> f a -> f b -> f c liftA2 a -> b -> c f) m (Maybe a) a m (Maybe b) b {-# INLINE mzipWith #-} #endif #if MIN_VERSION_base(4,12,0) instance Contravariant m => Contravariant (MaybeT m) where contramap :: forall a' a. (a' -> a) -> MaybeT m a -> MaybeT m a' contramap a' -> a f = m (Maybe a') -> MaybeT m a' forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a') -> MaybeT m a') -> (MaybeT m a -> m (Maybe a')) -> MaybeT m a -> MaybeT m a' forall b c a. (b -> c) -> (a -> b) -> a -> c . (Maybe a' -> Maybe a) -> m (Maybe a) -> m (Maybe a') forall a' a. (a' -> a) -> m a -> m a' forall (f :: * -> *) a' a. Contravariant f => (a' -> a) -> f a -> f a' contramap ((a' -> a) -> Maybe a' -> Maybe a forall a b. (a -> b) -> Maybe a -> Maybe b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap a' -> a f) (m (Maybe a) -> m (Maybe a')) -> (MaybeT m a -> m (Maybe a)) -> MaybeT m a -> m (Maybe a') forall b c a. (b -> c) -> (a -> b) -> a -> c . MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT {-# INLINE contramap #-} #endif -- | Lift a @callCC@ operation to the new monad. liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b liftCallCC :: forall (m :: * -> *) a b. CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b liftCallCC CallCC m (Maybe a) (Maybe b) callCC (a -> MaybeT m b) -> MaybeT m a f = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a forall a b. (a -> b) -> a -> b $ CallCC m (Maybe a) (Maybe b) callCC CallCC m (Maybe a) (Maybe b) -> CallCC m (Maybe a) (Maybe b) forall a b. (a -> b) -> a -> b $ \ Maybe a -> m (Maybe b) c -> MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT ((a -> MaybeT m b) -> MaybeT m a f (m (Maybe b) -> MaybeT m b forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe b) -> MaybeT m b) -> (a -> m (Maybe b)) -> a -> MaybeT m b forall b c a. (b -> c) -> (a -> b) -> a -> c . Maybe a -> m (Maybe b) c (Maybe a -> m (Maybe b)) -> (a -> Maybe a) -> a -> m (Maybe b) forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> Maybe a forall a. a -> Maybe a Just)) {-# INLINE liftCallCC #-} -- | Lift a @catchE@ operation to the new monad. liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a liftCatch :: forall e (m :: * -> *) a. Catch e m (Maybe a) -> Catch e (MaybeT m) a liftCatch Catch e m (Maybe a) f MaybeT m a m e -> MaybeT m a h = m (Maybe a) -> MaybeT m a forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a MaybeT (m (Maybe a) -> MaybeT m a) -> m (Maybe a) -> MaybeT m a forall a b. (a -> b) -> a -> b $ Catch e m (Maybe a) f (MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT MaybeT m a m) (MaybeT m a -> m (Maybe a) forall (m :: * -> *) a. MaybeT m a -> m (Maybe a) runMaybeT (MaybeT m a -> m (Maybe a)) -> (e -> MaybeT m a) -> e -> m (Maybe a) forall b c a. (b -> c) -> (a -> b) -> a -> c . e -> MaybeT m a h) {-# INLINE liftCatch #-} -- | Lift a @listen@ operation to the new monad. liftListen :: (Monad m) => Listen w m (Maybe a) -> Listen w (MaybeT m) a liftListen :: forall (m :: * -> *) w a. Monad m => Listen w m (Maybe a) -> Listen w (MaybeT m) a liftListen Listen w m (Maybe a) listen = (m (Maybe a) -> m (Maybe (a, w))) -> MaybeT m a -> MaybeT m (a, w) forall (m :: * -> *) a (n :: * -> *) b. (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b mapMaybeT ((m (Maybe a) -> m (Maybe (a, w))) -> MaybeT m a -> MaybeT m (a, w)) -> (m (Maybe a) -> m (Maybe (a, w))) -> MaybeT m a -> MaybeT m (a, w) forall a b. (a -> b) -> a -> b $ \ m (Maybe a) m -> do (Maybe a a, w w) <- Listen w m (Maybe a) listen m (Maybe a) m Maybe (a, w) -> m (Maybe (a, w)) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (a, w) -> m (Maybe (a, w))) -> Maybe (a, w) -> m (Maybe (a, w)) forall a b. (a -> b) -> a -> b $! (a -> (a, w)) -> Maybe a -> Maybe (a, w) forall a b. (a -> b) -> Maybe a -> Maybe b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap (\ a r -> (a r, w w)) Maybe a a {-# INLINE liftListen #-} -- | Lift a @pass@ operation to the new monad. liftPass :: (Monad m) => Pass w m (Maybe a) -> Pass w (MaybeT m) a liftPass :: forall (m :: * -> *) w a. Monad m => Pass w m (Maybe a) -> Pass w (MaybeT m) a liftPass Pass w m (Maybe a) pass = (m (Maybe (a, w -> w)) -> m (Maybe a)) -> MaybeT m (a, w -> w) -> MaybeT m a forall (m :: * -> *) a (n :: * -> *) b. (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b mapMaybeT ((m (Maybe (a, w -> w)) -> m (Maybe a)) -> MaybeT m (a, w -> w) -> MaybeT m a) -> (m (Maybe (a, w -> w)) -> m (Maybe a)) -> MaybeT m (a, w -> w) -> MaybeT m a forall a b. (a -> b) -> a -> b $ \ m (Maybe (a, w -> w)) m -> Pass w m (Maybe a) pass Pass w m (Maybe a) -> Pass w m (Maybe a) forall a b. (a -> b) -> a -> b $ do Maybe (a, w -> w) a <- m (Maybe (a, w -> w)) m (Maybe a, w -> w) -> m (Maybe a, w -> w) forall a. a -> m a forall (m :: * -> *) a. Monad m => a -> m a return ((Maybe a, w -> w) -> m (Maybe a, w -> w)) -> (Maybe a, w -> w) -> m (Maybe a, w -> w) forall a b. (a -> b) -> a -> b $! case Maybe (a, w -> w) a of Maybe (a, w -> w) Nothing -> (Maybe a forall a. Maybe a Nothing, w -> w forall a. a -> a id) Just (a v, w -> w f) -> (a -> Maybe a forall a. a -> Maybe a Just a v, w -> w f) {-# INLINE liftPass #-}