module Effectful.Zoo.Core.Error.Static
  ( Error,

    throw,

    catch,
    catch_,
    trap,
    trap_,

    catchWithCallStack,
    catchWithCallStack_,
    trapWithCallStack,
    trapWithCallStack_,

    catchIn,
    catchIn_,
    trapIn,
    trapIn_,

    catchWithCallStackIn,
    catchWithCallStackIn_,
    trapWithCallStackIn,
    trapWithCallStackIn_,
  ) where

import Effectful
import Effectful.Error.Static (Error)
import Effectful.Error.Static qualified as E
import Effectful.Zoo.Core
import HaskellWorks.Prelude

throw :: forall e r a. ()
  => HasCallStack
  => r <: Error e
  => Show e
  => e
  -> Eff r a
throw :: forall e (r :: [Effect]) a.
(HasCallStack, r <: Error e, Show e) =>
e -> Eff r a
throw =
  e -> Eff r a
forall e (r :: [Effect]) a.
(HasCallStack, r <: Error e, Show e) =>
e -> Eff r a
E.throwError

catchWithCallStack :: forall e r a. ()
  => HasCallStack
  => Eff (Error e : r) a
  -> (CallStack -> e -> Eff r a)
  -> Eff r a
catchWithCallStack :: forall e (r :: [Effect]) a.
HasCallStack =>
Eff (Error e : r) a -> (CallStack -> e -> Eff r a) -> Eff r a
catchWithCallStack Eff (Error e : r) a
action CallStack -> e -> Eff r a
handler =
  Eff (Error e : r) a -> Eff r (Either (CallStack, e) a)
forall e (es :: [Effect]) a.
HasCallStack =>
Eff (Error e : es) a -> Eff es (Either (CallStack, e) a)
E.runError Eff (Error e : r) a
action
    Eff r (Either (CallStack, e) a)
-> (Eff r (Either (CallStack, e) a) -> Eff r a) -> Eff r a
forall a b. a -> (a -> b) -> b
& ((CallStack, e) -> Eff r a)
-> Eff r (Either (CallStack, e) a) -> Eff r a
forall e a (m :: * -> *).
Monad m =>
(e -> m a) -> m (Either e a) -> m a
onLeftM ((CallStack -> e -> Eff r a) -> (CallStack, e) -> Eff r a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry CallStack -> e -> Eff r a
handler)

catchWithCallStack_ :: forall e r a. ()
  => HasCallStack
  => Eff (Error e : r) a
  -> (CallStack -> Eff r a)
  -> Eff r a
catchWithCallStack_ :: forall e (r :: [Effect]) a.
HasCallStack =>
Eff (Error e : r) a -> (CallStack -> Eff r a) -> Eff r a
catchWithCallStack_ Eff (Error e : r) a
f CallStack -> Eff r a
h =
  forall e (r :: [Effect]) a.
HasCallStack =>
Eff (Error e : r) a -> (CallStack -> e -> Eff r a) -> Eff r a
catchWithCallStack @e Eff (Error e : r) a
f \CallStack
cs e
_ -> CallStack -> Eff r a
h CallStack
cs

trapWithCallStack :: forall e r a. ()
  => HasCallStack
  => (CallStack -> e -> Eff r a)
  -> Eff (Error e : r) a
  -> Eff r a
