module Control.Monad.Ology.Specific.ResultT where

import Control.Monad.Ology.Data.Exn
import Control.Monad.Ology.General
import Control.Monad.Ology.Specific.ComposeInner
import Control.Monad.Ology.Specific.Result
import Import

type ResultT e = ComposeInner (Result e)

runResultT :: forall m e a. ResultT e m a -> m (Result e a)
runResultT :: forall (m :: Type -> Type) e a. ResultT e m a -> m (Result e a)
runResultT = forall (inner :: Type -> Type) (outer :: Type -> Type) a.
ComposeInner inner outer a -> outer (inner a)
unComposeInner

-- | Throw the parameterised exception type.
throwR ::
       forall m e a. Monad m
    => e
    -> ResultT e m a
throwR :: forall (m :: Type -> Type) e a. Monad m => e -> ResultT e m a
throwR e
e = forall (outer :: Type -> Type) (inner :: Type -> Type).
Applicative outer =>
inner --> ComposeInner inner outer
liftInner forall a b. (a -> b) -> a -> b
$ forall (m :: Type -> Type) a. MonadException m => Exc m -> m a
throwExc e
e

-- | Catch the parameterised exception type.
catchR ::
       forall m e e' a. Monad m
    => ResultT e m a
    -> (e -> ResultT e' m a)
    -> ResultT e' m a
catchR :: forall (m :: Type -> Type) e e' a.
Monad m =>
ResultT e m a -> (e -> ResultT e' m a) -> ResultT e' m a
catchR (MkComposeInner m (Result e a)
rma) e -> ResultT e' m a
handler =
    forall (inner :: Type -> Type) (outer :: Type -> Type) a.
outer (inner a) -> ComposeInner inner outer a
MkComposeInner forall a b. (a -> b) -> a -> b
$ do
        Result e a
rea <- m (Result e a)
rma
        case Result e a
rea of
            SuccessResult a
a -> forall (m :: Type -> Type) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall e a. a -> Result e a
SuccessResult a
a
            FailureResult e
e -> forall (inner :: Type -> Type) (outer :: Type -> Type) a.
ComposeInner inner outer a -> outer (inner a)
unComposeInner forall a b. (a -> b) -> a -> b
$ e -> ResultT e' m a
handler e
e

resultExn ::
       forall m e. Monad m
    => Exn (ResultT e m) e
resultExn :: forall (m :: Type -> Type) e. Monad m => Exn (ResultT e m) e
resultExn = forall (m :: Type -> Type) e.
(forall a. e -> m a)
-> (forall a. m a -> (e -> m a) -> m a) -> Exn m e
MkExn forall (m :: Type -> Type) e a. Monad m => e -> ResultT e m a
throwR forall (m :: Type -> Type) e e' a.
Monad m =>
ResultT e m a -> (e -> ResultT e' m a) -> ResultT e' m a
catchR