module Control.Monad.Exception.Asynchronous.Strict (
Exceptional(..),
pure,
broken,
fromSynchronous,
fromSynchronousNull,
fromSynchronousMonoid,
toSynchronous,
throw,
throwMonoid,
eatNothing,
zipWith,
append,
continue,
maybeAbort,
force,
mapException,
mapExceptional,
simultaneousBind,
simultaneousBindM,
sequenceF,
traverse,
sequenceA,
mapM,
sequence,
swapToSynchronousAsynchronous,
swapToAsynchronousSynchronous,
ExceptionalT(..),
fromSynchronousT,
fromSynchronousMonoidT,
forceT,
mapExceptionT,
mapExceptionalT,
throwMonoidT,
eatNothingT,
bindT,
manySynchronousT,
manyMonoidT,
processToSynchronousT_,
appendM,
continueM,
) where
import qualified Control.Monad.Exception.Synchronous as Sync
import Control.Monad (Monad, return, liftM, mplus, join, (>>=), (>>), )
import Control.Applicative (Applicative, liftA, )
import Control.DeepSeq (NFData, rnf, )
import Data.Functor (Functor, fmap, )
import Data.Monoid(Monoid, mappend, mempty, )
import Data.Semigroup (Semigroup((<>)), )
import Data.Function (const, (.), ($), )
import Data.Maybe (Maybe(Just, Nothing), maybe, )
import Prelude (Show, )
data Exceptional e a =
Exceptional {forall e a. Exceptional e a -> Maybe e
exception :: Maybe e, forall e a. Exceptional e a -> a
result :: a}
deriving Int -> Exceptional e a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e a. (Show e, Show a) => Int -> Exceptional e a -> ShowS
forall e a. (Show e, Show a) => [Exceptional e a] -> ShowS
forall e a. (Show e, Show a) => Exceptional e a -> String
showList :: [Exceptional e a] -> ShowS
$cshowList :: forall e a. (Show e, Show a) => [Exceptional e a] -> ShowS
show :: Exceptional e a -> String
$cshow :: forall e a. (Show e, Show a) => Exceptional e a -> String
showsPrec :: Int -> Exceptional e a -> ShowS
$cshowsPrec :: forall e a. (Show e, Show a) => Int -> Exceptional e a -> ShowS
Show
pure :: a -> Exceptional e a
pure :: forall a e. a -> Exceptional e a
pure = forall e a. Maybe e -> a -> Exceptional e a
Exceptional forall a. Maybe a
Nothing
broken :: e -> a -> Exceptional e a
broken :: forall e a. e -> a -> Exceptional e a
broken e
e = forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall a. a -> Maybe a
Just e
e)
fromSynchronous :: a -> Sync.Exceptional e a -> Exceptional e a
fromSynchronous :: forall a e. a -> Exceptional e a -> Exceptional e a
fromSynchronous a
deflt Exceptional e a
x =
case Exceptional e a
x of
Sync.Success a
y -> forall e a. Maybe e -> a -> Exceptional e a
Exceptional forall a. Maybe a
Nothing a
y
Sync.Exception e
e -> forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall a. a -> Maybe a
Just e
e) a
deflt
fromSynchronousNull :: Sync.Exceptional e () -> Exceptional e ()
fromSynchronousNull :: forall e. Exceptional e () -> Exceptional e ()
fromSynchronousNull = forall a e. a -> Exceptional e a -> Exceptional e a
fromSynchronous ()
fromSynchronousMonoid :: Monoid a =>
Sync.Exceptional e a -> Exceptional e a
fromSynchronousMonoid :: forall a e. Monoid a => Exceptional e a -> Exceptional e a
fromSynchronousMonoid = forall a e. a -> Exceptional e a -> Exceptional e a
fromSynchronous forall a. Monoid a => a
mempty
toSynchronous :: Exceptional e a -> Sync.Exceptional e a
toSynchronous :: forall e a. Exceptional e a -> Exceptional e a
toSynchronous (Exceptional Maybe e
me a
a) =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall e a. a -> Exceptional e a
Sync.Success a
a) forall e a. e -> Exceptional e a
Sync.Exception Maybe e
me
throw :: e -> Exceptional e ()
throw :: forall e. e -> Exceptional e ()
throw e
e = forall e a. e -> a -> Exceptional e a
broken e
e ()
throwMonoid :: Monoid a => e -> Exceptional e a
throwMonoid :: forall a e. Monoid a => e -> Exceptional e a
throwMonoid e
e = forall e a. e -> a -> Exceptional e a
broken e
e forall a. Monoid a => a
mempty
eatNothing :: Exceptional (Maybe e) a -> Exceptional e a
eatNothing :: forall e a. Exceptional (Maybe e) a -> Exceptional e a
eatNothing (Exceptional Maybe (Maybe e)
e a
a) =
forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (m :: * -> *) a. Monad m => m (m a) -> m a
join Maybe (Maybe e)
e) a
a
zipWith ::
(a -> b -> c) ->
Exceptional e [a] -> Exceptional e [b] -> Exceptional e [c]
zipWith :: forall a b c e.
(a -> b -> c)
-> Exceptional e [a] -> Exceptional e [b] -> Exceptional e [c]
zipWith a -> b -> c
f (Exceptional Maybe e
ea [a]
a0) (Exceptional Maybe e
eb [b]
b0) =
let recourse :: [a] -> [b] -> Exceptional e [c]
recourse (a
a:[a]
as) (b
b:[b]
bs) =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> b -> c
f a
a b
b forall a. a -> [a] -> [a]
:) ([a] -> [b] -> Exceptional e [c]
recourseF [a]
as [b]
bs)
recourse [a]
as [b]
_ =
forall e a. Maybe e -> a -> Exceptional e a
Exceptional (case [a]
as of [] -> forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus Maybe e
ea Maybe e
eb; [a]
_ -> Maybe e
eb) []
recourseF :: [a] -> [b] -> Exceptional e [c]
recourseF [a]
as [b]
bs = [a] -> [b] -> Exceptional e [c]
recourse [a]
as [b]
bs
in [a] -> [b] -> Exceptional e [c]
recourseF [a]
a0 [b]
b0
infixr 1 `append`, `continue`, `maybeAbort`
append ::
Monoid a =>
Exceptional e a -> Exceptional e a -> Exceptional e a
append :: forall a e.
Monoid a =>
Exceptional e a -> Exceptional e a -> Exceptional e a
append (Exceptional Maybe e
ea a
a) Exceptional e a
b =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Monoid a => a -> a -> a
mappend a
a) forall a b. (a -> b) -> a -> b
$ forall a e.
Monoid a =>
Maybe e -> Exceptional e a -> Exceptional e a
continue Maybe e
ea Exceptional e a
b
continue ::
Monoid a =>
Maybe e -> Exceptional e a -> Exceptional e a
continue :: forall a e.
Monoid a =>
Maybe e -> Exceptional e a -> Exceptional e a
continue Maybe e
ea Exceptional e a
b =
case Maybe e
ea of
Just e
_ -> forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
ea forall a. Monoid a => a
mempty
Maybe e
Nothing -> Exceptional e a
b
maybeAbort ::
Exceptional e a -> Maybe e -> Exceptional e a
maybeAbort :: forall e a. Exceptional e a -> Maybe e -> Exceptional e a
maybeAbort (Exceptional Maybe e
ea a
a) Maybe e
eb =
forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus Maybe e
ea Maybe e
eb) a
a
instance (NFData e, NFData a) => NFData (Exceptional e a) where
rnf :: Exceptional e a -> ()
rnf (Exceptional Maybe e
e a
a) = forall a. NFData a => a -> ()
rnf (Maybe e
e, a
a)
instance Monoid a => Semigroup (Exceptional e a) where
Exceptional Maybe e
ea a
a <> :: Exceptional e a -> Exceptional e a -> Exceptional e a
<> Exceptional Maybe e
eb a
b =
forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus Maybe e
ea Maybe e
eb) (forall a. Monoid a => a -> a -> a
mappend a
a (forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
b (forall a b. a -> b -> a
const forall a. Monoid a => a
mempty) Maybe e
ea))
instance Monoid a => Monoid (Exceptional e a) where
mempty :: Exceptional e a
mempty = forall a e. a -> Exceptional e a
pure forall a. Monoid a => a
mempty
mappend :: Exceptional e a -> Exceptional e a -> Exceptional e a
mappend = forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE force #-}
force :: Exceptional e a -> Exceptional e a
force :: forall e a. Exceptional e a -> Exceptional e a
force ~(Exceptional Maybe e
e a
a) = forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
e a
a
mapException :: (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException :: forall e0 e1 a. (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException e0 -> e1
f (Exceptional Maybe e0
e a
a) = forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap e0 -> e1
f Maybe e0
e) a
a
mapExceptional :: (e0 -> e1) -> (a -> b) -> Exceptional e0 a -> Exceptional e1 b
mapExceptional :: forall e0 e1 a b.
(e0 -> e1) -> (a -> b) -> Exceptional e0 a -> Exceptional e1 b
mapExceptional e0 -> e1
f a -> b
g (Exceptional Maybe e0
e a
a) = forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap e0 -> e1
f Maybe e0
e) (a -> b
g a
a)
instance Functor (Exceptional e) where
fmap :: forall a b. (a -> b) -> Exceptional e a -> Exceptional e b
fmap a -> b
f (Exceptional Maybe e
e a
a) = forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
e (a -> b
f a
a)
infixr 1 `simultaneousBind`, `simultaneousBindM`
{-# DEPRECATED simultaneousBind, simultaneousBindM "Check whether this function is really what you need. It generates an unreasonable exception when the second exception is caused by the first one." #-}
simultaneousBind :: Exceptional e a -> (a -> Exceptional e b) -> Exceptional e b
simultaneousBind :: forall e a b.
Exceptional e a -> (a -> Exceptional e b) -> Exceptional e b
simultaneousBind (Exceptional Maybe e
mea a
a) a -> Exceptional e b
actB =
let Exceptional Maybe e
meb b
b = a -> Exceptional e b
actB a
a
in forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus Maybe e
meb Maybe e
mea) b
b
simultaneousBindM :: (Monad m) => m (Exceptional e a) -> (a -> m (Exceptional e b)) -> m (Exceptional e b)
simultaneousBindM :: forall (m :: * -> *) e a b.
Monad m =>
m (Exceptional e a)
-> (a -> m (Exceptional e b)) -> m (Exceptional e b)
simultaneousBindM m (Exceptional e a)
actA a -> m (Exceptional e b)
actB =
do Exceptional Maybe e
mea a
a <- m (Exceptional e a)
actA
Exceptional Maybe e
meb b
b <- a -> m (Exceptional e b)
actB a
a
forall (m :: * -> *) a. Monad m => a -> m a
return (forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus Maybe e
meb Maybe e
mea) b
b)
{-# INLINE sequenceF #-}
sequenceF :: Functor f => Exceptional e (f a) -> f (Exceptional e a)
sequenceF :: forall (f :: * -> *) e a.
Functor f =>
Exceptional e (f a) -> f (Exceptional e a)
sequenceF (Exceptional Maybe e
e f a
a) =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
e) f a
a
{-# INLINE traverse #-}
traverse :: Applicative f => (a -> f b) -> Exceptional e a -> f (Exceptional e b)
traverse :: forall (f :: * -> *) a b e.
Applicative f =>
(a -> f b) -> Exceptional e a -> f (Exceptional e b)
traverse a -> f b
f = forall (f :: * -> *) e a.
Applicative f =>
Exceptional e (f a) -> f (Exceptional e a)
sequenceA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> f b
f
{-# INLINE sequenceA #-}
sequenceA :: Applicative f => Exceptional e (f a) -> f (Exceptional e a)
sequenceA :: forall (f :: * -> *) e a.
Applicative f =>
Exceptional e (f a) -> f (Exceptional e a)
sequenceA (Exceptional Maybe e
e f a
a) =
forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
liftA (forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
e) f a
a
{-# INLINE mapM #-}
mapM :: Monad m => (a -> m b) -> Exceptional e a -> m (Exceptional e b)
mapM :: forall (m :: * -> *) a b e.
Monad m =>
(a -> m b) -> Exceptional e a -> m (Exceptional e b)
mapM a -> m b
f = forall (m :: * -> *) e a.
Monad m =>
Exceptional e (m a) -> m (Exceptional e a)
sequence forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> m b
f
{-# INLINE sequence #-}
sequence :: Monad m => Exceptional e (m a) -> m (Exceptional e a)
sequence :: forall (m :: * -> *) e a.
Monad m =>
Exceptional e (m a) -> m (Exceptional e a)
sequence (Exceptional Maybe e
e m a
a) =
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e
e) m a
a
swapToSynchronousAsynchronous :: Exceptional e0 (Sync.Exceptional e1 a) -> Sync.Exceptional e1 (Exceptional e0 a)
swapToSynchronousAsynchronous :: forall e0 e1 a.
Exceptional e0 (Exceptional e1 a)
-> Exceptional e1 (Exceptional e0 a)
swapToSynchronousAsynchronous (Exceptional Maybe e0
e0 Exceptional e1 a
x) =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall e a. Maybe e -> a -> Exceptional e a
Exceptional Maybe e0
e0) Exceptional e1 a
x
swapToAsynchronousSynchronous :: Sync.Exceptional e1 (Exceptional e0 a) -> Exceptional e0 (Sync.Exceptional e1 a)
swapToAsynchronousSynchronous :: forall e1 e0 a.
Exceptional e1 (Exceptional e0 a)
-> Exceptional e0 (Exceptional e1 a)
swapToAsynchronousSynchronous Exceptional e1 (Exceptional e0 a)
x =
case Exceptional e1 (Exceptional e0 a)
x of
Sync.Exception e1
e1 -> forall a e. a -> Exceptional e a
pure forall a b. (a -> b) -> a -> b
$ forall e a. e -> Exceptional e a
Sync.Exception e1
e1
Sync.Success Exceptional e0 a
s -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall e a. a -> Exceptional e a
Sync.Success Exceptional e0 a
s
newtype ExceptionalT e m a =
ExceptionalT {forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT :: m (Exceptional e a)}
fromSynchronousT :: Functor m =>
a -> Sync.ExceptionalT e m a -> ExceptionalT e m a
fromSynchronousT :: forall (m :: * -> *) a e.
Functor m =>
a -> ExceptionalT e m a -> ExceptionalT e m a
fromSynchronousT a
deflt =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a e. a -> Exceptional e a -> Exceptional e a
fromSynchronous a
deflt) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
Sync.runExceptionalT
fromSynchronousMonoidT :: (Functor m, Monoid a) =>
Sync.ExceptionalT e m a -> ExceptionalT e m a
fromSynchronousMonoidT :: forall (m :: * -> *) a e.
(Functor m, Monoid a) =>
ExceptionalT e m a -> ExceptionalT e m a
fromSynchronousMonoidT =
forall (m :: * -> *) a e.
Functor m =>
a -> ExceptionalT e m a -> ExceptionalT e m a
fromSynchronousT forall a. Monoid a => a
mempty
instance Functor m => Functor (ExceptionalT e m) where
fmap :: forall a b. (a -> b) -> ExceptionalT e m a -> ExceptionalT e m b
fmap a -> b
f (ExceptionalT m (Exceptional e a)
x) =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) m (Exceptional e a)
x)
instance (Monad m, Monoid a) => Semigroup (ExceptionalT e m a) where
ExceptionalT e m a
x <> :: ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a
<> ExceptionalT e m a
y =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
m (Exceptional e a) -> m (Exceptional e a) -> m (Exceptional e a)
appendM (forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
x) (forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
y)
instance (Monad m, Monoid a) => Monoid (ExceptionalT e m a) where
mempty :: ExceptionalT e m a
mempty = forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Monoid a => a
mempty
mappend :: ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a
mappend = forall a. Semigroup a => a -> a -> a
(<>)
forceT :: Monad m => ExceptionalT e m a -> ExceptionalT e m a
forceT :: forall (m :: * -> *) e a.
Monad m =>
ExceptionalT e m a -> ExceptionalT e m a
forceT =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall e a. Exceptional e a -> Exceptional e a
force forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: forall (m :: * -> *) e0 e1 a.
Monad m =>
(e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a
mapExceptionT e0 -> e1
f =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall e0 e1 a. (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a
mapException e0 -> e1
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: forall (m :: * -> *) e0 a (n :: * -> *) e1 b.
(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)
f =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Exceptional e0 a) -> n (Exceptional e1 b)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT
throwMonoidT :: (Monad m, Monoid a) =>
e -> ExceptionalT e m a
throwMonoidT :: forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
e -> ExceptionalT e m a
throwMonoidT = forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a e. Monoid a => e -> Exceptional e a
throwMonoid
eatNothingT :: Monad m =>
ExceptionalT (Maybe e) m a -> ExceptionalT e m a
eatNothingT :: forall (m :: * -> *) e a.
Monad m =>
ExceptionalT (Maybe e) m a -> ExceptionalT e m a
eatNothingT =
forall (m :: * -> *) e0 a (n :: * -> *) e1 b.
(m (Exceptional e0 a) -> n (Exceptional e1 b))
-> ExceptionalT e0 m a -> ExceptionalT e1 n b
mapExceptionalT (forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall e a. Exceptional (Maybe e) a -> Exceptional e a
eatNothing)
infixl 1 `bindT`
bindT :: (Monad m, Monoid b) =>
ExceptionalT e m a ->
(a -> ExceptionalT e m b) ->
ExceptionalT e m b
bindT :: forall (m :: * -> *) b e a.
(Monad m, Monoid b) =>
ExceptionalT e m a
-> (a -> ExceptionalT e m b) -> ExceptionalT e m b
bindT ExceptionalT e m a
x a -> ExceptionalT e m b
y =
forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
ExceptionalT forall a b. (a -> b) -> a -> b
$
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT ExceptionalT e m a
x forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Exceptional e a
r ->
forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
runExceptionalT forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> ExceptionalT e m b
y forall a b. (a -> b) -> a -> b
$ forall e a. Exceptional e a -> a
result Exceptional e a
r) forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
e -> ExceptionalT e m a
throwMonoidT (forall e a. Exceptional e a -> Maybe e
exception Exceptional e a
r)
infixr 1 `appendM`, `continueM`
appendM :: (Monad m, Monoid a) =>
m (Exceptional e a) -> m (Exceptional e a) -> m (Exceptional e a)
appendM :: forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
m (Exceptional e a) -> m (Exceptional e a) -> m (Exceptional e a)
appendM m (Exceptional e a)
x m (Exceptional e a)
y =
do Exceptional e a
r <- m (Exceptional e a)
x
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Monoid a => a -> a -> a
mappend (forall e a. Exceptional e a -> a
result Exceptional e a
r))) forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
Maybe e -> m (Exceptional e a) -> m (Exceptional e a)
continueMPlain (forall e a. Exceptional e a -> Maybe e
exception Exceptional e a
r) m (Exceptional e a)
y
continueM :: (Monad m, Monoid a) =>
m (Maybe e) -> m (Exceptional e a) -> m (Exceptional e a)
continueM :: forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
m (Maybe e) -> m (Exceptional e a) -> m (Exceptional e a)
continueM m (Maybe e)
mx m (Exceptional e a)
y =
m (Maybe e)
mx forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe e
x -> forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
Maybe e -> m (Exceptional e a) -> m (Exceptional e a)
continueMPlain Maybe e
x m (Exceptional e a)
y
continueMPlain :: (Monad m, Monoid a) =>
Maybe e -> m (Exceptional e a) -> m (Exceptional e a)
continueMPlain :: forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
Maybe e -> m (Exceptional e a) -> m (Exceptional e a)
continueMPlain Maybe e
x m (Exceptional e a)
y =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m (Exceptional e a)
y (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a e. Monoid a => e -> Exceptional e a
throwMonoid) Maybe e
x
manySynchronousT :: (Monad m) =>
(m (Exceptional e b) -> m (Exceptional e b))
->
(a -> b -> b) ->
b ->
Sync.ExceptionalT e m a ->
m (Exceptional e b)
manySynchronousT :: forall (m :: * -> *) e b a.
Monad m =>
(m (Exceptional e b) -> m (Exceptional e b))
-> (a -> b -> b) -> b -> ExceptionalT e m a -> m (Exceptional e b)
manySynchronousT m (Exceptional e b) -> m (Exceptional e b)
defer a -> b -> b
cons b
empty ExceptionalT e m a
action =
let recourse :: m (Exceptional e b)
recourse =
m (Exceptional e b) -> m (Exceptional e b)
defer forall a b. (a -> b) -> a -> b
$
do Exceptional e a
r <- forall (m :: * -> *) e a.
Monad m =>
ExceptionalT e m a -> m (Exceptional e a)
Sync.tryT ExceptionalT e m a
action
case Exceptional e a
r of
Sync.Exception e
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall e a. Maybe e -> a -> Exceptional e a
Exceptional (forall a. a -> Maybe a
Just e
e) b
empty)
Sync.Success a
x -> forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> b -> b
cons a
x)) m (Exceptional e b)
recourse
in m (Exceptional e b)
recourse
{-# DEPRECATED manySynchronousT "use manyMonoidT with appropriate Monad like LazyIO and result Monoid like Endo instead" #-}
manyMonoidT :: (Monad m, Monoid a) =>
ExceptionalT e m a ->
ExceptionalT e m a
manyMonoidT :: forall (m :: * -> *) a e.
(Monad m, Monoid a) =>
ExceptionalT e m a -> ExceptionalT e m a
manyMonoidT ExceptionalT e m a
act =
let
customFmap :: (a -> b) -> ExceptionalT e1 n a -> ExceptionalT e1 n b
customFmap a -> b
f = forall (m :: * -> *) e0 a (n :: * -> *) e1 b.
(m (Exceptional e0 a) -> n (Exceptional e1 b))
-> ExceptionalT e0 m a -> ExceptionalT e1 n b
mapExceptionalT (forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f))
go :: ExceptionalT e m a
go = ExceptionalT e m a
act forall (m :: * -> *) b e a.
(Monad m, Monoid b) =>
ExceptionalT e m a
-> (a -> ExceptionalT e m b) -> ExceptionalT e m b
`bindT` \a
r -> forall {n :: * -> *} {a} {b} {e1}.
Monad n =>
(a -> b) -> ExceptionalT e1 n a -> ExceptionalT e1 n b
customFmap (forall a. Monoid a => a -> a -> a
mappend a
r) ExceptionalT e m a
go
in ExceptionalT e m a
go
processToSynchronousT_ :: (Monad m) =>
(b -> Maybe (a,b)) ->
(a -> Sync.ExceptionalT e m ())
->
Exceptional e b ->
Sync.ExceptionalT e m ()
processToSynchronousT_ :: forall (m :: * -> *) b a e.
Monad m =>
(b -> Maybe (a, b))
-> (a -> ExceptionalT e m ())
-> Exceptional e b
-> ExceptionalT e m ()
processToSynchronousT_ b -> Maybe (a, b)
decons a -> ExceptionalT e m ()
action (Exceptional Maybe e
me b
x) =
let recourse :: b -> ExceptionalT e m ()
recourse b
b0 =
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
(forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (m :: * -> *) e a. Monad m => e -> ExceptionalT e m a
Sync.throwT Maybe e
me)
(\(a
a,b
b1) -> a -> ExceptionalT e m ()
action a
a forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> ExceptionalT e m ()
recourse b
b1)
(b -> Maybe (a, b)
decons b
b0)
in b -> ExceptionalT e m ()
recourse b
x