{-# options_haddock prune #-}

-- |Description: Interpreters for 'Stop'.
module Polysemy.Resume.Interpreter.Stop where

import qualified Control.Exception as Base
import Control.Exception (throwIO)
import Control.Monad.Trans.Except (ExceptT (ExceptT), runExceptT, throwE)
import Data.Typeable (typeRep)
import Polysemy.Final (getInitialStateS, interpretFinal, runS, withStrategicToFinal)
import Polysemy.Internal (Sem (Sem), usingSem)
import Polysemy.Internal.Union (Weaving (Weaving), decomp, hoist, weave)
import qualified Text.Show

import Polysemy.Resume.Effect.Stop (Stop (Stop), stop)

-- |Equivalent of 'runError'.
runStop ::
  Sem (Stop err : r) a ->
  Sem r (Either err a)
runStop :: forall err (r :: [(* -> *) -> * -> *]) a.
Sem (Stop err : r) a -> Sem r (Either err a)
runStop (Sem forall (m :: * -> *).
Monad m =>
(forall x. Union (Stop err : r) (Sem (Stop err : r)) x -> m x)
-> m a
m) =
  (forall (m :: * -> *).
 Monad m =>
 (forall x. Union r (Sem r) x -> m x) -> m (Either err a))
-> Sem r (Either err a)
forall (r :: [(* -> *) -> * -> *]) a.
(forall (m :: * -> *).
 Monad m =>
 (forall x. Union r (Sem r) x -> m x) -> m a)
-> Sem r a
Sem \ forall x. Union r (Sem r) x -> m x
k ->
    ExceptT err m a -> m (Either err a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT err m a -> m (Either err a))
-> ExceptT err m a -> m (Either err a)
forall a b. (a -> b) -> a -> b
$ (forall x.
 Union (Stop err : r) (Sem (Stop err : r)) x -> ExceptT err m x)
-> ExceptT err m a
forall (m :: * -> *).
Monad m =>
(forall x. Union (Stop err : r) (Sem (Stop err : r)) x -> m x)
-> m a
m \ Union (Stop err : r) (Sem (Stop err : r)) x
u ->
      case Union (Stop err : r) (Sem (Stop err : r)) x
-> Either
     (Union r (Sem (Stop err : r)) x)
     (Weaving (Stop err) (Sem (Stop err : r)) x)
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *])
       (m :: * -> *) a.
Union (e : r) m a -> Either (Union r m a) (Weaving e m a)
decomp Union (Stop err : r) (Sem (Stop err : r)) x
u of
        Left Union r (Sem (Stop err : r)) x
x ->
          m (Either err x) -> ExceptT err m x
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either err x) -> ExceptT err m x)
-> m (Either err x) -> ExceptT err m x
forall a b. (a -> b) -> a -> b
$ Union r (Sem r) (Either err x) -> m (Either err x)
forall x. Union r (Sem r) x -> m x
k (Union r (Sem r) (Either err x) -> m (Either err x))
-> Union r (Sem r) (Either err x) -> m (Either err x)
forall a b. (a -> b) -> a -> b
$ Either err ()
-> (forall x.
    Either err (Sem (Stop err : r) x) -> Sem r (Either err x))
-> (forall x. Either err x -> Maybe x)
-> Union r (Sem (Stop err : r)) x
-> Union r (Sem r) (Either err x)
forall (s :: * -> *) (n :: * -> *) (m :: * -> *)
       (r :: [(* -> *) -> * -> *]) a.