trapWithCallStack :: forall e (r :: [Effect]) a.
HasCallStack =>
(CallStack -> e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
trapWithCallStack =
  (Eff (Error e : r) a -> (CallStack -> e -> Eff r a) -> Eff r a)
-> (CallStack -> e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Eff (Error e : r) a -> (CallStack -> e -> Eff r a) -> Eff r a
forall e (r :: [Effect]) a.
HasCallStack =>
Eff (Error e : r) a -> (CallStack -> e -> Eff r a) -> Eff r a
catchWithCallStack

trapWithCallStack_ :: forall e r a. ()
  => HasCallStack
  => (CallStack -> Eff r a)
  -> Eff (Error e : r) a
  -> Eff r a
trapWithCallStack_ :: forall e (r :: [Effect]) a.
HasCallStack =>
(CallStack -> Eff r a) -> Eff (Error e : r) a -> Eff r a
trapWithCallStack_ CallStack -> Eff r a
h =
  forall e (r :: [Effect]) a.
HasCallStack =>
(CallStack -> e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
trapWithCallStack @e (Eff r a -> e -> Eff r a
forall a b. a -> b -> a
const (Eff r a -> e -> Eff r a)
-> (CallStack -> Eff r a) -> CallStack -> e -> Eff r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CallStack -> Eff r a
h)

catch :: forall e r a. ()
  => Eff (Error e : r) a
  -> (e -> Eff r a)
  -> Eff r a
catch :: forall e (r :: [Effect]) a.
Eff (Error e : r) a -> (e -> Eff r a) -> Eff r a
catch Eff (Error e : r) a
action e -> Eff r a
handler =
  Eff (Error e : r) a -> Eff r (Either (CallStack, e) a)
forall e (es :: [Effect]) a.
HasCallStack =>
Eff (Error e : es) a -> Eff es (Either (CallStack, e) a)
E.runError Eff (Error e : r) a
action
    Eff r (Either (CallStack, e) a)
-> (Eff r (Either (CallStack, e) a) -> Eff r a) -> Eff r a
forall a b. a -> (a -> b) -> b
& ((CallStack, e) -> Eff r a)
-> Eff r (Either (CallStack, e) a) -> Eff r a
forall e a (m :: * -> *).
Monad m =>
(e -> m a) -> m (Either e a) -> m a
onLeftM (e -> Eff r a
handler (e -> Eff r a)
-> ((CallStack, e) -> e) -> (CallStack, e) -> Eff r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CallStack, e) -> e
forall a b. (a, b) -> b
snd)

catch_ :: forall e r a. ()
  => Eff (Error e : r) a
  -> Eff r a
  -> Eff r a
catch_ :: forall e (r :: [Effect]) a.
Eff (Error e : r) a -> Eff r a -> Eff r a
catch_ Eff (Error e : r) a
action Eff r a
handler =
  forall e (r :: [Effect]) a.
Eff (Error e : r) a -> (e -> Eff r a) -> Eff r a
catch @e Eff (Error e : r) a
action (Eff r a -> e -> Eff r a
forall a b. a -> b -> a
const Eff r a
handler)

trap :: forall e r a. ()
  => (e -> Eff r a)
  -> Eff (Error e : r) a
  -> Eff r a
trap :: forall e (r :: [Effect]) a.
(e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
trap =
  (Eff (Error e : r) a -> (e -> Eff r a) -> Eff r a)
-> (e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Eff (Error e : r) a -> (e -> Eff r a) -> Eff r a
forall e (r :: [Effect]) a.
Eff (Error e : r) a -> (e -> Eff r a) -> Eff r a
catch

trap_ :: forall e r a. ()
  => Eff r a
  -> Eff (Error e : r) a
  -> Eff r a
trap_ :: forall e (r :: [Effect]) a.
Eff r a -> Eff (Error e : r) a -> Eff r a
trap_ Eff r a
handler =
  forall e (r :: [Effect]) a.
(e -> Eff r a) -> Eff (Error e : r) a -> Eff r a
trap @e (Eff r a -> e -> Eff r a
forall a b. a -> b -> a
const Eff r a
handler)


catchWithCallStackIn :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => Eff es a
  -> (CallStack -> e -> Eff es a)
  -> Eff es a
catchWithCallStackIn :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
catchWithCallStackIn =
  Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
E.catchError

catchWithCallStackIn_ :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => Eff es a
  -> (CallStack -> Eff es a)
  -> Eff es a
catchWithCallStackIn_ :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> Eff es a) -> Eff es a
catchWithCallStackIn_ Eff es a
f CallStack -> Eff es a
h =
  forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
catchWithCallStackIn @e Eff es a
f \CallStack
cs e
_ -> CallStack -> Eff es a
h CallStack
cs

trapWithCallStackIn :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => (CallStack -> e -> Eff es a)
  -> Eff es a
  -> Eff es a
trapWithCallStackIn :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
(CallStack -> e -> Eff es a) -> Eff es a -> Eff es a
trapWithCallStackIn =
  (Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a)
-> (CallStack -> e -> Eff es a) -> Eff es a -> Eff es a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
catchWithCallStackIn

trapWithCallStackIn_ :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => (CallStack -> Eff es a)
  -> Eff es a
  -> Eff es a
trapWithCallStackIn_ :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
(CallStack -> Eff es a) -> Eff es a -> Eff es a
trapWithCallStackIn_ CallStack -> Eff es a
h =
  forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
(CallStack -> e -> Eff es a) -> Eff es a -> Eff es a
trapWithCallStackIn @e (Eff es a -> e -> Eff es a
forall a b. a -> b -> a
const (Eff es a -> e -> Eff es a)
-> (CallStack -> Eff es a) -> CallStack -> e -> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CallStack -> Eff es a
h)

catchIn :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => Eff es a
  -> (e -> Eff es a)
  -> Eff es a
catchIn :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (e -> Eff es a) -> Eff es a
catchIn Eff es a
action e -> Eff es a
handler =
  Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
catchWithCallStackIn Eff es a
action ((e -> Eff es a) -> CallStack -> e -> Eff es a
forall a b. a -> b -> a
const e -> Eff es a
handler)

catchIn_ :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => Eff es a
  -> Eff es a
  -> Eff es a
catchIn_ :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> Eff es a -> Eff es a
catchIn_ Eff es a
action Eff es a
handler =
  forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (e -> Eff es a) -> Eff es a
catchIn @e Eff es a
action (Eff es a -> e -> Eff es a
forall a b. a -> b -> a
const Eff es a
handler)

trapIn :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => (e -> Eff es a)
  -> Eff es a
  -> Eff es a
trapIn :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
(e -> Eff es a) -> Eff es a -> Eff es a
trapIn =
  (Eff es a -> (e -> Eff es a) -> Eff es a)
-> (e -> Eff es a) -> Eff es a -> Eff es a
forall a b c. (a -> b -> c) -> b -> a -> c
flip Eff es a -> (e -> Eff es a) -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> (e -> Eff es a) -> Eff es a
catchIn

trapIn_ :: forall e es a. ()
  => HasCallStack
  => es <: Error e
  => Eff es a
  -> Eff es a
  -> Eff es a
trapIn_ :: forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
Eff es a -> Eff es a -> Eff es a
trapIn_ Eff es a
handler =
  forall e (es :: [Effect]) a.
(HasCallStack, es <: Error e) =>
(e -> Eff es a) -> Eff es a -> Eff es a
trapIn @e (Eff es a -> e -> Eff es a
forall a b. a -> b -> a
const Eff es a
handler)