{- |
Synchronous exceptions immediately abort a series of computations.
We provide monads for describing this behaviour.
In contrast to ErrorT from @mtl@ or @transformers@ package
we do not pose restrictions on the exception type.

How to tell, that a function can possibly throw more than one (kind of) exception?

If you would use the exception type @(Either ParserException IOError)@
then this is different from @(Either IOError ParserException)@.
Thus we recommned using type classes for exceptions.
Then you can use one type containing all exceptions in an application,
but the type signature still tells which exceptions are actually possible.
Examples:

> parser :: ParserException e => ExceptionalT e ParserMonad a
>
> getLine :: IOException e => ExceptionalT e IO String
>
> fileParser :: (ParserException e, IOException e) => ExceptionalT e IO String

Unfortunately, this way you cannot remove single exceptions
from the constraints by catching them.
You can only remove all of them using 'resolve' or none.
For a more advanced approach,
that allows removing exceptions constraints
by some non-Haskell-98 type hackery,
see the exception package by Joseph Iborra.
-}
module Control.Monad.Exception.Synchronous (
   Exceptional(..),
   fromMaybe,    toMaybe,
   fromEither,   toEither,
   fromExitCode, toExitCode,
   getExceptionNull,
   switch,
   force,
   mapException,
   mapExceptional,
   throw,
   assert,
   catch,
   resolve,
   merge,
   alternative,

   ExceptionalT(..),
   fromMaybeT,    toMaybeT,
   fromErrorT,    toErrorT,
   fromEitherT,   toEitherT,
   fromExitCodeT, toExitCodeT,
   liftT,
   switchT,
   forceT,
   mapExceptionT,
   mapExceptionalT,
   throwT,
   assertT,
   catchT,
   bracketT,
   resolveT,
   tryT,
   manyT,
   manyMonoidT,
   mergeT,
   alternativeT,
   ) where

import Control.Applicative (Applicative(pure, (<*>)))
import Control.Monad (Monad, return, liftM, liftM2, (>>=), (>>), (=<<),
          {- MonadPlus(mzero, mplus), -})
import Control.Monad.Fix (MonadFix, mfix, )
import Control.Monad.Trans.Class (MonadTrans, lift, )
import Control.Monad.Trans.Error (ErrorT(ErrorT, runErrorT))
import Control.Monad.Trans.Maybe (MaybeT(MaybeT, runMaybeT))
import Control.DeepSeq (NFData, rnf, )
import Data.Functor (Functor, fmap, )
import Data.Monoid(Monoid, mappend, mempty, Endo(Endo, appEndo), )
import Data.Function (flip, const, (.), ($), )
import Data.Either (Either(Left, Right), either, )
import Data.Maybe (Maybe(Just, Nothing), maybe, )
import Data.Bool (Bool, )
import Data.Eq (Eq, )

import System.Exit (ExitCode(ExitSuccess, ExitFailure), )

import Prelude (Show, Int, error, )


-- * Plain monad