(Functor s, Functor n) =>
s ()
-> (forall x. s (m x) -> n (s x))
-> (forall x. s x -> Maybe x)
-> Union r m a
-> Union r n (s a)
weave (() -> Either err ()
forall a b. b -> Either a b
Right ()) ((err -> Sem r (Either err x))
-> (Sem (Stop err : r) x -> Sem r (Either err x))
-> Either err (Sem (Stop err : r) x)
-> Sem r (Either err x)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Either err x -> Sem r (Either err x)
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either err x -> Sem r (Either err x))
-> (err -> Either err x) -> err -> Sem r (Either err x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. err -> Either err x
forall a b. a -> Either a b
Left) Sem (Stop err : r) x -> Sem r (Either err x)
forall err (r :: [(* -> *) -> * -> *]) a.
Sem (Stop err : r) a -> Sem r (Either err a)
runStop) Either err x -> Maybe x
forall x. Either err x -> Maybe x
forall l r. Either l r -> Maybe r
rightToMaybe Union r (Sem (Stop err : r)) x
x
        Right (Weaving (Stop err
err) f ()
_ forall x. f (Sem rInitial x) -> Sem (Stop err : r) (f x)
_ f a -> x
_ forall x. f x -> Maybe x
_) ->
          err -> ExceptT err m x
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
throwE err
err
{-# inline runStop #-}

-- | Internal type used to tag exceptions thrown by 'Stop' interpreters.
newtype StopExc err =
  StopExc { forall err. StopExc err -> err
unStopExc :: err }
  deriving stock (Typeable)

instance {-# overlappable #-} Typeable err => Show (StopExc err) where
  show :: StopExc err -> String
show =
    String -> ShowS
forall a. Monoid a => a -> a -> a
mappend String
"StopExc: " ShowS -> (StopExc err -> String) -> StopExc err -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeRep -> String
forall b a. (Show a, IsString b) => a -> b
show (TypeRep -> String)
-> (StopExc err -> TypeRep) -> StopExc err -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StopExc err -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep

instance Show (StopExc Text) where
  show :: StopExc Text -> String
show (StopExc Text
err) =
    String
"StopExc " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Text -> String
forall b a. (Show a, IsString b) => a -> b
show Text
err

instance {-# overlappable #-} Typeable err => Exception (StopExc err)

instance Exception (StopExc Text)

-- |Run 'Stop' by throwing exceptions.
runStopAsExcFinal ::
  ∀ err r a .
  Exception (StopExc err) =>
  Member (Final IO) r =>
  Sem (Stop err : r) a ->
  Sem r a
runStopAsExcFinal :: forall err (r :: [(* -> *) -> * -> *]) a.
(Exception (StopExc err), Member (Final IO) r) =>
Sem (Stop err : r) a -> Sem r a
runStopAsExcFinal =
  (forall x (rInitial :: [(* -> *) -> * -> *]).
 Stop err (Sem rInitial) x -> Strategic IO (Sem rInitial) x)
-> Sem (Stop err : r) a -> Sem r a
forall (m :: * -> *) (e :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
Member (Final m) r =>
(forall x (rInitial :: [(* -> *) -> * -> *]).
 e (Sem rInitial) x -> Strategic m (Sem rInitial) x)
-> Sem (e : r) a -> Sem r a
interpretFinal \case
    Stop err
err ->
      IO (f x) -> Sem (WithStrategy IO f (Sem rInitial)) (IO (f x))
forall a. a -> Sem (WithStrategy IO f (Sem rInitial)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StopExc err -> IO (f x)
forall e a. Exception e => e -> IO a
throwIO (err -> StopExc err
forall err. err -> StopExc err
StopExc err
err))
{-# inline runStopAsExcFinal #-}

-- |Run 'Stop' by throwing and catching exceptions.
stopToIOFinal ::
  ∀ err r a .
  Exception (StopExc err) =>
  Member (Final IO) r =>
  Sem (Stop err : r) a ->
  Sem r (Either err a)
stopToIOFinal :: forall err (r :: [(* -> *) -> * -> *]) a.
(Exception (StopExc err), Member (Final IO) r) =>
Sem (Stop err : r) a -> Sem r (Either err a)
stopToIOFinal Sem (Stop err : r) a
sem =
  forall (m :: * -> *) (r :: [(* -> *) -> * -> *]) a.
Member (Final m) r =>
Strategic m (Sem r) a -> Sem r a
withStrategicToFinal @IO do
    IO (f a)
m' <- Sem r a -> Sem (WithStrategy IO f (Sem r)) (IO (f a))
forall (n :: * -> *) a (m :: * -> *) (f :: * -> *).
n a -> Sem (WithStrategy m f n) (m (f a))
runS (Sem (Stop err : r) a -> Sem r a
forall err (r :: [(* -> *) -> * -> *]) a.
(Exception (StopExc err), Member (Final IO) r) =>
Sem (Stop err : r) a -> Sem r a
runStopAsExcFinal Sem (Stop err : r) a
sem)
    f ()
s <- Sem (WithStrategy IO f (Sem r)) (f ())
forall (m :: * -> *) (f :: * -> *) (n :: * -> *).
Sem (WithStrategy m f n) (f ())
getInitialStateS
    pure $ (StopExc err -> f (Either err a))
-> (f a -> f (Either err a))
-> Either (StopExc err) (f a)
-> f (Either err a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ((Either err a -> f () -> f (Either err a)
forall a b. a -> f b -> f a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ f ()
s) (Either err a -> f (Either err a))
-> (StopExc err -> Either err a) -> StopExc err -> f (Either err a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. err -> Either err a
forall a b. a -> Either a b
Left (err -> Either err a)
-> (StopExc err -> err) -> StopExc err -> Either err a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. \ (StopExc err
e) -> err
e) ((a -> Either err a) -> f a -> f (Either err a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Either err a
forall a b. b -> Either a b
Right) (Either (StopExc err) (f a) -> f (Either err a))
-> IO (Either (StopExc err) (f a)) -> IO (f (Either err a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (f a) -> IO (Either (StopExc err) (f a))
forall e a. Exception e => IO a -> IO (Either e a)
Base.try IO (f a)
m'
{-# inline stopToIOFinal #-}

-- |Stop if the argument is 'Left', transforming the error with @f@.
stopEitherWith ::
  ∀ err err' r a .
  Member (Stop err') r =>
  (err -> err') ->
  Either err a ->
  Sem r a
stopEitherWith :: forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith err -> err'
f =
  (err -> Sem r a) -> (a -> Sem r a) -> Either err a -> Sem r a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (err' -> Sem r a
forall e (r :: [(* -> *) -> * -> *]) a.
Member (Stop e) r =>
e -> Sem r a
stop (err' -> Sem r a) -> (err -> err') -> err -> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. err -> err'
f) a -> Sem r a
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
{-# inline stopEitherWith #-}

-- |Stop if the argument is 'Left', using the supplied error.
stopEitherAs ::
  ∀ err err' r a .
  Member (Stop err') r =>
  err' ->
  Either err a ->
  Sem r a
stopEitherAs :: forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
err' -> Either err a -> Sem r a
stopEitherAs err'
err =
  (err -> err') -> Either err a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith (err' -> err -> err'
forall a b. a -> b -> a
const err'
err)
{-# inline stopEitherAs #-}

-- |Stop if the argument is 'Left'.
stopEither ::
  ∀ err r a .
  Member (Stop err) r =>
  Either err a ->
  Sem r a
stopEither :: forall err (r :: [(* -> *) -> * -> *]) a.
Member (Stop err) r =>
Either err a -> Sem r a
stopEither =
  (err -> err) -> Either err a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith err -> err
forall a. a -> a
id
{-# inline stopEither #-}

-- |Stop with the supplied error if the argument is 'Nothing'.
stopNote ::
  ∀ err r a .
  Member (Stop err) r =>
  err ->
  Maybe a ->
  Sem r a
stopNote :: forall err (r :: [(* -> *) -> * -> *]) a.
Member (Stop err) r =>
err -> Maybe a -> Sem r a
stopNote err
err =
  Sem r a -> (a -> Sem r a) -> Maybe a -> Sem r a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (err -> Sem r a
forall e (r :: [(* -> *) -> * -> *]) a.
Member (Stop e) r =>
e -> Sem r a
stop err
err) a -> Sem r a
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
{-# inline stopNote #-}

-- |Convert a program using regular 'Error's to one using 'Stop'.
stopOnError ::
  ∀ err r a .
  Member (Stop err) r =>
  Sem (Error err : r) a ->
  Sem r a
stopOnError :: forall err (r :: [(* -> *) -> * -> *]) a.
Member (Stop err) r =>
Sem (Error err : r) a -> Sem r a
stopOnError =
  Either err a -> Sem r a
forall err (r :: [(* -> *) -> * -> *]) a.
Member (Stop err) r =>
Either err a -> Sem r a
stopEither (Either err a -> Sem r a)
-> (Sem (Error err : r) a -> Sem r (Either err a))
-> Sem (Error err : r) a
-> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Sem (Error err : r) a -> Sem r (Either err a)
forall e (r :: [(* -> *) -> * -> *]) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError
{-# inline stopOnError #-}

-- |Convert a program using regular 'Error's to one using 'Stop'.
stopOnErrorWith ::
  ∀ err err' r a .
  Member (Stop err') r =>
  (err -> err') ->
  Sem (Error err : r) a ->
  Sem r a
stopOnErrorWith :: forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Sem (Error err : r) a -> Sem r a
stopOnErrorWith err -> err'
f =
  (err -> err') -> Either err a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith err -> err'
f (Either err a -> Sem r a)
-> (Sem (Error err : r) a -> Sem r (Either err a))
-> Sem (Error err : r) a
-> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Sem (Error err : r) a -> Sem r (Either err a)
forall e (r :: [(* -> *) -> * -> *]) a.
Sem (Error e : r) a -> Sem r (Either e a)
runError
{-# inline stopOnErrorWith #-}

-- |Convert a program using 'Stop' to one using 'Error', transforming the error with the supplied function.
stopToErrorWith ::
  ∀ err err' r a .
  Member (Error err') r =>
  (err -> err') ->
  Sem (Stop err : r) a ->
  Sem r a
stopToErrorWith :: forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Error err') r =>
(err -> err') -> Sem (Stop err : r) a -> Sem r a
stopToErrorWith err -> err'
f =
  (err -> Sem r a) -> (a -> Sem r a) -> Either err a -> Sem r a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (err' -> Sem r a
forall e (r :: [(* -> *) -> * -> *]) a.
Member (Error e) r =>
e -> Sem r a
throw (err' -> Sem r a) -> (err -> err') -> err -> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. err -> err'
f) a -> Sem r a
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either err a -> Sem r a)
-> (Sem (Stop err : r) a -> Sem r (Either err a))
-> Sem (Stop err : r) a
-> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Sem (Stop err : r) a -> Sem r (Either err a)
forall err (r :: [(* -> *) -> * -> *]) a.
Sem (Stop err : r) a -> Sem r (Either err a)
runStop
{-# inline stopToErrorWith #-}

-- |Convert a program using 'Stop' to one using 'Error'.
stopToError ::
  ∀ err r a .
  Member (Error err) r =>
  Sem (Stop err : r) a ->
  Sem r a
stopToError :: forall err (r :: [(* -> *) -> * -> *]) a.
Member (Error err) r =>
Sem (Stop err : r) a -> Sem r a
stopToError =
  (err -> err) -> Sem (Stop err : r) a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Error err') r =>
(err -> err') -> Sem (Stop err : r) a -> Sem r a
stopToErrorWith err -> err
forall a. a -> a
id
{-# inline stopToError #-}

-- |Convert a program using 'Stop' to one using 'Error'.
stopToErrorIO ::
  ∀ err r a .
  Exception (StopExc err) =>
  Members [Error err, Final IO] r =>
  Sem (Stop err : r) a ->
  Sem r a
stopToErrorIO :: forall err (r :: [(* -> *) -> * -> *]) a.
(Exception (StopExc err), Members '[Error err, Final IO] r) =>
Sem (Stop err : r) a -> Sem r a
stopToErrorIO =
  (err -> Sem r a) -> (a -> Sem r a) -> Either err a -> Sem r a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either err -> Sem r a
forall e (r :: [(* -> *) -> * -> *]) a.
Member (Error e) r =>
e -> Sem r a
throw a -> Sem r a
forall a. a -> Sem r a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either err a -> Sem r a)
-> (Sem (Stop err : r) a -> Sem r (Either err a))
-> Sem (Stop err : r) a
-> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Sem (Stop err : r) a -> Sem r (Either err a)
forall err (r :: [(* -> *) -> * -> *]) a.
(Exception (StopExc err), Member (Final IO) r) =>
Sem (Stop err : r) a -> Sem r (Either err a)
stopToIOFinal
{-# inline stopToErrorIO #-}

-- |Map over the error type in a 'Stop'.
mapStop ::
  ∀ err e' r a .
  Member (Stop e') r =>
  (err -> e') ->
  Sem (Stop err : r) a ->
  Sem r a
mapStop :: forall err e' (r :: [(* -> *) -> * -> *]) a.
Member (Stop e') r =>
(err -> e') -> Sem (Stop err : r) a -> Sem r a
mapStop err -> e'
f (Sem forall (m :: * -> *).
Monad m =>
(forall x. Union (Stop err : r) (Sem (Stop err : r)) x -> m x)
-> m a
m) =
  (forall (m :: * -> *).
 Monad m =>
 (forall x. Union r (Sem r) x -> m x) -> m a)
-> Sem r a
forall (r :: [(* -> *) -> * -> *]) a.
(forall (m :: * -> *).
 Monad m =>
 (forall x. Union r (Sem r) x -> m x) -> m a)
-> Sem r a
Sem \ forall x. Union r (Sem r) x -> m x
k -> (forall x. Union (Stop err : r) (Sem (Stop err : r)) x -> m x)
-> m a
forall (m :: * -> *).
Monad m =>
(forall x. Union (Stop err : r) (Sem (Stop err : r)) x -> m x)
-> m a
m \ Union (Stop err : r) (Sem (Stop err : r)) x
u ->
    case Union (Stop err : r) (Sem (Stop err : r)) x
-> Either
     (Union r (Sem (Stop err : r)) x)
     (Weaving (Stop err) (Sem (Stop err : r)) x)
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *])
       (m :: * -> *) a.
Union (e : r) m a -> Either (Union r m a) (Weaving e m a)
decomp Union (Stop err : r) (Sem (Stop err : r)) x
u of
      Left Union r (Sem (Stop err : r)) x
x ->
        Union r (Sem r) x -> m x
forall x. Union r (Sem r) x -> m x
k ((forall x. Sem (Stop err : r) x -> Sem r x)
-> Union r (Sem (Stop err : r)) x -> Union r (Sem r) x
forall (m :: * -> *) (n :: * -> *) (r :: [(* -> *) -> * -> *]) a.
(forall x. m x -> n x) -> Union r m a -> Union r n a
hoist ((err -> e') -> Sem (Stop err : r) x -> Sem r x
forall err e' (r :: [(* -> *) -> * -> *]) a.
Member (Stop e') r =>
(err -> e') -> Sem (Stop err : r) a -> Sem r a
mapStop err -> e'
f) Union r (Sem (Stop err : r)) x
x)
      Right (Weaving (Stop err
err) f ()
_ forall x. f (Sem rInitial x) -> Sem (Stop err : r) (f x)
_ f a -> x
_ forall x. f x -> Maybe x
_) ->
        (forall x. Union r (Sem r) x -> m x) -> Sem r x -> m x
forall (m :: * -> *) (r :: [(* -> *) -> * -> *]) a.
Monad m =>
(forall x. Union r (Sem r) x -> m x) -> Sem r a -> m a
usingSem Union r (Sem r) x -> m x
forall x. Union r (Sem r) x -> m x
k (Stop e' (Sem r) x -> Sem r x
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
Member e r =>
e (Sem r) a -> Sem r a
send (Stop e' (Sem r) x -> Sem r x) -> Stop e' (Sem r) x -> Sem r x
forall a b. (a -> b) -> a -> b
$ e' -> Stop e' (Sem r) x
forall e (a :: * -> *) b. e -> Stop e a b
Stop (err -> e'
f err
err))
{-# inline mapStop #-}

-- |Replace the error in a 'Stop' with another type.
replaceStop ::
  ∀ err e' r a .
  Member (Stop e') r =>
  e' ->
  Sem (Stop err : r) a ->
  Sem r a
replaceStop :: forall err e' (r :: [(* -> *) -> * -> *]) a.
Member (Stop e') r =>
e' -> Sem (Stop err : r) a -> Sem r a
replaceStop e'
e' =
  (err -> e') -> Sem (Stop err : r) a -> Sem r a
forall err e' (r :: [(* -> *) -> * -> *]) a.
Member (Stop e') r =>
(err -> e') -> Sem (Stop err : r) a -> Sem r a
mapStop (e' -> err -> e'
forall a b. a -> b -> a
const e'
e')
{-# inline replaceStop #-}

-- |Convert the error type in a 'Stop' to 'Text'.
showStop ::
  ∀ err r a .
  Show err =>
  Member (Stop Text) r =>
  Sem (Stop err : r) a ->
  Sem r a
showStop :: forall err (r :: [(* -> *) -> * -> *]) a.
(Show err, Member (Stop Text) r) =>
Sem (Stop err : r) a -> Sem r a
showStop =
  forall err e' (r :: [(* -> *) -> * -> *]) a.
Member (Stop e') r =>
(err -> e') -> Sem (Stop err : r) a -> Sem r a
mapStop @err @Text err -> Text
forall b a. (Show a, IsString b) => a -> b
show
{-# inline showStop #-}

-- |Convert an 'IO' exception to 'Stop' using the provided transformation.
stopTryIOE ::
  ∀ exc err r a .
  Exception exc =>
  Members [Stop err, Embed IO] r =>
  (exc -> err) ->
  IO a ->
  Sem r a
stopTryIOE :: forall exc err (r :: [(* -> *) -> * -> *]) a.
(Exception exc, Members '[Stop err, Embed IO] r) =>
(exc -> err) -> IO a -> Sem r a
stopTryIOE exc -> err
f =
  (exc -> err) -> Either exc a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith exc -> err
f (Either exc a -> Sem r a)
-> (IO a -> Sem r (Either exc a)) -> IO a -> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e (r :: [(* -> *) -> * -> *]) a.
(Exception e, Member (Embed IO) r) =>
IO a -> Sem r (Either e a)
tryIOE @exc
{-# inline stopTryIOE #-}

-- |Convert an 'IO' exception of type @err@ to 'Stop' using the provided transformation from 'Text'.
stopTryIO ::
  ∀ exc err r a .
  Exception exc =>
  Members [Stop err, Embed IO] r =>
  (Text -> err) ->
  IO a ->
  Sem r a
stopTryIO :: forall exc err (r :: [(* -> *) -> * -> *]) a.
(Exception exc, Members '[Stop err, Embed IO] r) =>
(Text -> err) -> IO a -> Sem r a
stopTryIO Text -> err
f =
  (Text -> err) -> Either Text a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith Text -> err
f (Either Text a -> Sem r a)
-> (IO a -> Sem r (Either Text a)) -> IO a -> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall e (r :: [(* -> *) -> * -> *]) a.
(Exception e, Member (Embed IO) r) =>
IO a -> Sem r (Either Text a)
tryIO @exc
{-# inline stopTryIO #-}

-- |Convert an 'IO' exception of type 'Control.Exception.IOError' to 'Stop' using the provided transformation from
-- 'Text'.
stopTryIOError ::
  ∀ err r a .
  Members [Stop err, Embed IO] r =>
  (Text -> err) ->
  IO a ->
  Sem r a
stopTryIOError :: forall err (r :: [(* -> *) -> * -> *]) a.
Members '[Stop err, Embed IO] r =>
(Text -> err) -> IO a -> Sem r a
stopTryIOError Text -> err
f =
  (Text -> err) -> Either Text a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith Text -> err
f (Either Text a -> Sem r a)
-> (IO a -> Sem r (Either Text a)) -> IO a -> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< IO a -> Sem r (Either Text a)
forall (r :: [(* -> *) -> * -> *]) a.
Member (Embed IO) r =>
IO a -> Sem r (Either Text a)
tryIOError
{-# inline stopTryIOError #-}

-- |Convert an 'IO' exception to 'Stop' using the provided transformation from 'Text'.
stopTryAny ::
  ∀ err r a .
  Members [Stop err, Embed IO] r =>
  (Text -> err) ->
  IO a ->
  Sem r a
stopTryAny :: forall err (r :: [(* -> *) -> * -> *]) a.
Members '[Stop err, Embed IO] r =>
(Text -> err) -> IO a -> Sem r a
stopTryAny Text -> err
f =
  (Text -> err) -> Either Text a -> Sem r a
forall err err' (r :: [(* -> *) -> * -> *]) a.
Member (Stop err') r =>
(err -> err') -> Either err a -> Sem r a
stopEitherWith Text -> err
f (Either Text a -> Sem r a)
-> (IO a -> Sem r (Either Text a)) -> IO a -> Sem r a
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< IO a -> Sem r (Either Text a)
forall (r :: [(* -> *) -> * -> *]) a.
Member (Embed IO) r =>
IO a -> Sem r (Either Text a)
tryAny
{-# inline stopTryAny #-}