{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes                 #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE UnicodeSyntax              #-}


module ZIO.Trans (
    EIO(..), ZIO(..)
  , UEIO, URIO, UZIO, Task, RIO
  , elift, ezlift, zlift
  , uelift, uzlift
  , euUnlift, zuUnlift
  , mapEError, mapZError
  , runEIO, runZIO
  , withEIO, withZIO
  , module Control.Monad.Except
  , module Control.Monad.Reader
  , module UnexceptionalIO
  , module UnexceptionalIO.Trans

) where

import           Control.Monad.Except
import           Control.Monad.Reader hiding (lift)
import           Data.Void (Void, absurd)
import           UnexceptionalIO hiding (fromIO, lift, run)
import           UnexceptionalIO.Trans (UIO, fromIO, run)

-- | Corresponds to IO[E, A] in Scala
newtype EIO e a = EIO { EIO e a -> ExceptT e UIO a
_unEIO :: ExceptT e UIO a }
  deriving ( a -> EIO e b -> EIO e a
(a -> b) -> EIO e a -> EIO e b
(forall a b. (a -> b) -> EIO e a -> EIO e b)
-> (forall a b. a -> EIO e b -> EIO e a) -> Functor (EIO e)
forall a b. a -> EIO e b -> EIO e a
forall a b. (a -> b) -> EIO e a -> EIO e b
forall e a b. a -> EIO e b -> EIO e a
forall e a b. (a -> b) -> EIO e a -> EIO e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> EIO e b -> EIO e a
$c<$ :: forall e a b. a -> EIO e b -> EIO e a
fmap :: (a -> b) -> EIO e a -> EIO e b
$cfmap :: forall e a b. (a -> b) -> EIO e a -> EIO e b
Functor, Functor (EIO e)
a -> EIO e a
Functor (EIO e)
-> (forall a. a -> EIO e a)
-> (forall a b. EIO e (a -> b) -> EIO e a -> EIO e b)
-> (forall a b c. (a -> b -> c) -> EIO e a -> EIO e b -> EIO e c)
-> (forall a b. EIO e a -> EIO e b -> EIO e b)
-> (forall a b. EIO e a -> EIO e b -> EIO e a)
-> Applicative (EIO e)
EIO e a -> EIO e b -> EIO e b
EIO e a -> EIO e b -> EIO e a
EIO e (a -> b) -> EIO e a -> EIO e b
(a -> b -> c) -> EIO e a -> EIO e b -> EIO e c
forall e. Functor (EIO e)
forall a. a -> EIO e a
forall e a. a -> EIO e a
forall a b. EIO e a -> EIO e b -> EIO e a
forall a b. EIO e a -> EIO e b -> EIO e b
forall a b. EIO e (a -> b) -> EIO e a -> EIO e b
forall e a b. EIO e a -> EIO e b -> EIO e a
forall e a b. EIO e a -> EIO e b -> EIO e b
forall e a b. EIO e (a -> b) -> EIO e a -> EIO e b
forall a b c. (a -> b -> c) -> EIO e a -> EIO e b -> EIO e c
forall e a b c. (a -> b -> c) -> EIO e a -> EIO e b -> EIO e c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: EIO e a -> EIO e b -> EIO e a
$c<* :: forall e a b. EIO e a -> EIO e b -> EIO e a
*> :: EIO e a -> EIO e b -> EIO e b
$c*> :: forall e a b. EIO e a -> EIO e b -> EIO e b
liftA2 :: (a -> b -> c) -> EIO e a -> EIO e b -> EIO e c
$cliftA2 :: forall e a b c. (a -> b -> c) -> EIO e a -> EIO e b -> EIO e c
<*> :: EIO e (a -> b) -> EIO e a -> EIO e b
$c<*> :: forall e a b. EIO e (a -> b) -> EIO e a -> EIO e b
pure :: a -> EIO e a
$cpure :: forall e a. a -> EIO e a
$cp1Applicative :: forall e. Functor (EIO e)
Applicative, Applicative (EIO e)
a -> EIO e a
Applicative (EIO e)
-> (forall a b. EIO e a -> (a -> EIO e b) -> EIO e b)
-> (forall a b. EIO e a -> EIO e b -> EIO e b)
-> (forall a. a -> EIO e a)
-> Monad (EIO e)
EIO e a -> (a -> EIO e b) -> EIO e b
EIO e a -> EIO e b -> EIO e b
forall e. Applicative (EIO e)
forall a. a -> EIO e a
forall e a. a -> EIO e a
forall a b. EIO e a -> EIO e b -> EIO e b
forall a b. EIO e a -> (a -> EIO e b) -> EIO e b
forall e a b. EIO e a -> EIO e b -> EIO e b
forall e a b. EIO e a -> (a -> EIO e b) -> EIO e b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> EIO e a
$creturn :: forall e a. a -> EIO e a
>> :: EIO e a -> EIO e b -> EIO e b
$c>> :: forall e a b. EIO e a -> EIO e b -> EIO e b
>>= :: EIO e a -> (a -> EIO e b) -> EIO e b
$c>>= :: forall e a b. EIO e a -> (a -> EIO e b) -> EIO e b
$cp1Monad :: forall e. Applicative (EIO e)
Monad, MonadError e, Monad (EIO e)
Monad (EIO e)
-> (forall a. (a -> EIO e a) -> EIO e a) -> MonadFix (EIO e)
(a -> EIO e a) -> EIO e a
forall e. Monad (EIO e)
forall a. (a -> EIO e a) -> EIO e a
forall e a. (a -> EIO e a) -> EIO e a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> EIO e a) -> EIO e a
$cmfix :: forall e a. (a -> EIO e a) -> EIO e a
$cp1MonadFix :: forall e. Monad (EIO e)
MonadFix, Monad (EIO e)
Monad (EIO e)
-> (forall a. UIO a -> EIO e a) -> Unexceptional (EIO e)
UIO a -> EIO e a
forall e. Monad (EIO e)
forall a. UIO a -> EIO e a
forall e a. UIO a -> EIO e a
forall (m :: * -> *).
Monad m -> (forall a. UIO a -> m a) -> Unexceptional m
lift :: UIO a -> EIO e a
$clift :: forall e a. UIO a -> EIO e a
$cp1Unexceptional :: forall e. Monad (EIO e)
Unexceptional )