{- |
Like 'Either', but explicitly intended for handling of exceptional results.
In contrast to 'Either' we do not support 'fail'.
Calling 'fail' in the 'Exceptional' monad is an error.
This way, we do not require that an exception can be derived from a 'String',
yet, we require no constraint on the exception type at all.
-}
data Exceptional e a =
     Success a
   | Exception e
   deriving (Int -> Exceptional e a -> ShowS
[Exceptional e a] -> ShowS
Exceptional e a -> String
(Int -> Exceptional e a -> ShowS)
-> (Exceptional e a -> String)
-> ([Exceptional e a] -> ShowS)
-> Show (Exceptional e a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e a. (Show a, Show e) => Int -> Exceptional e a -> ShowS
forall e a. (Show a, Show e) => [Exceptional e a] -> ShowS
forall e a. (Show a, Show e) => Exceptional e a -> String
showList :: [Exceptional e a] -> ShowS
$cshowList :: forall e a. (Show a, Show e) => [Exceptional e a] -> ShowS
show :: Exceptional e a -> String
$cshow :: forall e a. (Show a, Show e) => Exceptional e a -> String
showsPrec :: Int -> Exceptional e a -> ShowS
$cshowsPrec :: forall e a. (Show a, Show e) => Int -> Exceptional e a -> ShowS
Show, Exceptional e a -> Exceptional e a -> Bool
(Exceptional e a -> Exceptional e a -> Bool)
-> (Exceptional e a -> Exceptional e a -> Bool)
-> Eq (Exceptional e a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall e a.
(Eq a, Eq e) =>
Exceptional e a -> Exceptional e a -> Bool
/= :: Exceptional e a -> Exceptional e a -> Bool
$c/= :: forall e a.
(Eq a, Eq e) =>
Exceptional e a -> Exceptional e a -> Bool
== :: Exceptional e a -> Exceptional e a -> Bool
$c== :: forall e a.
(Eq a, Eq e) =>
Exceptional e a -> Exceptional e a -> Bool
Eq)


fromMaybe :: e -> Maybe a -> Exceptional e a
fromMaybe :: e -> Maybe a -> Exceptional e a
fromMaybe e :: e
e = Exceptional e a
-> (a -> Exceptional e a) -> Maybe a -> Exceptional e a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (e -> Exceptional e a
forall e a. e -> Exceptional e a
Exception e
e) a -> Exceptional e a
forall e a. a -> Exceptional e a
Success

fromEither :: Either e a -> Exceptional e a
fromEither :: Either e a -> Exceptional e a
fromEither = (e -> Exceptional e a)
-> (a -> Exceptional e a) -> Either e a -> Exceptional e a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> Exceptional e a
forall e a. e -> Exceptional e a
Exception a -> Exceptional e a
forall e a. a -> Exceptional e a
Success

toMaybe :: Exceptional e a -> Maybe a
toMaybe :: Exceptional e a -> Maybe a
toMaybe = (e -> Maybe a) -> (a -> Maybe a) -> Exceptional e a -> Maybe a
forall e b a. (e -> b) -> (a -> b) -> Exceptional e a -> b
switch (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

toEither :: Exceptional e a -> Either e a
toEither :: Exceptional e a -> Either e a
toEither x :: Exceptional e a
x =
   case Exceptional e a
x of
      Success a :: a
a   -> a -> Either e a
forall a b. b -> Either a b
Right a
a
      Exception e :: e
e -> e -> Either e a
forall a b. a -> Either a b
Left e
e


toExitCode :: Exceptional Int () -> ExitCode
toExitCode :: Exceptional Int () -> ExitCode
toExitCode e :: Exceptional Int ()
e =
   case Exceptional Int ()
e of
      Success () -> ExitCode
ExitSuccess
      Exception n :: Int
n -> Int -> ExitCode
ExitFailure Int
n

fromExitCode :: ExitCode -> Exceptional Int ()
fromExitCode :: ExitCode -> Exceptional Int ()
fromExitCode e :: ExitCode
e =
   case ExitCode
e of
      ExitSuccess -> () -> Exceptional Int ()
forall e a. a -> Exceptional e a
Success ()
      ExitFailure n :: Int
n -> Int -> Exceptional Int ()
forall e a. e -> Exceptional e a
Exception Int
n


-- | useful in connection with 'Control.Monad.Exception.Asynchronous.continue'
getExceptionNull :: Exceptional e () -> Maybe e
getExceptionNull :: Exceptional e () -> Maybe e
getExceptionNull x :: Exceptional e ()
x =
   case Exceptional e ()
x of
      Success _   -> Maybe e
forall a. Maybe a
Nothing
      Exception e :: e
e -> e -> Maybe e
forall a. a -> Maybe a
Just e
e


{- |
Counterpart to 'either' for 'Either'.
-}
switch :: (e -> b) -> (a -> b) -> Exceptional e a -> b
switch :: (e -> b) -> (a -> b) -> Exceptional e a -> b
switch f :: e -> b
f g :: a -> b
g x :: Exceptional e a
x =
   case Exceptional e a
x of
      Success a :: a
a -> a -> b
g a
a
      Exception e :: e
e -> e -> b
f e
e

{- |
If you are sure that the value is always a 'Success'
you can tell that the run-time system
thus making your program lazy.
However, try to avoid this function by using 'catch' and friends,
since this function is partial.
-}
force :: Exceptional e a -> Exceptional e a
force :: Exceptional e a -> Exceptional e a
force ~(Success a :: a
a) = a -> Exceptional e a
forall e a. a -> Exceptional e a
Success a
a

mapException :: (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException :: (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException f :: e0 -> e1
f x :: Exceptional e0 a
x =
   case Exceptional e0 a
x of
      Success a :: a
a   -> a -> Exceptional e1 a
forall e a. a -> Exceptional e a
Success a
a
      Exception e :: e0
e -> e1 -> Exceptional e1 a
forall e a. e -> Exceptional e a
Exception (e0 -> e1
f e0
e)

mapExceptional :: (e0 -> e1) -> (a -> b) -> Exceptional e0 a -> Exceptional e1 b
mapExceptional :: (e0 -> e1) -> (a -> b) -> Exceptional e0 a -> Exceptional e1 b
mapExceptional f :: e0 -> e1
f g :: a -> b
g x :: Exceptional e0 a
x =
   case Exceptional e0 a
x of
      Success a :: a
a   -> b -> Exceptional e1 b
forall e a. a -> Exceptional e a
Success (a -> b
g a
a)
      Exception e :: e0
e -> e1 -> Exceptional e1 b
forall e a. e -> Exceptional e a
Exception (e0 -> e1
f e0
e)

throw :: e -> Exceptional e a
throw :: e -> Exceptional e a
throw = e -> Exceptional e a
forall e a. e -> Exceptional e a
Exception

assert :: e -> Bool -> Exceptional e ()
assert :: e -> Bool -> Exceptional e ()
assert e :: e
e b :: Bool
b =
   if Bool
b then () -> Exceptional e ()
forall e a. a -> Exceptional e a
Success () else e -> Exceptional e ()
forall e a. e -> Exceptional e a
throw e
e

catch :: Exceptional e0 a -> (e0 -> Exceptional e1 a) -> Exceptional e1 a
catch :: Exceptional e0 a -> (e0 -> Exceptional e1 a) -> Exceptional e1 a
catch x :: Exceptional e0 a
x handler :: e0 -> Exceptional e1 a
handler =
   case Exceptional e0 a
x of
      Success a :: a
a   -> a -> Exceptional e1 a
forall e a. a -> Exceptional e a
Success a
a
      Exception e :: e0
e -> e0 -> Exceptional e1 a
handler e0
e

{-
bracket ::
   Exceptional e h ->
   (h -> Exceptional e ()) ->
   (h -> Exceptional e a) ->
   Exceptional e a
bracket open close action =
   open >>= \h ->
   case action h of
-}

resolve :: (e -> a) -> Exceptional e a -> a
resolve :: (e -> a) -> Exceptional e a -> a
resolve handler :: e -> a
handler x :: Exceptional e a
x =
   case Exceptional e a
x of
      Success a :: a
a   -> a
a
      Exception e :: e
e -> e -> a
handler e
e

{-
Semigroup instance could replace (Math.Checksum.IBAN.+++).
-}

-- like Applicative.<|>
infixl 3 `alternative`, `alternativeT`

alternative, _alternative ::
   Exceptional e a -> Exceptional e a -> Exceptional e a
alternative :: Exceptional e a -> Exceptional e a -> Exceptional e a
alternative x :: Exceptional e a
x y :: Exceptional e a
y = Exceptional e a -> (e -> Exceptional e a) -> Exceptional e a
forall e0 a e1.
Exceptional e0 a -> (e0 -> Exceptional e1 a) -> Exceptional e1 a
catch Exceptional e a
x (Exceptional e a -> e -> Exceptional e a
forall a b. a -> b -> a
const Exceptional e a
y)
_alternative :: Exceptional e a -> Exceptional e a -> Exceptional e a
_alternative x :: Exceptional e a
x y :: Exceptional e a
y = (e -> Exceptional e a)
-> (a -> Exceptional e a) -> Exceptional e a -> Exceptional e a
forall e b a. (e -> b) -> (a -> b) -> Exceptional e a -> b
switch (Exceptional e a -> e -> Exceptional e a
forall a b. a -> b -> a
const Exceptional e a
y) a -> Exceptional e a
forall e a. a -> Exceptional e a
Success Exceptional e a
x



-- like Applicative.<*>
infixl 4 `merge`, `mergeT`

{- | see 'mergeT' -}
merge, mergeLazy, _mergeStrict ::
   (Monoid e) =>
   Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
merge :: Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
merge = Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
forall e a b.
Monoid e =>
Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
mergeLazy

mergeLazy :: Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
mergeLazy ef :: Exceptional e (a -> b)
ef ea :: Exceptional e a
ea =
   case Exceptional e (a -> b)
ef of
      Exception e0 :: e
e0 ->
         e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception (e -> Exceptional e b) -> e -> Exceptional e b
forall a b. (a -> b) -> a -> b
$ e -> e -> e
forall a. Monoid a => a -> a -> a
mappend e
e0 (e -> e) -> e -> e
forall a b. (a -> b) -> a -> b
$
         case Exceptional e a
ea of
            Success _ -> e
forall a. Monoid a => a
mempty
            Exception e1 :: e
e1 -> e
e1
      Success f :: a -> b
f -> (a -> b) -> Exceptional e a -> Exceptional e b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Exceptional e a
ea

_mergeStrict :: Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
_mergeStrict ef :: Exceptional e (a -> b)
ef ea :: Exceptional e a
ea =
   case (Exceptional e (a -> b)
ef,Exceptional e a
ea) of
      (Success f :: a -> b
f, Success a :: a
a) -> b -> Exceptional e b
forall e a. a -> Exceptional e a
Success (b -> Exceptional e b) -> b -> Exceptional e b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
a
      (Exception e :: e
e, Success _) -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e
      (Success _, Exception e :: e
e) -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e
      (Exception e0 :: e
e0, Exception e1 :: e
e1) -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception (e -> Exceptional e b) -> e -> Exceptional e b
forall a b. (a -> b) -> a -> b
$ e -> e -> e
forall a. Monoid a => a -> a -> a
mappend e
e0 e
e1


instance (NFData e, NFData a) => NFData (Exceptional e a) where
   rnf :: Exceptional e a -> ()
rnf = (e -> ()) -> (a -> ()) -> Exceptional e a -> ()
forall e b a. (e -> b) -> (a -> b) -> Exceptional e a -> b
switch e -> ()
forall a. NFData a => a -> ()
rnf a -> ()
forall a. NFData a => a -> ()
rnf

instance Functor (Exceptional e) where
   fmap :: (a -> b) -> Exceptional e a -> Exceptional e b
fmap f :: a -> b
f x :: Exceptional e a
x =
      case Exceptional e a
x of
         Success a :: a
a   -> b -> Exceptional e b
forall e a. a -> Exceptional e a
Success (a -> b
f a
a)
         Exception e :: e
e -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e

instance Applicative (Exceptional e) where
   pure :: a -> Exceptional e a
pure = a -> Exceptional e a
forall e a. a -> Exceptional e a
Success
   f :: Exceptional e (a -> b)
f <*> :: Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
<*> x :: Exceptional e a
x =
      case Exceptional e (a -> b)
f of
         Exception e :: e
e -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e
         Success g :: a -> b
g ->
            case Exceptional e a
x of
               Success a :: a
a   -> b -> Exceptional e b
forall e a. a -> Exceptional e a
Success (a -> b
g a
a)
               Exception e :: e
e -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e

instance Monad (Exceptional e) where
   return :: a -> Exceptional e a
return = a -> Exceptional e a
forall e a. a -> Exceptional e a
Success
   x :: Exceptional e a
x >>= :: Exceptional e a -> (a -> Exceptional e b) -> Exceptional e b
>>= f :: a -> Exceptional e b
f =
      case Exceptional e a
x of
         Exception e :: e
e -> e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e
         Success y :: a
y -> a -> Exceptional e b
f a
y

{- |
I think it is not a good idea to use this instance,
maybe we shoul remove it.
It expects that the constructor is 'Success'
and the result is undefined otherwise.
But if the constructor must always be 'Success',
why using 'Exceptional' then, at all?
-}
instance MonadFix (Exceptional e) where
    mfix :: (a -> Exceptional e a) -> Exceptional e a
mfix f :: a -> Exceptional e a
f =
       let unSuccess :: Exceptional e a -> a
unSuccess ~(Success x :: a
x) = a
x
           a :: Exceptional e a
a = a -> Exceptional e a
f (Exceptional e a -> a
forall e a. Exceptional e a -> a
unSuccess Exceptional e a
a)
       in  Exceptional e a
a

{-
A MonadPlus instance would require another class, say DefaultException,
that provides a default exception used for @mzero@.
In Control.Monad.Error this is handled by the Error class.
Since String is a typical type used for exceptions -
shall there be a DefaultException String instance?
-}



-- * Monad transformer

-- | like ErrorT, but ExceptionalT is the better name in order to distinguish from real (programming) errors
newtype ExceptionalT e m a =
   ExceptionalT {ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT :: m (Exceptional e a)}


_assertMaybeT :: (Monad m) => e -> Maybe a -> ExceptionalT e m a
_assertMaybeT :: e -> Maybe a -> ExceptionalT e m a
_assertMaybeT e :: e
e = ExceptionalT e m a
-> (a -> ExceptionalT e m a) -> Maybe a -> ExceptionalT e m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (e -> ExceptionalT e m a
forall (m :: * -> *) e a. Monad m => e -> ExceptionalT e m a
throwT e
e) a -> ExceptionalT e m a
forall (m :: * -> *) a. Monad m => a -> m a
return

fromMaybeT :: Monad m => e -> MaybeT m a -> ExceptionalT e m a
fromMaybeT :: e -> MaybeT m a -> ExceptionalT e m a
fromMaybeT e :: e
e  =  m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (MaybeT m a -> m (Exceptional e a))
-> MaybeT m a
-> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> Exceptional e a) -> m (Maybe a) -> m (Exceptional e a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (e -> Maybe a -> Exceptional e a
forall e a. e -> Maybe a -> Exceptional e a
fromMaybe e
e) (m (Maybe a) -> m (Exceptional e a))
-> (MaybeT m a -> m (Maybe a)) -> MaybeT m a -> m (Exceptional e 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

toMaybeT :: Monad m => ExceptionalT e m a -> MaybeT m a
toMaybeT :: ExceptionalT e m a -> MaybeT m a
toMaybeT  =  m (Maybe a) -> MaybeT m a
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe a) -> MaybeT m a)
-> (ExceptionalT e m a -> m (Maybe a))
-> ExceptionalT e m a
-> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exceptional e a -> Maybe a) -> m (Exceptional e a) -> m (Maybe a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Exceptional e a -> Maybe a
forall e a. Exceptional e a -> Maybe a
toMaybe (m (Exceptional e a) -> m (Maybe a))
-> (ExceptionalT e m a -> m (Exceptional e a))
-> ExceptionalT e m a
-> m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT

fromErrorT :: Monad m => ErrorT e m a -> ExceptionalT e m a
fromErrorT :: ErrorT e m a -> ExceptionalT e m a
fromErrorT  =  m (Either e a) -> ExceptionalT e m a
forall (m :: * -> *) e a.
Monad m =>
m (Either e a) -> ExceptionalT e m a
fromEitherT (m (Either e a) -> ExceptionalT e m a)
-> (ErrorT e m a -> m (Either e a))
-> ErrorT e m a
-> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ErrorT e m a -> m (Either e a)
forall e (m :: * -> *) a. ErrorT e m a -> m (Either e a)
runErrorT

toErrorT :: Monad m => ExceptionalT e m a -> ErrorT e m a
toErrorT :: ExceptionalT e m a -> ErrorT e m a
toErrorT  =  m (Either e a) -> ErrorT e m a
forall e (m :: * -> *) a. m (Either e a) -> ErrorT e m a
ErrorT (m (Either e a) -> ErrorT e m a)
-> (ExceptionalT e m a -> m (Either e a))
-> ExceptionalT e m a
-> ErrorT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e m a -> m (Either e a)
forall (m :: * -> *) e a.
Monad m =>
ExceptionalT e m a -> m (Either e a)
toEitherT

fromEitherT :: Monad m => m (Either e a) -> ExceptionalT e m a
fromEitherT :: m (Either e a) -> ExceptionalT e m a
fromEitherT  =  m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (m (Either e a) -> m (Exceptional e a))
-> m (Either e a)
-> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either e a -> Exceptional e a)
-> m (Either e a) -> m (Exceptional e a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Either e a -> Exceptional e a
forall e a. Either e a -> Exceptional e a
fromEither

toEitherT :: Monad m => ExceptionalT e m a -> m (Either e a)
toEitherT :: ExceptionalT e m a -> m (Either e a)
toEitherT  =  (Exceptional e a -> Either e a)
-> m (Exceptional e a) -> m (Either e a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Exceptional e a -> Either e a
forall e a. Exceptional e a -> Either e a
toEither (m (Exceptional e a) -> m (Either e a))
-> (ExceptionalT e m a -> m (Exceptional e a))
-> ExceptionalT e m a
-> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT

toExitCodeT ::
   (Functor m) =>
   ExceptionalT Int m () -> m ExitCode
toExitCodeT :: ExceptionalT Int m () -> m ExitCode
toExitCodeT act :: ExceptionalT Int m ()
act =
   (Exceptional Int () -> ExitCode)
-> m (Exceptional Int ()) -> m ExitCode
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exceptional Int () -> ExitCode
toExitCode (m (Exceptional Int ()) -> m ExitCode)
-> m (Exceptional Int ()) -> m ExitCode
forall a b. (a -> b) -> a -> b
$ ExceptionalT Int m () -> m (Exceptional Int ())
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT Int m ()
act

fromExitCodeT ::
   (Functor m) =>
   m ExitCode -> ExceptionalT Int m ()
fromExitCodeT :: m ExitCode -> ExceptionalT Int m ()
fromExitCodeT act :: m ExitCode
act =
   m (Exceptional Int ()) -> ExceptionalT Int m ()
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional Int ()) -> ExceptionalT Int m ())
-> m (Exceptional Int ()) -> ExceptionalT Int m ()
forall a b. (a -> b) -> a -> b
$ (ExitCode -> Exceptional Int ())
-> m ExitCode -> m (Exceptional Int ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ExitCode -> Exceptional Int ()
fromExitCode m ExitCode
act


liftT :: (Monad m) => Exceptional e a -> ExceptionalT e m a
liftT :: Exceptional e a -> ExceptionalT e m a
liftT = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (Exceptional e a -> m (Exceptional e a))
-> Exceptional e a
-> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exceptional e a -> m (Exceptional e a)
forall (m :: * -> *) a. Monad m => a -> m a
return


switchT ::
   (Monad m) =>
   (e -> m b) -> (a -> m b) ->
   ExceptionalT e m a -> m b
switchT :: (e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b
switchT e :: e -> m b
e s :: a -> m b
s m :: ExceptionalT e m a
m =
   (e -> m b) -> (a -> m b) -> Exceptional e a -> m b
forall e b a. (e -> b) -> (a -> b) -> Exceptional e a -> b
switch e -> m b
e a -> m b
s (Exceptional e a -> m b) -> m (Exceptional e a) -> m b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
m

{- |
see 'force'
-}
forceT :: Monad m => ExceptionalT e m a -> ExceptionalT e m a
forceT :: ExceptionalT e m a -> ExceptionalT e m a
forceT =
   m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (ExceptionalT e m a -> m (Exceptional e a))
-> ExceptionalT e m a
-> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exceptional e a -> Exceptional e a)
-> m (Exceptional e a) -> m (Exceptional e a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Exceptional e a -> Exceptional e a
forall e a. Exceptional e a -> Exceptional e a
force (m (Exceptional e a) -> m (Exceptional e a))
-> (ExceptionalT e m a -> m (Exceptional e a))
-> ExceptionalT e m a
-> m (Exceptional e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT


mapExceptionT :: (Monad m) =>
   (e0 -> e1) ->
   ExceptionalT e0 m a ->
   ExceptionalT e1 m a
mapExceptionT :: (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a
mapExceptionT f :: e0 -> e1
f =
   m (Exceptional e1 a) -> ExceptionalT e1 m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e1 a) -> ExceptionalT e1 m a)
-> (ExceptionalT e0 m a -> m (Exceptional e1 a))
-> ExceptionalT e0 m a
-> ExceptionalT e1 m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exceptional e0 a -> Exceptional e1 a)
-> m (Exceptional e0 a) -> m (Exceptional e1 a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ((e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
forall e0 e1 a. (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException e0 -> e1
f) (m (Exceptional e0 a) -> m (Exceptional e1 a))
-> (ExceptionalT e0 m a -> m (Exceptional e0 a))
-> ExceptionalT e0 m a
-> m (Exceptional e1 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e0 m a -> m (Exceptional e0 a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT

mapExceptionalT ::
   (m (Exceptional e0 a) -> n (Exceptional e1 b)) ->
   ExceptionalT e0 m a -> ExceptionalT e1 n b
mapExceptionalT :: (m (Exceptional e0 a) -> n (Exceptional e1 b))
-> ExceptionalT e0 m a -> ExceptionalT e1 n b
mapExceptionalT f :: m (Exceptional e0 a) -> n (Exceptional e1 b)
f =
   n (Exceptional e1 b) -> ExceptionalT e1 n b
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (n (Exceptional e1 b) -> ExceptionalT e1 n b)
-> (ExceptionalT e0 m a -> n (Exceptional e1 b))
-> ExceptionalT e0 m a
-> ExceptionalT e1 n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Exceptional e0 a) -> n (Exceptional e1 b)
f (m (Exceptional e0 a) -> n (Exceptional e1 b))
-> (ExceptionalT e0 m a -> m (Exceptional e0 a))
-> ExceptionalT e0 m a
-> n (Exceptional e1 b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionalT e0 m a -> m (Exceptional e0 a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT

throwT :: (Monad m) =>
   e -> ExceptionalT e m a
throwT :: e -> ExceptionalT e m a
throwT = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (e -> m (Exceptional e a)) -> e -> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exceptional e a -> m (Exceptional e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e a -> m (Exceptional e a))
-> (e -> Exceptional e a) -> e -> m (Exceptional e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Exceptional e a
forall e a. e -> Exceptional e a
throw

assertT :: (Monad m) =>
   e -> Bool -> ExceptionalT e m ()
assertT :: e -> Bool -> ExceptionalT e m ()
assertT e :: e
e = m (Exceptional e ()) -> ExceptionalT e m ()
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e ()) -> ExceptionalT e m ())
-> (Bool -> m (Exceptional e ())) -> Bool -> ExceptionalT e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exceptional e () -> m (Exceptional e ())
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e () -> m (Exceptional e ()))
-> (Bool -> Exceptional e ()) -> Bool -> m (Exceptional e ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Bool -> Exceptional e ()
forall e. e -> Bool -> Exceptional e ()
assert e
e

catchT :: (Monad m) =>
   ExceptionalT e0 m a ->
   (e0 -> ExceptionalT e1 m a) ->
   ExceptionalT e1 m a
catchT :: ExceptionalT e0 m a
-> (e0 -> ExceptionalT e1 m a) -> ExceptionalT e1 m a
catchT action :: ExceptionalT e0 m a
action handler :: e0 -> ExceptionalT e1 m a
handler =
   m (Exceptional e1 a) -> ExceptionalT e1 m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e1 a) -> ExceptionalT e1 m a)
-> m (Exceptional e1 a) -> ExceptionalT e1 m a
forall a b. (a -> b) -> a -> b
$ (e0 -> m (Exceptional e1 a))
-> (a -> m (Exceptional e1 a))
-> ExceptionalT e0 m a
-> m (Exceptional e1 a)
forall (m :: * -> *) e b a.
Monad m =>
(e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b
switchT (ExceptionalT e1 m a -> m (Exceptional e1 a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT (ExceptionalT e1 m a -> m (Exceptional e1 a))
-> (e0 -> ExceptionalT e1 m a) -> e0 -> m (Exceptional e1 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e0 -> ExceptionalT e1 m a
handler) (Exceptional e1 a -> m (Exceptional e1 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e1 a -> m (Exceptional e1 a))
-> (a -> Exceptional e1 a) -> a -> m (Exceptional e1 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Exceptional e1 a
forall e a. a -> Exceptional e a
Success) ExceptionalT e0 m a
action

{- |
If the enclosed monad has custom exception facilities,
they could skip the cleanup code.
Make sure, that this cannot happen by choosing an appropriate monad.
-}
bracketT :: (Monad m) =>
   ExceptionalT e m h ->
   (h -> ExceptionalT e m ()) ->
   (h -> ExceptionalT e m a) ->
   ExceptionalT e m a
bracketT :: ExceptionalT e m h
-> (h -> ExceptionalT e m ())
-> (h -> ExceptionalT e m a)
-> ExceptionalT e m a
bracketT open :: ExceptionalT e m h
open close :: h -> ExceptionalT e m ()
close action :: h -> ExceptionalT e m a
action =
   ExceptionalT e m h
open ExceptionalT e m h
-> (h -> ExceptionalT e m a) -> ExceptionalT e m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \h :: h
h ->
      m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> m (Exceptional e a) -> ExceptionalT e m a
forall a b. (a -> b) -> a -> b
$
         do Exceptional e a
a <- ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT (h -> ExceptionalT e m a
action h
h)
            Exceptional e ()
c <- ExceptionalT e m () -> m (Exceptional e ())
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT (h -> ExceptionalT e m ()
close h
h)
            Exceptional e a -> m (Exceptional e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e a
a Exceptional e a -> (a -> Exceptional e a) -> Exceptional e a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \r :: a
r -> Exceptional e ()
c Exceptional e () -> Exceptional e a -> Exceptional e a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Exceptional e a
forall (m :: * -> *) a. Monad m => a -> m a
return a
r)

resolveT :: (Monad m) =>
   (e -> m a) -> ExceptionalT e m a -> m a
resolveT :: (e -> m a) -> ExceptionalT e m a -> m a
resolveT handler :: e -> m a
handler x :: ExceptionalT e m a
x =
   do Exceptional e a
r <- ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
x
      (e -> m a) -> Exceptional e (m a) -> m a
forall e a. (e -> a) -> Exceptional e a -> a
resolve e -> m a
handler ((a -> m a) -> Exceptional e a -> Exceptional e (m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Exceptional e a
r)

tryT :: (Monad m) =>
   ExceptionalT e m a -> m (Exceptional e a)
tryT :: ExceptionalT e m a -> m (Exceptional e a)
tryT = ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT


{- |
Repeat an action until an exception occurs.
Initialize the result with @empty@ and add new elements using @cons@
(e.g. @[]@ and @(:)@).
The exception handler decides whether the terminating exception
is re-raised ('Just') or catched ('Nothing').
-}
manyT :: (Monad m) =>
   (e0 -> Maybe e1)        {- ^ exception handler -} ->
   (a -> b -> b)           {- ^ @cons@ function -} ->
   b                       {- ^ @empty@ -} ->
   ExceptionalT e0 m a     {- ^ atomic action to repeat -} ->
   ExceptionalT e1 m b
manyT :: (e0 -> Maybe e1)
-> (a -> b -> b) -> b -> ExceptionalT e0 m a -> ExceptionalT e1 m b
manyT handler :: e0 -> Maybe e1
handler cons :: a -> b -> b
cons empty :: b
empty action :: ExceptionalT e0 m a
action =
   (Endo b -> b) -> ExceptionalT e1 m (Endo b) -> ExceptionalT e1 m b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ((Endo b -> b -> b) -> b -> Endo b -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip Endo b -> b -> b
forall a. Endo a -> a -> a
appEndo b
empty) (ExceptionalT e1 m (Endo b) -> ExceptionalT e1 m b)
-> ExceptionalT e1 m (Endo b) -> ExceptionalT e1 m b
forall a b. (a -> b) -> a -> b
$
   (e0 -> Maybe e1)
-> ExceptionalT e0 m (Endo b) -> ExceptionalT e1 m (Endo b)
forall (m :: * -> *) a e0 e1.
(Monad m, Monoid a) =>
(e0 -> Maybe e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a
manyMonoidT e0 -> Maybe e1
handler (ExceptionalT e0 m (Endo b) -> ExceptionalT e1 m (Endo b))
-> ExceptionalT e0 m (Endo b) -> ExceptionalT e1 m (Endo b)
forall a b. (a -> b) -> a -> b
$
   (a -> Endo b) -> ExceptionalT e0 m a -> ExceptionalT e0 m (Endo b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ((b -> b) -> Endo b
forall a. (a -> a) -> Endo a
Endo ((b -> b) -> Endo b) -> (a -> b -> b) -> a -> Endo b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> b
cons) ExceptionalT e0 m a
action

manyMonoidT :: (Monad m, Monoid a) =>
   (e0 -> Maybe e1)        {- ^ exception handler -} ->
   ExceptionalT e0 m a     {- ^ atomic action to repeat -} ->
   ExceptionalT e1 m a
manyMonoidT :: (e0 -> Maybe e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a
manyMonoidT handler :: e0 -> Maybe e1
handler action :: ExceptionalT e0 m a
action =
   let recourse :: ExceptionalT e1 m a
recourse =
          do Exceptional e0 a
r <- m (Exceptional e0 a) -> ExceptionalT e1 m (Exceptional e0 a)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Exceptional e0 a) -> ExceptionalT e1 m (Exceptional e0 a))
-> m (Exceptional e0 a) -> ExceptionalT e1 m (Exceptional e0 a)
forall a b. (a -> b) -> a -> b
$ ExceptionalT e0 m a -> m (Exceptional e0 a)
forall (m :: * -> *) e a.
Monad m =>
ExceptionalT e m a -> m (Exceptional e a)
tryT ExceptionalT e0 m a
action
             case Exceptional e0 a
r of
                -- Exception e -> maybe (return empty) throwT (handler e)
                -- more lazy
                Exception e :: e0
e -> m (Exceptional e1 a) -> ExceptionalT e1 m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e1 a) -> ExceptionalT e1 m a)
-> m (Exceptional e1 a) -> ExceptionalT e1 m a
forall a b. (a -> b) -> a -> b
$ Exceptional e1 a -> m (Exceptional e1 a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e1 a -> m (Exceptional e1 a))
-> Exceptional e1 a -> m (Exceptional e1 a)
forall a b. (a -> b) -> a -> b
$ Exceptional e1 a
-> (e1 -> Exceptional e1 a) -> Maybe e1 -> Exceptional e1 a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> Exceptional e1 a
forall e a. a -> Exceptional e a
Success a
forall a. Monoid a => a
mempty) e1 -> Exceptional e1 a
forall e a. e -> Exceptional e a
throw (e0 -> Maybe e1
handler e0
e)
                Success x :: a
x   -> (a -> a) -> ExceptionalT e1 m a -> ExceptionalT e1 m a
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (a -> a -> a
forall a. Monoid a => a -> a -> a
mappend a
x) ExceptionalT e1 m a
recourse
   in  ExceptionalT e1 m a
recourse


{- |
This combines two actions similar to Applicative's @<*>@.
The result action fails if one of the input action fails,
but both actions are executed.
E.g. consider a compiler that emits all errors
that can be detected independently,
but eventually aborts if there is at least one error.

The exception type @e@ might be a list type,
or an @Endo@ type that implements a difflist.
-}
mergeT ::
   (Monoid e, Monad m) =>
   ExceptionalT e m (a -> b) ->
   ExceptionalT e m a ->
   ExceptionalT e m b
mergeT :: ExceptionalT e m (a -> b)
-> ExceptionalT e m a -> ExceptionalT e m b
mergeT mf :: ExceptionalT e m (a -> b)
mf ma :: ExceptionalT e m a
ma =
   m (Exceptional e b) -> ExceptionalT e m b
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e b) -> ExceptionalT e m b)
-> m (Exceptional e b) -> ExceptionalT e m b
forall a b. (a -> b) -> a -> b
$
   (Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b)
-> m (Exceptional e (a -> b))
-> m (Exceptional e a)
-> m (Exceptional e b)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
forall e a b.
Monoid e =>
Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
merge (ExceptionalT e m (a -> b) -> m (Exceptional e (a -> b))
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m (a -> b)
mf) (ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
ma)

alternativeT, _alternativeT ::
   (Monad m) =>
   ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a
alternativeT :: ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a
alternativeT x :: ExceptionalT e m a
x y :: ExceptionalT e m a
y = ExceptionalT e m a
-> (e -> ExceptionalT e m a) -> ExceptionalT e m a
forall (m :: * -> *) e0 a e1.
Monad m =>
ExceptionalT e0 m a
-> (e0 -> ExceptionalT e1 m a) -> ExceptionalT e1 m a
catchT ExceptionalT e m a
x (ExceptionalT e m a -> e -> ExceptionalT e m a
forall a b. a -> b -> a
const ExceptionalT e m a
y)
_alternativeT :: ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a
_alternativeT x :: ExceptionalT e m a
x y :: ExceptionalT e m a
y =
   m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> m (Exceptional e a) -> ExceptionalT e m a
forall a b. (a -> b) -> a -> b
$ (e -> m (Exceptional e a))
-> (a -> m (Exceptional e a))
-> ExceptionalT e m a
-> m (Exceptional e a)
forall (m :: * -> *) e b a.
Monad m =>
(e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b
switchT (m (Exceptional e a) -> e -> m (Exceptional e a)
forall a b. a -> b -> a
const (m (Exceptional e a) -> e -> m (Exceptional e a))
-> m (Exceptional e a) -> e -> m (Exceptional e a)
forall a b. (a -> b) -> a -> b
$ ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
y) (Exceptional e a -> m (Exceptional e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e a -> m (Exceptional e a))
-> (a -> Exceptional e a) -> a -> m (Exceptional e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Exceptional e a
forall e a. a -> Exceptional e a
Success) ExceptionalT e m a
x


instance Functor m => Functor (ExceptionalT e m) where
   fmap :: (a -> b) -> ExceptionalT e m a -> ExceptionalT e m b
fmap f :: a -> b
f (ExceptionalT x :: m (Exceptional e a)
x) =
      m (Exceptional e b) -> ExceptionalT e m b
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT ((Exceptional e a -> Exceptional e b)
-> m (Exceptional e a) -> m (Exceptional e b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Exceptional e a -> Exceptional e b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) m (Exceptional e a)
x)

instance Applicative m => Applicative (ExceptionalT e m) where
   pure :: a -> ExceptionalT e m a
pure = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (a -> m (Exceptional e a)) -> a -> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exceptional e a -> m (Exceptional e a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exceptional e a -> m (Exceptional e a))
-> (a -> Exceptional e a) -> a -> m (Exceptional e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Exceptional e a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
   ExceptionalT f :: m (Exceptional e (a -> b))
f <*> :: ExceptionalT e m (a -> b)
-> ExceptionalT e m a -> ExceptionalT e m b
<*> ExceptionalT x :: m (Exceptional e a)
x =
      m (Exceptional e b) -> ExceptionalT e m b
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT ((Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b)
-> m (Exceptional e (a -> b))
-> m (Exceptional e a -> Exceptional e b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>) m (Exceptional e (a -> b))
f m (Exceptional e a -> Exceptional e b)
-> m (Exceptional e a) -> m (Exceptional e b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (Exceptional e a)
x)

instance Monad m => Monad (ExceptionalT e m) where
   return :: a -> ExceptionalT e m a
return = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> (a -> m (Exceptional e a)) -> a -> ExceptionalT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exceptional e a -> m (Exceptional e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exceptional e a -> m (Exceptional e a))
-> (a -> Exceptional e a) -> a -> m (Exceptional e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Exceptional e a
forall (m :: * -> *) a. Monad m => a -> m a
return
   x0 :: ExceptionalT e m a
x0 >>= :: ExceptionalT e m a
-> (a -> ExceptionalT e m b) -> ExceptionalT e m b
>>= f :: a -> ExceptionalT e m b
f =
      m (Exceptional e b) -> ExceptionalT e m b
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e b) -> ExceptionalT e m b)
-> m (Exceptional e b) -> ExceptionalT e m b
forall a b. (a -> b) -> a -> b
$
         ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
x0 m (Exceptional e a)
-> (Exceptional e a -> m (Exceptional e b)) -> m (Exceptional e b)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \x1 :: Exceptional e a
x1 ->
         case Exceptional e a
x1 of
            Exception e :: e
e -> Exceptional e b -> m (Exceptional e b)
forall (m :: * -> *) a. Monad m => a -> m a
return (e -> Exceptional e b
forall e a. e -> Exceptional e a
Exception e
e)
            Success x :: a
x -> ExceptionalT e m b -> m (Exceptional e b)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT (ExceptionalT e m b -> m (Exceptional e b))
-> ExceptionalT e m b -> m (Exceptional e b)
forall a b. (a -> b) -> a -> b
$ a -> ExceptionalT e m b
f a
x

{- |
Same restrictions applies as for @instance MonadFix (Exceptional e a)@.
-}
instance (MonadFix m) => MonadFix (ExceptionalT e m) where
   mfix :: (a -> ExceptionalT e m a) -> ExceptionalT e m a
mfix f :: a -> ExceptionalT e m a
f = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> m (Exceptional e a) -> ExceptionalT e m a
forall a b. (a -> b) -> a -> b
$ (Exceptional e a -> m (Exceptional e a)) -> m (Exceptional e a)
forall (m :: * -> *) a. MonadFix m => (a -> m a) -> m a
mfix ((Exceptional e a -> m (Exceptional e a)) -> m (Exceptional e a))
-> (Exceptional e a -> m (Exceptional e a)) -> m (Exceptional e a)
forall a b. (a -> b) -> a -> b
$ \ ~(Success r :: a
r) -> ExceptionalT e m a -> m (Exceptional e a)
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT (ExceptionalT e m a -> m (Exceptional e a))
-> ExceptionalT e m a -> m (Exceptional e a)
forall a b. (a -> b) -> a -> b
$ a -> ExceptionalT e m a
f a
r

instance MonadTrans (ExceptionalT e) where
   lift :: m a -> ExceptionalT e m a
lift m :: m a
m = m (Exceptional e a) -> ExceptionalT e m a
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (m (Exceptional e a) -> ExceptionalT e m a)
-> m (Exceptional e a) -> ExceptionalT e m a
forall a b. (a -> b) -> a -> b
$ (a -> Exceptional e a) -> m a -> m (Exceptional e a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM a -> Exceptional e a
forall e a. a -> Exceptional e a
Success m a
m

{-
instance MonadIO m => MonadIO (ExceptionalT e m) where
   liftIO act = ExceptionalT $ liftIO $ liftM Success act
-}