newtype ZIO r e a = ZIO { ZIO r e a -> ReaderT r (EIO e) a
_unZIO :: ReaderT r (EIO e) a }
  deriving ( a -> ZIO r e b -> ZIO r e a
(a -> b) -> ZIO r e a -> ZIO r e b
(forall a b. (a -> b) -> ZIO r e a -> ZIO r e b)
-> (forall a b. a -> ZIO r e b -> ZIO r e a) -> Functor (ZIO r e)
forall a b. a -> ZIO r e b -> ZIO r e a
forall a b. (a -> b) -> ZIO r e a -> ZIO r e b
forall r e a b. a -> ZIO r e b -> ZIO r e a
forall r e a b. (a -> b) -> ZIO r e a -> ZIO r e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ZIO r e b -> ZIO r e a
$c<$ :: forall r e a b. a -> ZIO r e b -> ZIO r e a
fmap :: (a -> b) -> ZIO r e a -> ZIO r e b
$cfmap :: forall r e a b. (a -> b) -> ZIO r e a -> ZIO r e b
Functor, Functor (ZIO r e)
a -> ZIO r e a
Functor (ZIO r e)
-> (forall a. a -> ZIO r e a)
-> (forall a b. ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b)
-> (forall a b c.
    (a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c)
-> (forall a b. ZIO r e a -> ZIO r e b -> ZIO r e b)
-> (forall a b. ZIO r e a -> ZIO r e b -> ZIO r e a)
-> Applicative (ZIO r e)
ZIO r e a -> ZIO r e b -> ZIO r e b
ZIO r e a -> ZIO r e b -> ZIO r e a
ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b
(a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c
forall a. a -> ZIO r e a
forall r e. Functor (ZIO r e)
forall a b. ZIO r e a -> ZIO r e b -> ZIO r e a
forall a b. ZIO r e a -> ZIO r e b -> ZIO r e b
forall a b. ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b
forall r e a. a -> ZIO r e a
forall a b c. (a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c
forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e a
forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e b
forall r e a b. ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b
forall r e a b c.
(a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: ZIO r e a -> ZIO r e b -> ZIO r e a
$c<* :: forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e a
*> :: ZIO r e a -> ZIO r e b -> ZIO r e b
$c*> :: forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e b
liftA2 :: (a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c
$cliftA2 :: forall r e a b c.
(a -> b -> c) -> ZIO r e a -> ZIO r e b -> ZIO r e c
<*> :: ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b
$c<*> :: forall r e a b. ZIO r e (a -> b) -> ZIO r e a -> ZIO r e b
pure :: a -> ZIO r e a
$cpure :: forall r e a. a -> ZIO r e a
$cp1Applicative :: forall r e. Functor (ZIO r e)
Applicative, Applicative (ZIO r e)
a -> ZIO r e a
Applicative (ZIO r e)
-> (forall a b. ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b)
-> (forall a b. ZIO r e a -> ZIO r e b -> ZIO r e b)
-> (forall a. a -> ZIO r e a)
-> Monad (ZIO r e)
ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b
ZIO r e a -> ZIO r e b -> ZIO r e b
forall a. a -> ZIO r e a
forall r e. Applicative (ZIO r e)
forall a b. ZIO r e a -> ZIO r e b -> ZIO r e b
forall a b. ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b
forall r e a. a -> ZIO r e a
forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e b
forall r e a b. ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> ZIO r e a
$creturn :: forall r e a. a -> ZIO r e a
>> :: ZIO r e a -> ZIO r e b -> ZIO r e b
$c>> :: forall r e a b. ZIO r e a -> ZIO r e b -> ZIO r e b
>>= :: ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b
$c>>= :: forall r e a b. ZIO r e a -> (a -> ZIO r e b) -> ZIO r e b
$cp1Monad :: forall r e. Applicative (ZIO r e)
Monad, MonadError e, Monad (ZIO r e)
Monad (ZIO r e)
-> (forall a. (a -> ZIO r e a) -> ZIO r e a) -> MonadFix (ZIO r e)
(a -> ZIO r e a) -> ZIO r e a
forall a. (a -> ZIO r e a) -> ZIO r e a
forall r e. Monad (ZIO r e)
forall r e a. (a -> ZIO r e a) -> ZIO r e a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> ZIO r e a) -> ZIO r e a
$cmfix :: forall r e a. (a -> ZIO r e a) -> ZIO r e a
$cp1MonadFix :: forall r e. Monad (ZIO r e)
MonadFix, MonadReader r, Monad (ZIO r e)
Monad (ZIO r e)
-> (forall a. UIO a -> ZIO r e a) -> Unexceptional (ZIO r e)
UIO a -> ZIO r e a
forall a. UIO a -> ZIO r e a
forall r e. Monad (ZIO r e)
forall r e a. UIO a -> ZIO r e a
forall (m :: * -> *).
Monad m -> (forall a. UIO a -> m a) -> Unexceptional m
lift :: UIO a -> ZIO r e a
$clift :: forall r e a. UIO a -> ZIO r e a
$cp1Unexceptional :: forall r e. Monad (ZIO r e)
Unexceptional )

type UEIO a = EIO Void a

type URIO r a = ZIO r Void a

type UZIO a = ZIO Void Void a

type Task a = ZIO Void SomeNonPseudoException a

type RIO r a = ZIO r SomeNonPseudoException a

elift :: IO a -> EIO SomeNonPseudoException a
elift :: IO a -> EIO SomeNonPseudoException a
elift =  ExceptT SomeNonPseudoException UIO a
-> EIO SomeNonPseudoException a
forall e a. ExceptT e UIO a -> EIO e a
EIO (ExceptT SomeNonPseudoException UIO a
 -> EIO SomeNonPseudoException a)
-> (IO a -> ExceptT SomeNonPseudoException UIO a)
-> IO a
-> EIO SomeNonPseudoException a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> ExceptT SomeNonPseudoException UIO a
forall (m :: * -> *) a.
Unexceptional m =>
IO a -> ExceptT SomeNonPseudoException m a
fromIO

zlift :: IO a -> ZIO r SomeNonPseudoException a
zlift :: IO a -> ZIO r SomeNonPseudoException a
zlift = ReaderT r (EIO SomeNonPseudoException) a
-> ZIO r SomeNonPseudoException a
forall r e a. ReaderT r (EIO e) a -> ZIO r e a
ZIO (ReaderT r (EIO SomeNonPseudoException) a
 -> ZIO r SomeNonPseudoException a)
-> (IO a -> ReaderT r (EIO SomeNonPseudoException) a)
-> IO a
-> ZIO r SomeNonPseudoException a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EIO SomeNonPseudoException a
-> ReaderT r (EIO SomeNonPseudoException) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (EIO SomeNonPseudoException a
 -> ReaderT r (EIO SomeNonPseudoException) a)
-> (IO a -> EIO SomeNonPseudoException a)
-> IO a
-> ReaderT r (EIO SomeNonPseudoException) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> EIO SomeNonPseudoException a
forall a. IO a -> EIO SomeNonPseudoException a
elift

ezlift :: forall r e a. EIO e a -> ZIO r e a
ezlift :: EIO e a -> ZIO r e a
ezlift = ReaderT r (EIO e) a -> ZIO r e a
forall r e a. ReaderT r (EIO e) a -> ZIO r e a
ZIO (ReaderT r (EIO e) a -> ZIO r e a)
-> (EIO e a -> ReaderT r (EIO e) a) -> EIO e a -> ZIO r e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EIO e a -> ReaderT r (EIO e) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

uelift :: ∀ e a. UIO a -> EIO e a
uelift :: UIO a -> EIO e a
uelift = ExceptT e UIO a -> EIO e a
forall e a. ExceptT e UIO a -> EIO e a
EIO (ExceptT e UIO a -> EIO e a)
-> (UIO a -> ExceptT e UIO a) -> UIO a -> EIO e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UIO a -> ExceptT e UIO a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

uzlift :: ∀ r e a. UIO a -> ZIO r e a
uzlift :: UIO a -> ZIO r e a
uzlift = EIO e a -> ZIO r e a
forall r e a. EIO e a -> ZIO r e a
ezlift (EIO e a -> ZIO r e a) -> (UIO a -> EIO e a) -> UIO a -> ZIO r e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UIO a -> EIO e a
forall e a. UIO a -> EIO e a
uelift

euUnlift :: UEIO a -> UIO a
euUnlift :: UEIO a -> UIO a
euUnlift UEIO a
ueio = ((Void -> a) -> (a -> a) -> Either Void a -> a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Void -> a
forall a. Void -> a
absurd a -> a
forall a. a -> a
id) (Either Void a -> a) -> UIO (Either Void a) -> UIO a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((ExceptT Void UIO a -> UIO (Either Void a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT Void UIO a -> UIO (Either Void a))
-> (UEIO a -> ExceptT Void UIO a) -> UEIO a -> UIO (Either Void a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UEIO a -> ExceptT Void UIO a
forall e a. EIO e a -> ExceptT e UIO a
_unEIO) UEIO a
ueio)

zuUnlift :: UZIO a -> UIO a
zuUnlift :: UZIO a -> UIO a
zuUnlift = UEIO a -> UIO a
forall a. UEIO a -> UIO a
euUnlift (UEIO a -> UIO a) -> (UZIO a -> UEIO a) -> UZIO a -> UIO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT Void (EIO Void) a -> Void -> UEIO a)
-> Void -> ReaderT Void (EIO Void) a -> UEIO a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT Void (EIO Void) a -> Void -> UEIO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Void
forall a. HasCallStack => a
undefined (ReaderT Void (EIO Void) a -> UEIO a)
-> (UZIO a -> ReaderT Void (EIO Void) a) -> UZIO a -> UEIO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UZIO a -> ReaderT Void (EIO Void) a
forall r e a. ZIO r e a -> ReaderT r (EIO e) a
_unZIO

runEIO :: MonadIO m => EIO e a -> (e -> m a) -> m a
runEIO :: EIO e a -> (e -> m a) -> m a
runEIO EIO e a
eio e -> m a
handler = do
  Either e a
resEi :: Either e a <- (UIO (Either e a) -> m (Either e a)
forall (m :: * -> *) a. MonadIO m => UIO a -> m a
run (UIO (Either e a) -> m (Either e a))
-> (EIO e a -> UIO (Either e a)) -> EIO e a -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT e UIO a -> UIO (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT e UIO a -> UIO (Either e a))
-> (EIO e a -> ExceptT e UIO a) -> EIO e a -> UIO (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EIO e a -> ExceptT e UIO a
forall e a. EIO e a -> ExceptT e UIO a
_unEIO) EIO e a
eio
  (e -> m a) -> (a -> m a) -> Either e a -> m a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> m a
handler a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Either e a
resEi

withEIO :: (e -> e') -> EIO e a -> EIO e' a
withEIO :: (e -> e') -> EIO e a -> EIO e' a
withEIO e -> e'
h =  ExceptT e' UIO a -> EIO e' a
forall e a. ExceptT e UIO a -> EIO e a
EIO
           (ExceptT e' UIO a -> EIO e' a)
-> (EIO e a -> ExceptT e' UIO a) -> EIO e a -> EIO e' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> e') -> ExceptT e UIO a -> ExceptT e' UIO a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> e'
h
           (ExceptT e UIO a -> ExceptT e' UIO a)
-> (EIO e a -> ExceptT e UIO a) -> EIO e a -> ExceptT e' UIO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EIO e a -> ExceptT e UIO a
forall e a. EIO e a -> ExceptT e UIO a
_unEIO

mapEError :: (e -> e') -> EIO e a -> EIO e' a
mapEError :: (e -> e') -> EIO e a -> EIO e' a
mapEError = (e -> e') -> EIO e a -> EIO e' a
forall e e' a. (e -> e') -> EIO e a -> EIO e' a
withEIO

runZIO :: MonadIO m => ZIO r e a -> r -> (e -> m a) -> m a
runZIO :: ZIO r e a -> r -> (e -> m a) -> m a
runZIO ZIO r e a
app r
env e -> m a
handler = do
  let eio :: EIO e a
eio = ReaderT r (EIO e) a -> r -> EIO e a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ZIO r e a -> ReaderT r (EIO e) a
forall r e a. ZIO r e a -> ReaderT r (EIO e) a
_unZIO ZIO r e a
app) r
env
  EIO e a -> (e -> m a) -> m a
forall (m :: * -> *) e a. MonadIO m => EIO e a -> (e -> m a) -> m a
runEIO EIO e a
eio e -> m a
handler

withZIO :: r -> (e -> e') -> ZIO r e a -> ZIO r e' a
withZIO :: r -> (e -> e') -> ZIO r e a -> ZIO r e' a
withZIO r
r e -> e'
h =  EIO e' a -> ZIO r e' a
forall r e a. EIO e a -> ZIO r e a
ezlift
             (EIO e' a -> ZIO r e' a)
-> (ZIO r e a -> EIO e' a) -> ZIO r e a -> ZIO r e' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT e' UIO a -> EIO e' a
forall e a. ExceptT e UIO a -> EIO e a
EIO
             (ExceptT e' UIO a -> EIO e' a)
-> (ZIO r e a -> ExceptT e' UIO a) -> ZIO r e a -> EIO e' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> e') -> ExceptT e UIO a -> ExceptT e' UIO a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> e'
h
             (ExceptT e UIO a -> ExceptT e' UIO a)
-> (ZIO r e a -> ExceptT e UIO a) -> ZIO r e a -> ExceptT e' UIO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EIO e a -> ExceptT e UIO a
forall e a. EIO e a -> ExceptT e UIO a
_unEIO
             (EIO e a -> ExceptT e UIO a)
-> (ZIO r e a -> EIO e a) -> ZIO r e a -> ExceptT e UIO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReaderT r (EIO e) a -> r -> EIO e a)
-> r -> ReaderT r (EIO e) a -> EIO e a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ReaderT r (EIO e) a -> r -> EIO e a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT r
r
             (ReaderT r (EIO e) a -> EIO e a)
-> (ZIO r e a -> ReaderT r (EIO e) a) -> ZIO r e a -> EIO e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZIO r e a -> ReaderT r (EIO e) a
forall r e a. ZIO r e a -> ReaderT r (EIO e) a
_unZIO

mapZError :: (e -> e') -> ZIO r e a -> ZIO r e' a
mapZError :: (e -> e') -> ZIO r e a -> ZIO r e' a
mapZError e -> e'
h ZIO r e a
m = do
  r
r <- ZIO r e' r
forall r (m :: * -> *). MonadReader r m => m r
ask
  r -> (e -> e') -> ZIO r e a -> ZIO r e' a
forall r e e' a. r -> (e -> e') -> ZIO r e a -> ZIO r e' a
withZIO r
r e -> e'
h ZIO r e a
m