{-# LANGUAGE AllowAmbiguousTypes, DerivingVia #-}
{-# OPTIONS_HADDOCK not-home #-}
module Control.Effect.Carrier.Internal.Interpret where

import Data.Coerce

import Control.Applicative
import Control.Monad
import Control.Monad.Trans
import Control.Monad.Trans.Reader
import Control.Monad.Fix

import Control.Monad.Trans.Identity

import Control.Effect.Internal
import Control.Effect.Internal.Derive
import Control.Effect.Internal.Itself
import Control.Effect.Internal.KnownList
import Control.Effect.Internal.Union
import Control.Effect.Internal.Effly
import Control.Effect.Internal.Reflection
import Control.Effect.Internal.Utils
import Control.Monad.Base
import Control.Effect.Carrier.Internal.Intro

data HandlerCState p m z
  = HandlerCState (forall x. m x -> z x) (Algebra p z)

newtype ReifiedReformulation r p m = ReifiedReformulation {
    ReifiedReformulation r p m
-> forall (z :: * -> *).
   Monad z =>
   (forall x. m x -> z x) -> Algebra p z -> Algebra r z
getReifiedReformulation :: Reformulation r p m
  }

newtype
    HandlerC
      (sHandler :: *)
      (sReform :: *)
      (r :: [Effect])
      (p :: [Effect])
      (m :: * -> *) z (a :: *)
  = HandlerC { HandlerC sHandler sReform r p m z a -> z a
unHandlerC :: z a }
  deriving (a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
(a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
(forall a b.
 (a -> b)
 -> HandlerC sHandler sReform r p m z a
 -> HandlerC sHandler sReform r p m z b)
-> (forall a b.
    a
    -> HandlerC sHandler sReform r p m z b
    -> HandlerC sHandler sReform r p m z a)
-> Functor (HandlerC sHandler sReform r p m z)
forall a b.
a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
forall a b.
(a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Functor z =>
a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Functor z =>
(a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
$c<$ :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Functor z =>
a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
fmap :: (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
$cfmap :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Functor z =>
(a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
Functor, Functor (HandlerC sHandler sReform r p m z)
a -> HandlerC sHandler sReform r p m z a
Functor (HandlerC sHandler sReform r p m z)
-> (forall a. a -> HandlerC sHandler sReform r p m z a)
-> (forall a b.
    HandlerC sHandler sReform r p m z (a -> b)
    -> HandlerC sHandler sReform r p m z a
    -> HandlerC sHandler sReform r p m z b)
-> (forall a b c.
    (a -> b -> c)
    -> HandlerC sHandler sReform r p m z a
    -> HandlerC sHandler sReform r p m z b
    -> HandlerC sHandler sReform r p m z c)
-> (forall a b.
    HandlerC sHandler sReform r p m z a
    -> HandlerC sHandler sReform r p m z b
    -> HandlerC sHandler sReform r p m z b)
-> (forall a b.
    HandlerC sHandler sReform r p m z a
    -> HandlerC sHandler sReform r p m z b
    -> HandlerC sHandler sReform r p m z a)
-> Applicative (HandlerC sHandler sReform r p m z)
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
HandlerC sHandler sReform r p m z (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
(a -> b -> c)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z c
forall a. a -> HandlerC sHandler sReform r p m z a
forall a b.
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
forall a b.
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
forall a b.
HandlerC sHandler sReform r p m z (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *).
Applicative z =>
Functor (HandlerC sHandler sReform r p m z)
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
Applicative z =>
a -> HandlerC sHandler sReform r p m z a
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b c.
Applicative z =>
(a -> b -> c)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z c
forall a b c.
(a -> b -> c)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z 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
<* :: HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
$c<* :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z a
*> :: HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
$c*> :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
liftA2 :: (a -> b -> c)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z c
$cliftA2 :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b c.
Applicative z =>
(a -> b -> c)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z c
<*> :: HandlerC sHandler sReform r p m z (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
$c<*> :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Applicative z =>
HandlerC sHandler sReform r p m z (a -> b)
-> HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
pure :: a -> HandlerC sHandler sReform r p m z a
$cpure :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
Applicative z =>
a -> HandlerC sHandler sReform r p m z a
$cp1Applicative :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *).
Applicative z =>
Functor (HandlerC sHandler sReform r p m z)
Applicative, Applicative (HandlerC sHandler sReform r p m z)
a -> HandlerC sHandler sReform r p m z a
Applicative (HandlerC sHandler sReform r p m z)
-> (forall a b.
    HandlerC sHandler sReform r p m z a
    -> (a -> HandlerC sHandler sReform r p m z b)
    -> HandlerC sHandler sReform r p m z b)
-> (forall a b.
    HandlerC sHandler sReform r p m z a
    -> HandlerC sHandler sReform r p m z b
    -> HandlerC sHandler sReform r p m z b)
-> (forall a. a -> HandlerC sHandler sReform r p m z a)
-> Monad (HandlerC sHandler sReform r p m z)
HandlerC sHandler sReform r p m z a
-> (a -> HandlerC sHandler sReform r p m z b)
-> HandlerC sHandler sReform r p m z b
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
forall a. a -> HandlerC sHandler sReform r p m z a
forall a b.
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
forall a b.
HandlerC sHandler sReform r p m z a
-> (a -> HandlerC sHandler sReform r p m z b)
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *).
Monad z =>
Applicative (HandlerC sHandler sReform r p m z)
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
Monad z =>
a -> HandlerC sHandler sReform r p m z a
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Monad z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Monad z =>
HandlerC sHandler sReform r p m z a
-> (a -> HandlerC sHandler sReform r p m z b)
-> HandlerC sHandler sReform r p m z 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 -> HandlerC sHandler sReform r p m z a
$creturn :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
Monad z =>
a -> HandlerC sHandler sReform r p m z a
>> :: HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
$c>> :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Monad z =>
HandlerC sHandler sReform r p m z a
-> HandlerC sHandler sReform r p m z b
-> HandlerC sHandler sReform r p m z b
>>= :: HandlerC sHandler sReform r p m z a
-> (a -> HandlerC sHandler sReform r p m z b)
-> HandlerC sHandler sReform r p m z b
$c>>= :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a b.
Monad z =>
HandlerC sHandler sReform r p m z a
-> (a -> HandlerC sHandler sReform r p m z b)
-> HandlerC sHandler sReform r p m z b
$cp1Monad :: forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *).
Monad z =>
Applicative (HandlerC sHandler sReform r p m z)
Monad) via z

data CarrierReform m

instance (Carrier m, r ~ Derivs m, p ~ Prims m)
      => Reifies (CarrierReform m)
                 (ReifiedReformulation r p m) where
  reflect :: ReifiedReformulation r p m
reflect = Reformulation r p m -> ReifiedReformulation r p m
forall (r :: [Effect]) (p :: [Effect]) (m :: * -> *).
Reformulation r p m -> ReifiedReformulation r p m
ReifiedReformulation Reformulation r p m
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate
  {-# INLINE reflect #-}


instance ( Reifies sHandler (HandlerCState p m z)
         , Reifies sReform (ReifiedReformulation r p m)
         , Monad z
         )
      => Carrier (HandlerC sHandler sReform r p m z) where
  type Derivs (HandlerC sHandler sReform r p m z) = r
  type Prims  (HandlerC sHandler sReform r p m z) = p

  algPrims :: Algebra'
  (Prims (HandlerC sHandler sReform r p m z))
  (HandlerC sHandler sReform r p m z)
  a
algPrims =
    let
      HandlerCState forall x. m x -> z x
_ Algebra p z
alg = forall a. Reifies sHandler a => a
forall k (s :: k) a. Reifies s a => a
reflect @sHandler
    in
      z a -> HandlerC sHandler sReform r p m z a
coerce (z a -> HandlerC sHandler sReform r p m z a)
-> (Union p z a -> z a)
-> Union p z a
-> HandlerC sHandler sReform r p m z a
forall c b a. Coercible c b => (b -> c) -> (a -> b) -> a -> c
#. Union p z a -> z a
Algebra p z
alg (Union p z a -> HandlerC sHandler sReform r p m z a)
-> (Union p (HandlerC sHandler sReform r p m z) a -> Union p z a)
-> Union p (HandlerC sHandler sReform r p m z) a
-> HandlerC sHandler sReform r p m z a
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# Union p (HandlerC sHandler sReform r p m z) a -> Union p z a
coerce
  {-# INLINE algPrims #-}

  reformulate :: Reformulation'
  (Derivs (HandlerC sHandler sReform r p m z))
  (Prims (HandlerC sHandler sReform r p m z))
  (HandlerC sHandler sReform r p m z)
  z
  a
reformulate forall x. HandlerC sHandler sReform r p m z x -> z x
n' Algebra (Prims (HandlerC sHandler sReform r p m z)) z
alg =
    let
      HandlerCState forall x. m x -> z x
n Algebra p z
_ = forall a. Reifies sHandler a => a
forall k (s :: k) a. Reifies s a => a
reflect @sHandler
    in
      ReifiedReformulation r p m
-> (forall x. m x -> z x) -> Algebra p z -> Algebra r z
forall (r :: [Effect]) (p :: [Effect]) (m :: * -> *).
ReifiedReformulation r p m -> Reformulation r p m
getReifiedReformulation (forall a. Reifies sReform a => a
forall k (s :: k) a. Reifies s a => a
reflect @sReform) (HandlerC sHandler sReform r p m z x -> z x
forall x. HandlerC sHandler sReform r p m z x -> z x
n' (HandlerC sHandler sReform r p m z x -> z x)
-> (m x -> HandlerC sHandler sReform r p m z x) -> m x -> z x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z x -> HandlerC sHandler sReform r p m z x
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
z a -> HandlerC sHandler sReform r p m z a
HandlerC (z x -> HandlerC sHandler sReform r p m z x)
-> (m x -> z x) -> m x -> HandlerC sHandler sReform r p m z x
forall c b a. Coercible c b => (b -> c) -> (a -> b) -> a -> c
#. m x -> z x
forall x. m x -> z x
n) Algebra p z
Algebra (Prims (HandlerC sHandler sReform r p m z)) z
alg
  {-# INLINE reformulate #-}

  algDerivs :: Algebra'
  (Derivs (HandlerC sHandler sReform r p m z))
  (HandlerC sHandler sReform r p m z)
  a
algDerivs =
    let
      HandlerCState forall x. m x -> z x
n Algebra p z
alg = forall a. Reifies sHandler a => a
forall k (s :: k) a. Reifies s a => a
reflect @sHandler
    in
      ReifiedReformulation r p m
-> (forall x. m x -> HandlerC sHandler sReform r p m z x)
-> Algebra p (HandlerC sHandler sReform r p m z)
-> Algebra r (HandlerC sHandler sReform r p m z)
forall (r :: [Effect]) (p :: [Effect]) (m :: * -> *).
ReifiedReformulation r p m -> Reformulation r p m
getReifiedReformulation
        (forall a. Reifies sReform a => a
forall k (s :: k) a. Reifies s a => a
reflect @sReform)
        (z x -> HandlerC sHandler sReform r p m z x
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
z a -> HandlerC sHandler sReform r p m z a
HandlerC (z x -> HandlerC sHandler sReform r p m z x)
-> (m x -> z x) -> m x -> HandlerC sHandler sReform r p m z x
forall c b a. Coercible c b => (b -> c) -> (a -> b) -> a -> c
#. m x -> z x
forall x. m x -> z x
n)
        (z x -> HandlerC sHandler sReform r p m z x
coerce (z x -> HandlerC sHandler sReform r p m z x)
-> (Union p z x -> z x)
-> Union p z x
-> HandlerC sHandler sReform r p m z x
forall c b a. Coercible c b => (b -> c) -> (a -> b) -> a -> c
#. Union p z x -> z x
Algebra p z
alg (Union p z x -> HandlerC sHandler sReform r p m z x)
-> (Union p (HandlerC sHandler sReform r p m z) x -> Union p z x)
-> Union p (HandlerC sHandler sReform r p m z) x
-> HandlerC sHandler sReform r p m z x
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# Union p (HandlerC sHandler sReform r p m z) x -> Union p z x
coerce)
  {-# INLINE algDerivs #-}


instance ( Reifies sHandler (HandlerCState p m z)
         , Monad z
         , Monad m
         )
      => MonadBase m (HandlerC sHandler sReform r p m z) where
  liftBase :: m α -> HandlerC sHandler sReform r p m z α
liftBase m α
m =
    let
      HandlerCState forall x. m x -> z x
n Algebra p z
_ = forall a. Reifies sHandler a => a
forall k (s :: k) a. Reifies s a => a
reflect @sHandler
    in
      z α -> HandlerC sHandler sReform r p m z α
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
z a -> HandlerC sHandler sReform r p m z a
HandlerC (m α -> z α
forall x. m x -> z x
n m α
m)
  {-# INLINE liftBase #-}

newtype InterpretPrimC (s :: *) (e :: Effect) (m :: * -> *) a =
  InterpretPrimC {
      InterpretPrimC s e m a -> m a
unInterpretPrimC :: m a
    }
  deriving ( a -> InterpretPrimC s e m b -> InterpretPrimC s e m a
(a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b
(forall a b.
 (a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b)
-> (forall a b.
    a -> InterpretPrimC s e m b -> InterpretPrimC s e m a)
-> Functor (InterpretPrimC s e m)
forall a b. a -> InterpretPrimC s e m b -> InterpretPrimC s e m a
forall a b.
(a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretPrimC s e m b -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> InterpretPrimC s e m b -> InterpretPrimC s e m a
$c<$ :: forall s (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretPrimC s e m b -> InterpretPrimC s e m a
fmap :: (a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b
$cfmap :: forall s (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretPrimC s e m a -> InterpretPrimC s e m b
Functor, Functor (InterpretPrimC s e m)
a -> InterpretPrimC s e m a
Functor (InterpretPrimC s e m)
-> (forall a. a -> InterpretPrimC s e m a)
-> (forall a b.
    InterpretPrimC s e m (a -> b)
    -> InterpretPrimC s e m a -> InterpretPrimC s e m b)
-> (forall a b c.
    (a -> b -> c)
    -> InterpretPrimC s e m a
    -> InterpretPrimC s e m b
    -> InterpretPrimC s e m c)
-> (forall a b.
    InterpretPrimC s e m a
    -> InterpretPrimC s e m b -> InterpretPrimC s e m b)
-> (forall a b.
    InterpretPrimC s e m a
    -> InterpretPrimC s e m b -> InterpretPrimC s e m a)
-> Applicative (InterpretPrimC s e m)
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m a
InterpretPrimC s e m (a -> b)
-> InterpretPrimC s e m a -> InterpretPrimC s e m b
(a -> b -> c)
-> InterpretPrimC s e m a
-> InterpretPrimC s e m b
-> InterpretPrimC s e m c
forall a. a -> InterpretPrimC s e m a
forall a b.
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m a
forall a b.
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
forall a b.
InterpretPrimC s e m (a -> b)
-> InterpretPrimC s e m a -> InterpretPrimC s e m b
forall a b c.
(a -> b -> c)
-> InterpretPrimC s e m a
-> InterpretPrimC s e m b
-> InterpretPrimC s e m c
forall s (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m (a -> b)
-> InterpretPrimC s e m a -> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretPrimC s e m a
-> InterpretPrimC s e m b
-> InterpretPrimC s e m 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
<* :: InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m a
$c<* :: forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m a
*> :: InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
$c*> :: forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
liftA2 :: (a -> b -> c)
-> InterpretPrimC s e m a
-> InterpretPrimC s e m b
-> InterpretPrimC s e m c
$cliftA2 :: forall s (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretPrimC s e m a
-> InterpretPrimC s e m b
-> InterpretPrimC s e m c
<*> :: InterpretPrimC s e m (a -> b)
-> InterpretPrimC s e m a -> InterpretPrimC s e m b
$c<*> :: forall s (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimC s e m (a -> b)
-> InterpretPrimC s e m a -> InterpretPrimC s e m b
pure :: a -> InterpretPrimC s e m a
$cpure :: forall s (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretPrimC s e m a
$cp1Applicative :: forall s (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretPrimC s e m)
Applicative, Applicative (InterpretPrimC s e m)
a -> InterpretPrimC s e m a
Applicative (InterpretPrimC s e m)
-> (forall a b.
    InterpretPrimC s e m a
    -> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m b)
-> (forall a b.
    InterpretPrimC s e m a
    -> InterpretPrimC s e m b -> InterpretPrimC s e m b)
-> (forall a. a -> InterpretPrimC s e m a)
-> Monad (InterpretPrimC s e m)
InterpretPrimC s e m a
-> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m b
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
forall a. a -> InterpretPrimC s e m a
forall a b.
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
forall a b.
InterpretPrimC s e m a
-> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimC s e m a
-> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m 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 -> InterpretPrimC s e m a
$creturn :: forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretPrimC s e m a
>> :: InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
$c>> :: forall s (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m b -> InterpretPrimC s e m b
>>= :: InterpretPrimC s e m a
-> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m b
$c>>= :: forall s (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimC s e m a
-> (a -> InterpretPrimC s e m b) -> InterpretPrimC s e m b
$cp1Monad :: forall s (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretPrimC s e m)
Monad
           , Applicative (InterpretPrimC s e m)
InterpretPrimC s e m a
Applicative (InterpretPrimC s e m)
-> (forall a. InterpretPrimC s e m a)
-> (forall a.
    InterpretPrimC s e m a
    -> InterpretPrimC s e m a -> InterpretPrimC s e m a)
-> (forall a. InterpretPrimC s e m a -> InterpretPrimC s e m [a])
-> (forall a. InterpretPrimC s e m a -> InterpretPrimC s e m [a])
-> Alternative (InterpretPrimC s e m)
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
InterpretPrimC s e m a -> InterpretPrimC s e m [a]
InterpretPrimC s e m a -> InterpretPrimC s e m [a]
forall a. InterpretPrimC s e m a
forall a. InterpretPrimC s e m a -> InterpretPrimC s e m [a]
forall a.
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a -> InterpretPrimC s e m [a]
forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: InterpretPrimC s e m a -> InterpretPrimC s e m [a]
$cmany :: forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a -> InterpretPrimC s e m [a]
some :: InterpretPrimC s e m a -> InterpretPrimC s e m [a]
$csome :: forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a -> InterpretPrimC s e m [a]
<|> :: InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
$c<|> :: forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
empty :: InterpretPrimC s e m a
$cempty :: forall s (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimC s e m a
$cp1Alternative :: forall s (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretPrimC s e m)
Alternative, Monad (InterpretPrimC s e m)
Alternative (InterpretPrimC s e m)
InterpretPrimC s e m a
Alternative (InterpretPrimC s e m)
-> Monad (InterpretPrimC s e m)
-> (forall a. InterpretPrimC s e m a)
-> (forall a.
    InterpretPrimC s e m a
    -> InterpretPrimC s e m a -> InterpretPrimC s e m a)
-> MonadPlus (InterpretPrimC s e m)
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
forall a. InterpretPrimC s e m a
forall a.
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
$cmplus :: forall s (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimC s e m a
-> InterpretPrimC s e m a -> InterpretPrimC s e m a
mzero :: InterpretPrimC s e m a
$cmzero :: forall s (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimC s e m a
$cp2MonadPlus :: forall s (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretPrimC s e m)
$cp1MonadPlus :: forall s (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretPrimC s e m)
MonadPlus
           , Monad (InterpretPrimC s e m)
Monad (InterpretPrimC s e m)
-> (forall a.
    (a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a)
-> MonadFix (InterpretPrimC s e m)
(a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall a. (a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
$cmfix :: forall s (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
$cp1MonadFix :: forall s (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretPrimC s e m)
MonadFix, Monad (InterpretPrimC s e m)
Monad (InterpretPrimC s e m)
-> (forall a. String -> InterpretPrimC s e m a)
-> MonadFail (InterpretPrimC s e m)
String -> InterpretPrimC s e m a
forall a. String -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretPrimC s e m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: String -> InterpretPrimC s e m a
$cfail :: forall s (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretPrimC s e m a
$cp1MonadFail :: forall s (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretPrimC s e m)
MonadFail, Monad (InterpretPrimC s e m)
Monad (InterpretPrimC s e m)
-> (forall a. IO a -> InterpretPrimC s e m a)
-> MonadIO (InterpretPrimC s e m)
IO a -> InterpretPrimC s e m a
forall a. IO a -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretPrimC s e m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> InterpretPrimC s e m a
$cliftIO :: forall s (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretPrimC s e m a
$cp1MonadIO :: forall s (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretPrimC s e m)
MonadIO
           , Monad (InterpretPrimC s e m)
e -> InterpretPrimC s e m a
Monad (InterpretPrimC s e m)
-> (forall e a. Exception e => e -> InterpretPrimC s e m a)
-> MonadThrow (InterpretPrimC s e m)
forall e a. Exception e => e -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretPrimC s e m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> InterpretPrimC s e m a
$cthrowM :: forall s (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretPrimC s e m a
$cp1MonadThrow :: forall s (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretPrimC s e m)
MonadThrow, MonadThrow (InterpretPrimC s e m)
MonadThrow (InterpretPrimC s e m)
-> (forall e a.
    Exception e =>
    InterpretPrimC s e m a
    -> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a)
-> MonadCatch (InterpretPrimC s e m)
InterpretPrimC s e m a
-> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall e a.
Exception e =>
InterpretPrimC s e m a
-> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretPrimC s e m a
-> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: InterpretPrimC s e m a
-> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
$ccatch :: forall s (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretPrimC s e m a
-> (e -> InterpretPrimC s e m a) -> InterpretPrimC s e m a
$cp1MonadCatch :: forall s (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretPrimC s e m)
MonadCatch, MonadCatch (InterpretPrimC s e m)
MonadCatch (InterpretPrimC s e m)
-> (forall b.
    ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
     -> InterpretPrimC s e m b)
    -> InterpretPrimC s e m b)
-> (forall b.
    ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
     -> InterpretPrimC s e m b)
    -> InterpretPrimC s e m b)
-> (forall a b c.
    InterpretPrimC s e m a
    -> (a -> ExitCase b -> InterpretPrimC s e m c)
    -> (a -> InterpretPrimC s e m b)
    -> InterpretPrimC s e m (b, c))
-> MonadMask (InterpretPrimC s e m)
InterpretPrimC s e m a
-> (a -> ExitCase b -> InterpretPrimC s e m c)
-> (a -> InterpretPrimC s e m b)
-> InterpretPrimC s e m (b, c)
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
forall b.
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
forall a b c.
InterpretPrimC s e m a
-> (a -> ExitCase b -> InterpretPrimC s e m c)
-> (a -> InterpretPrimC s e m b)
-> InterpretPrimC s e m (b, c)
forall s (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretPrimC s e m)
forall s (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
forall s (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretPrimC s e m a
-> (a -> ExitCase b -> InterpretPrimC s e m c)
-> (a -> InterpretPrimC s e m b)
-> InterpretPrimC s e m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: InterpretPrimC s e m a
-> (a -> ExitCase b -> InterpretPrimC s e m c)
-> (a -> InterpretPrimC s e m b)
-> InterpretPrimC s e m (b, c)
$cgeneralBracket :: forall s (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretPrimC s e m a
-> (a -> ExitCase b -> InterpretPrimC s e m c)
-> (a -> InterpretPrimC s e m b)
-> InterpretPrimC s e m (b, c)
uninterruptibleMask :: ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
$cuninterruptibleMask :: forall s (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
mask :: ((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
$cmask :: forall s (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretPrimC s e m a -> InterpretPrimC s e m a)
 -> InterpretPrimC s e m b)
-> InterpretPrimC s e m b
$cp1MonadMask :: forall s (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretPrimC s e m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
  deriving (m a -> InterpretPrimC s e m a
(forall (m :: * -> *) a. Monad m => m a -> InterpretPrimC s e m a)
-> MonadTrans (InterpretPrimC s e)
forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> InterpretPrimC s e m a
forall (m :: * -> *) a. Monad m => m a -> InterpretPrimC s e m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> InterpretPrimC s e m a
$clift :: forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> InterpretPrimC s e m a
MonadTrans, MonadTrans (InterpretPrimC s e)
m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a
MonadTrans (InterpretPrimC s e)
-> (forall (m :: * -> *) a.
    Monad m =>
    (Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a)
-> MonadTransControl (InterpretPrimC s e)
(Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a
forall s (e :: Effect). MonadTrans (InterpretPrimC s e)
forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a
forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
(Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a
forall (m :: * -> *) a.
Monad m =>
m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a
forall (m :: * -> *) a.
Monad m =>
(Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a
forall (t :: Effect).
MonadTrans t
-> (forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a
$crestoreT :: forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
m (StT (InterpretPrimC s e) a) -> InterpretPrimC s e m a
liftWith :: (Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a
$cliftWith :: forall s (e :: Effect) (m :: * -> *) a.
Monad m =>
(Run (InterpretPrimC s e) -> m a) -> InterpretPrimC s e m a
$cp1MonadTransControl :: forall s (e :: Effect). MonadTrans (InterpretPrimC s e)
MonadTransControl) via IdentityT

-- | The class of effect handlers for derived effects.
-- Instances of this class can be used together 'interpretViaHandler'
-- in order to interpret effects.
--
-- @h@ is the tag for the handler, @e@ is the effect to interpret,
-- and @m@ is the 'Carrier' on which the handler operates.
--
-- To define your own interpreter using this method, create a new
-- datatype without any constructors to serve as the tag
-- for the handler, and then define a 'Handler' instance for it.
-- Then, you can use your handler to interpret effects with
-- 'interpretViaHandler'.
--
-- Alternatively, you can use 'interpret' or 'interpretSimple',
-- which lets you avoid the need to define instances of 'Handler',
-- but come at other costs.
class ( RepresentationalEff e
      , Carrier m
      )
   => Handler (h :: *) e m where
  effHandler :: EffHandler e m


-- | The type of effect handlers for a derived effect @e@ with current
-- carrier @m@.
--
-- Don't let the type overwhelm you; in most cases, you can treat this as
-- @e m x -> m x@.
--
-- Any 'EffHandler' is required to work with /any/ carrier monad @z@ that
-- lifts @m@, and has the same derived and primitive effects as @m@ does.
-- The only constraints that are propagated to @z@ are membership
-- constraints:
-- @MonadIO m@ doesn't imply @MonadIO z@, but @Eff (Embed IO) m@ /does/
-- imply @Eff (Embed IO) z@.
--
-- In addition, since @z@ lifts @m@, you can lift values of @m@
-- to @z@ through 'liftBase'. This is most useful when using
-- 'interpret' or 'interpretSimple', as it allows you to
-- bring monadic values of @m@ from outside of the handler
-- (like arguments to the interpreter) into the handler.
--
-- The @z@ provided to the handler has 'Effly' wrapped around it,
-- so the handler may make use of the various instances of 'Effly'.
-- For example, you have access to 'MonadFix' inside the handler
-- if you have  @'Eff' 'Control.Effect.Fix.Fix' m@.
--
-- Any effect to be handled needs to be
-- /representational in the monad parameter/. See 'RepresentationalEff'
-- for more information.
type EffHandler e m =
     forall z x
   . ( Carrier z
     , Derivs z ~ Derivs m
     , Prims z ~ Prims m
     , MonadBase m z
     )
  => e (Effly z) x -> Effly z x

-- | The type of effect handlers for a primitive effect @e@ with current
-- carrier @m@.
--
-- Unlike 'EffHandler's, 'EffPrimHandler's have direct access to @m@,
-- making them significantly more powerful.
--
-- That said, __you should interpret your own effects as primitives only as a__
-- __last resort.__ Every primitive effect comes at the cost of enormous amounts
-- of boilerplate: namely, the need for a 'ThreadsEff' instance for every
-- monad transformer that can thread that effect.
--
-- Some effects in this library are intended to be used as primitive effects,
-- such as 'Control.Effect.Regional.Regional'. Try to use such effects
-- to gain the power you need to interpret your effects instead of
-- defining your own primitive effects, since the primitive effects offered
-- in this library already have 'ThreadsEff' instances defined for them.
type EffPrimHandler e m = forall x. e m x -> m x

-- | The class of effect handlers for primitive effects.
-- Instances of this class can be used together 'interpretPrimViaHandler'
-- in order to interpret primitive effects.
--
-- @h@ is the tag for the handler, @e@ is the effect to interpret,
-- and @m@ is the 'Carrier' on which the handler operates.
--
-- To define your own interpreter using this method, create a new
-- datatype without any constructors to serve as the tag
-- for the handler, and then define a 'PrimHandler' instance for it.
-- Then, you can use your handler to interpret effects with
-- 'interpretPrimViaHandler'.
--
-- Alternatively, you can use 'interpretPrim' or 'interpretPrimSimple',
-- which lets you avoid the need to define instances of 'PrimHandler',
-- but come at other costs.
--
-- __Only interpret your own effects as primitives as a last resort.__
-- See 'EffPrimHandler'.
class ( RepresentationalEff e
      , Carrier m
      ) => PrimHandler (h :: *) e m where
  effPrimHandler :: EffPrimHandler e m

instance ( Carrier m
         , Handler h e m
         ) => Carrier (InterpretC h e m) where
  type Derivs (InterpretC h e m) = e ': Derivs m
  type Prims (InterpretC h e m) = Prims m

  algPrims :: Algebra' (Prims (InterpretC h e m)) (InterpretC h e m) a
algPrims = (Union (Prims m) m a -> m a)
-> Algebra' (Prims m) (InterpretC h e m) a
coerce (forall a. Carrier m => Algebra' (Prims m) m a
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @m)
  {-# INLINEABLE algPrims #-}

  reformulate :: Reformulation'
  (Derivs (InterpretC h e m))
  (Prims (InterpretC h e m))
  (InterpretC h e m)
  z
  a
reformulate forall x. InterpretC h e m x -> z x
n Algebra (Prims (InterpretC h e m)) z
alg = Algebra' (Derivs m) z a
-> (e z a -> z a) -> Algebra' (e : Derivs m) z a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg (Reformulation' (Derivs m) (Prims m) m z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate (InterpretC h e m x -> z x
forall x. InterpretC h e m x -> z x
n (InterpretC h e m x -> z x)
-> (m x -> InterpretC h e m x) -> m x -> z x
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# m x -> InterpretC h e m x
forall h (e :: Effect) (m :: * -> *) a. m a -> InterpretC h e m a
InterpretC) forall x. Union (Prims m) z x -> z x
Algebra (Prims (InterpretC h e m)) z
alg) ((e z a -> z a) -> Algebra' (e : Derivs m) z a)
-> (e z a -> z a) -> Algebra' (e : Derivs m) z a
forall a b. (a -> b) -> a -> b
$
    let
      !handlerState :: HandlerCState (Prims m) m z
handlerState = (forall x. m x -> z x)
-> (forall x. Union (Prims m) z x -> z x)
-> HandlerCState (Prims m) m z
forall (p :: [Effect]) (m :: * -> *) (z :: * -> *).
(forall x. m x -> z x) -> Algebra p z -> HandlerCState p m z
HandlerCState (InterpretC h e m x -> z x
forall x. InterpretC h e m x -> z x
n (InterpretC h e m x -> z x)
-> (m x -> InterpretC h e m x) -> m x -> z x
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# m x -> InterpretC h e m x
forall h (e :: Effect) (m :: * -> *) a. m a -> InterpretC h e m a
InterpretC) forall x. Union (Prims m) z x -> z x
Algebra (Prims (InterpretC h e m)) z
alg
    in
      HandlerCState (Prims m) m z
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
    pr s -> e z a -> z a)
-> e z a
-> z a
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify HandlerCState (Prims m) m z
handlerState ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
  pr s -> e z a -> z a)
 -> e z a -> z a)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
    pr s -> e z a -> z a)
-> e z a
-> z a
forall a b. (a -> b) -> a -> b
$ \(pr s
_ :: p s) ->
        \e z a
e -> forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
HandlerC sHandler sReform r p m z a -> z a
forall (z :: * -> *) a.
HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a
unHandlerC @s @(CarrierReform m) @_ @_ @m (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a)
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a
forall a b. (a -> b) -> a -> b
$ Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a
forall k (m :: k -> *) (a :: k). Effly m a -> m a
runEffly (Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
 -> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a)
-> Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a
forall a b. (a -> b) -> a -> b
$
          e (Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z)) a
-> Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
forall h (e :: Effect) (m :: * -> *).
Handler h e m =>
EffHandler e m
effHandler @h @e @m (e z a
-> e (Effly
        (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z))
     a
coerce e z a
e)
  {-# INLINEABLE reformulate #-}

  algDerivs :: Algebra' (Derivs (InterpretC h e m)) (InterpretC h e m) a
algDerivs = Algebra' (Derivs m) (InterpretC h e m) a
-> (e (InterpretC h e m) a -> InterpretC h e m a)
-> Algebra' (e : Derivs m) (InterpretC h e m) a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg (Algebra' (Derivs m) m a -> Algebra' (Derivs m) (InterpretC h e m) a
coerce (forall a. Carrier m => Algebra' (Derivs m) m a
forall (m :: * -> *) a. Carrier m => Algebra' (Derivs m) m a
algDerivs @m)) ((e (InterpretC h e m) a -> InterpretC h e m a)
 -> Algebra' (e : Derivs m) (InterpretC h e m) a)
-> (e (InterpretC h e m) a -> InterpretC h e m a)
-> Algebra' (e : Derivs m) (InterpretC h e m) a
forall a b. (a -> b) -> a -> b
$ \e (InterpretC h e m) a
e ->
    m a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a. m a -> InterpretC h e m a
InterpretC (m a -> InterpretC h e m a) -> m a -> InterpretC h e m a
forall a b. (a -> b) -> a -> b
$ Itself m a -> m a
forall k (m :: k -> *) (a :: k). Itself m a -> m a
unItself (Itself m a -> m a) -> Itself m a -> m a
forall a b. (a -> b) -> a -> b
$ Effly (Itself m) a -> Itself m a
forall k (m :: k -> *) (a :: k). Effly m a -> m a
runEffly (Effly (Itself m) a -> Itself m a)
-> Effly (Itself m) a -> Itself m a
forall a b. (a -> b) -> a -> b
$ e (Effly (Itself m)) a -> Effly (Itself m) a
forall h (e :: Effect) (m :: * -> *).
Handler h e m =>
EffHandler e m
effHandler @h @e (e (InterpretC h e m) a -> e (Effly (Itself m)) a
coerce e (InterpretC h e m) a
e)
  {-# INLINEABLE algDerivs #-}

newtype InterpretC (h :: *) (e :: Effect) (m :: * -> *) a = InterpretC {
      InterpretC h e m a -> m a
unInterpretC :: m a
    }
  deriving ( a -> InterpretC h e m b -> InterpretC h e m a
(a -> b) -> InterpretC h e m a -> InterpretC h e m b
(forall a b. (a -> b) -> InterpretC h e m a -> InterpretC h e m b)
-> (forall a b. a -> InterpretC h e m b -> InterpretC h e m a)
-> Functor (InterpretC h e m)
forall a b. a -> InterpretC h e m b -> InterpretC h e m a
forall a b. (a -> b) -> InterpretC h e m a -> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretC h e m b -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretC h e m a -> InterpretC h e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> InterpretC h e m b -> InterpretC h e m a
$c<$ :: forall h (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretC h e m b -> InterpretC h e m a
fmap :: (a -> b) -> InterpretC h e m a -> InterpretC h e m b
$cfmap :: forall h (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretC h e m a -> InterpretC h e m b
Functor, Functor (InterpretC h e m)
a -> InterpretC h e m a
Functor (InterpretC h e m)
-> (forall a. a -> InterpretC h e m a)
-> (forall a b.
    InterpretC h e m (a -> b)
    -> InterpretC h e m a -> InterpretC h e m b)
-> (forall a b c.
    (a -> b -> c)
    -> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m c)
-> (forall a b.
    InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b)
-> (forall a b.
    InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a)
-> Applicative (InterpretC h e m)
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a
InterpretC h e m (a -> b)
-> InterpretC h e m a -> InterpretC h e m b
(a -> b -> c)
-> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m c
forall a. a -> InterpretC h e m a
forall a b.
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a
forall a b.
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
forall a b.
InterpretC h e m (a -> b)
-> InterpretC h e m a -> InterpretC h e m b
forall a b c.
(a -> b -> c)
-> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m c
forall h (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m (a -> b)
-> InterpretC h e m a -> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m 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
<* :: InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a
$c<* :: forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m a
*> :: InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
$c*> :: forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
liftA2 :: (a -> b -> c)
-> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m c
$cliftA2 :: forall h (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m c
<*> :: InterpretC h e m (a -> b)
-> InterpretC h e m a -> InterpretC h e m b
$c<*> :: forall h (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretC h e m (a -> b)
-> InterpretC h e m a -> InterpretC h e m b
pure :: a -> InterpretC h e m a
$cpure :: forall h (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretC h e m a
$cp1Applicative :: forall h (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretC h e m)
Applicative, Applicative (InterpretC h e m)
a -> InterpretC h e m a
Applicative (InterpretC h e m)
-> (forall a b.
    InterpretC h e m a
    -> (a -> InterpretC h e m b) -> InterpretC h e m b)
-> (forall a b.
    InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b)
-> (forall a. a -> InterpretC h e m a)
-> Monad (InterpretC h e m)
InterpretC h e m a
-> (a -> InterpretC h e m b) -> InterpretC h e m b
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
forall a. a -> InterpretC h e m a
forall a b.
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
forall a b.
InterpretC h e m a
-> (a -> InterpretC h e m b) -> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretC h e m a
-> (a -> InterpretC h e m b) -> InterpretC h e m 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 -> InterpretC h e m a
$creturn :: forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretC h e m a
>> :: InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
$c>> :: forall h (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretC h e m a -> InterpretC h e m b -> InterpretC h e m b
>>= :: InterpretC h e m a
-> (a -> InterpretC h e m b) -> InterpretC h e m b
$c>>= :: forall h (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretC h e m a
-> (a -> InterpretC h e m b) -> InterpretC h e m b
$cp1Monad :: forall h (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretC h e m)
Monad
           , Applicative (InterpretC h e m)
InterpretC h e m a
Applicative (InterpretC h e m)
-> (forall a. InterpretC h e m a)
-> (forall a.
    InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a)
-> (forall a. InterpretC h e m a -> InterpretC h e m [a])
-> (forall a. InterpretC h e m a -> InterpretC h e m [a])
-> Alternative (InterpretC h e m)
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
InterpretC h e m a -> InterpretC h e m [a]
InterpretC h e m a -> InterpretC h e m [a]
forall a. InterpretC h e m a
forall a. InterpretC h e m a -> InterpretC h e m [a]
forall a.
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a -> InterpretC h e m [a]
forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: InterpretC h e m a -> InterpretC h e m [a]
$cmany :: forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a -> InterpretC h e m [a]
some :: InterpretC h e m a -> InterpretC h e m [a]
$csome :: forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a -> InterpretC h e m [a]
<|> :: InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
$c<|> :: forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
empty :: InterpretC h e m a
$cempty :: forall h (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretC h e m a
$cp1Alternative :: forall h (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretC h e m)
Alternative, Monad (InterpretC h e m)
Alternative (InterpretC h e m)
InterpretC h e m a
Alternative (InterpretC h e m)
-> Monad (InterpretC h e m)
-> (forall a. InterpretC h e m a)
-> (forall a.
    InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a)
-> MonadPlus (InterpretC h e m)
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
forall a. InterpretC h e m a
forall a.
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
$cmplus :: forall h (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretC h e m a -> InterpretC h e m a -> InterpretC h e m a
mzero :: InterpretC h e m a
$cmzero :: forall h (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretC h e m a
$cp2MonadPlus :: forall h (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretC h e m)
$cp1MonadPlus :: forall h (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretC h e m)
MonadPlus
           , Monad (InterpretC h e m)
Monad (InterpretC h e m)
-> (forall a. (a -> InterpretC h e m a) -> InterpretC h e m a)
-> MonadFix (InterpretC h e m)
(a -> InterpretC h e m a) -> InterpretC h e m a
forall a. (a -> InterpretC h e m a) -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretC h e m a) -> InterpretC h e m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> InterpretC h e m a) -> InterpretC h e m a
$cmfix :: forall h (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretC h e m a) -> InterpretC h e m a
$cp1MonadFix :: forall h (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretC h e m)
MonadFix, Monad (InterpretC h e m)
Monad (InterpretC h e m)
-> (forall a. String -> InterpretC h e m a)
-> MonadFail (InterpretC h e m)
String -> InterpretC h e m a
forall a. String -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretC h e m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: String -> InterpretC h e m a
$cfail :: forall h (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretC h e m a
$cp1MonadFail :: forall h (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretC h e m)
MonadFail, Monad (InterpretC h e m)
Monad (InterpretC h e m)
-> (forall a. IO a -> InterpretC h e m a)
-> MonadIO (InterpretC h e m)
IO a -> InterpretC h e m a
forall a. IO a -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretC h e m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> InterpretC h e m a
$cliftIO :: forall h (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretC h e m a
$cp1MonadIO :: forall h (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretC h e m)
MonadIO
           , Monad (InterpretC h e m)
e -> InterpretC h e m a
Monad (InterpretC h e m)
-> (forall e a. Exception e => e -> InterpretC h e m a)
-> MonadThrow (InterpretC h e m)
forall e a. Exception e => e -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretC h e m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> InterpretC h e m a
$cthrowM :: forall h (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretC h e m a
$cp1MonadThrow :: forall h (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretC h e m)
MonadThrow, MonadThrow (InterpretC h e m)
MonadThrow (InterpretC h e m)
-> (forall e a.
    Exception e =>
    InterpretC h e m a
    -> (e -> InterpretC h e m a) -> InterpretC h e m a)
-> MonadCatch (InterpretC h e m)
InterpretC h e m a
-> (e -> InterpretC h e m a) -> InterpretC h e m a
forall e a.
Exception e =>
InterpretC h e m a
-> (e -> InterpretC h e m a) -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretC h e m a
-> (e -> InterpretC h e m a) -> InterpretC h e m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: InterpretC h e m a
-> (e -> InterpretC h e m a) -> InterpretC h e m a
$ccatch :: forall h (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretC h e m a
-> (e -> InterpretC h e m a) -> InterpretC h e m a
$cp1MonadCatch :: forall h (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretC h e m)
MonadCatch, MonadCatch (InterpretC h e m)
MonadCatch (InterpretC h e m)
-> (forall b.
    ((forall a. InterpretC h e m a -> InterpretC h e m a)
     -> InterpretC h e m b)
    -> InterpretC h e m b)
-> (forall b.
    ((forall a. InterpretC h e m a -> InterpretC h e m a)
     -> InterpretC h e m b)
    -> InterpretC h e m b)
-> (forall a b c.
    InterpretC h e m a
    -> (a -> ExitCase b -> InterpretC h e m c)
    -> (a -> InterpretC h e m b)
    -> InterpretC h e m (b, c))
-> MonadMask (InterpretC h e m)
InterpretC h e m a
-> (a -> ExitCase b -> InterpretC h e m c)
-> (a -> InterpretC h e m b)
-> InterpretC h e m (b, c)
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
forall b.
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
forall a b c.
InterpretC h e m a
-> (a -> ExitCase b -> InterpretC h e m c)
-> (a -> InterpretC h e m b)
-> InterpretC h e m (b, c)
forall h (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretC h e m)
forall h (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
forall h (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretC h e m a
-> (a -> ExitCase b -> InterpretC h e m c)
-> (a -> InterpretC h e m b)
-> InterpretC h e m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: InterpretC h e m a
-> (a -> ExitCase b -> InterpretC h e m c)
-> (a -> InterpretC h e m b)
-> InterpretC h e m (b, c)
$cgeneralBracket :: forall h (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretC h e m a
-> (a -> ExitCase b -> InterpretC h e m c)
-> (a -> InterpretC h e m b)
-> InterpretC h e m (b, c)
uninterruptibleMask :: ((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
$cuninterruptibleMask :: forall h (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
mask :: ((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
$cmask :: forall h (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretC h e m a -> InterpretC h e m a)
 -> InterpretC h e m b)
-> InterpretC h e m b
$cp1MonadMask :: forall h (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretC h e m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
  deriving (m a -> InterpretC h e m a
(forall (m :: * -> *) a. Monad m => m a -> InterpretC h e m a)
-> MonadTrans (InterpretC h e)
forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> InterpretC h e m a
forall (m :: * -> *) a. Monad m => m a -> InterpretC h e m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> InterpretC h e m a
$clift :: forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> InterpretC h e m a
MonadTrans, MonadTrans (InterpretC h e)
m (StT (InterpretC h e) a) -> InterpretC h e m a
MonadTrans (InterpretC h e)
-> (forall (m :: * -> *) a.
    Monad m =>
    (Run (InterpretC h e) -> m a) -> InterpretC h e m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT (InterpretC h e) a) -> InterpretC h e m a)
-> MonadTransControl (InterpretC h e)
(Run (InterpretC h e) -> m a) -> InterpretC h e m a
forall h (e :: Effect). MonadTrans (InterpretC h e)
forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
m (StT (InterpretC h e) a) -> InterpretC h e m a
forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
(Run (InterpretC h e) -> m a) -> InterpretC h e m a
forall (m :: * -> *) a.
Monad m =>
m (StT (InterpretC h e) a) -> InterpretC h e m a
forall (m :: * -> *) a.
Monad m =>
(Run (InterpretC h e) -> m a) -> InterpretC h e m a
forall (t :: Effect).
MonadTrans t
-> (forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT (InterpretC h e) a) -> InterpretC h e m a
$crestoreT :: forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
m (StT (InterpretC h e) a) -> InterpretC h e m a
liftWith :: (Run (InterpretC h e) -> m a) -> InterpretC h e m a
$cliftWith :: forall h (e :: Effect) (m :: * -> *) a.
Monad m =>
(Run (InterpretC h e) -> m a) -> InterpretC h e m a
$cp1MonadTransControl :: forall h (e :: Effect). MonadTrans (InterpretC h e)
MonadTransControl) via IdentityT


newtype ReifiedHandler e m = ReifiedHandler {
  ReifiedHandler e m
-> forall (z :: * -> *) x.
   (Carrier z, Derivs z ~ Derivs m, Prims z ~ Prims m,
    MonadBase m z) =>
   e (Effly z) x -> Effly z x
getReifiedHandler :: EffHandler e m
  }



newtype ReifiedPrimHandler (e :: Effect) m = ReifiedPrimHandler {
    ReifiedPrimHandler e m
-> forall (z :: * -> *) x. Coercible z m => e z x -> m x
getReifiedPrimHandler :: forall z x. Coercible z m => e z x -> m x
  }

coerceHandler :: (RepresentationalEff e, Coercible m n)
              => (e m a -> m a) -> e n a -> n a
coerceHandler :: (e m a -> m a) -> e n a -> n a
coerceHandler = (e m a -> m a) -> e n a -> n a
coerce
{-# INLINE coerceHandler #-}

instance PrimHandler h e m => Carrier (InterpretPrimC h e m) where
  type Derivs (InterpretPrimC h e m) = e ': Derivs m
  type Prims (InterpretPrimC h e m) = e ': Prims m

  algPrims :: Algebra' (Prims (InterpretPrimC h e m)) (InterpretPrimC h e m) a
algPrims =
    Algebra' (Prims m) (InterpretPrimC h e m) a
-> (e (InterpretPrimC h e m) a -> InterpretPrimC h e m a)
-> Algebra' (e : Prims m) (InterpretPrimC h e m) a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg
      (Algebra' (Prims m) m a
-> Algebra' (Prims m) (InterpretPrimC h e m) a
coerce (forall a. Carrier m => Algebra' (Prims m) m a
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @m))
      ((e m a -> m a)
-> e (InterpretPrimC h e m) a -> InterpretPrimC h e m a
forall (e :: Effect) (m :: * -> *) (n :: * -> *) a.
(RepresentationalEff e, Coercible m n) =>
(e m a -> m a) -> e n a -> n a
coerceHandler (PrimHandler h e m => EffPrimHandler e m
forall h (e :: Effect) (m :: * -> *).
PrimHandler h e m =>
EffPrimHandler e m
effPrimHandler @h @e @m))
  {-# INLINEABLE algPrims #-}

  reformulate :: Reformulation'
  (Derivs (InterpretPrimC h e m))
  (Prims (InterpretPrimC h e m))
  (InterpretPrimC h e m)
  z
  a
reformulate = Reformulation' (Derivs m) (Prims m) (InterpretPrimC h e m) z a
-> Reformulation'
     (e : Derivs m) (e : Prims m) (InterpretPrimC h e m) z a
forall (e :: Effect) (r :: [Effect]) (p :: [Effect]) (m :: * -> *)
       (z :: * -> *) a.
Monad z =>
Reformulation' r p m z a -> Reformulation' (e : r) (e : p) m z a
addPrim (Reformulation' (Derivs m) (Prims m) m z a
-> Reformulation' (Derivs m) (Prims m) (InterpretPrimC h e m) z a
forall (m :: * -> *) (n :: * -> *) (r :: [Effect]) (p :: [Effect])
       (z :: * -> *) a.
Coercible m n =>
Reformulation' r p m z a -> Reformulation' r p n z a
coerceReform (forall (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate @m))
  {-# INLINEABLE reformulate #-}

  algDerivs :: Algebra' (Derivs (InterpretPrimC h e m)) (InterpretPrimC h e m) a
algDerivs =
    Algebra' (Derivs m) (InterpretPrimC h e m) a
-> (e (InterpretPrimC h e m) a -> InterpretPrimC h e m a)
-> Algebra' (e : Derivs m) (InterpretPrimC h e m) a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg
      (Algebra' (Derivs m) m a
-> Algebra' (Derivs m) (InterpretPrimC h e m) a
coerce (forall a. Carrier m => Algebra' (Derivs m) m a
forall (m :: * -> *) a. Carrier m => Algebra' (Derivs m) m a
algDerivs @m))
      ((e m a -> m a)
-> e (InterpretPrimC h e m) a -> InterpretPrimC h e m a
forall (e :: Effect) (m :: * -> *) (n :: * -> *) a.
(RepresentationalEff e, Coercible m n) =>
(e m a -> m a) -> e n a -> n a
coerceHandler (PrimHandler h e m => EffPrimHandler e m
forall h (e :: Effect) (m :: * -> *).
PrimHandler h e m =>
EffPrimHandler e m
effPrimHandler @h @e @m))
  {-# INLINEABLE algDerivs #-}

data ViaReifiedH (s :: *)

instance ( RepresentationalEff e
         , Carrier m
         , Reifies s (ReifiedHandler e m)
         ) => Handler (ViaReifiedH s) e m where
  effHandler :: e (Effly z) x -> Effly z x
effHandler = ReifiedHandler e m -> EffHandler e m
forall (e :: Effect) (m :: * -> *).
ReifiedHandler e m
-> forall (z :: * -> *) x.
   (Carrier z, Derivs z ~ Derivs m, Prims z ~ Prims m,
    MonadBase m z) =>
   e (Effly z) x -> Effly z x
getReifiedHandler (forall a. Reifies s a => a
forall k (s :: k) a. Reifies s a => a
reflect @s)
  {-# INLINE effHandler #-}

instance ( RepresentationalEff e
         , Carrier m
         , Reifies s (ReifiedPrimHandler e m)
         ) => PrimHandler (ViaReifiedH s) e m where
  effPrimHandler :: e m x -> m x
effPrimHandler = ReifiedPrimHandler e m
-> forall (z :: * -> *) x. Coercible z m => e z x -> m x
forall (e :: Effect) (m :: * -> *).
ReifiedPrimHandler e m
-> forall (z :: * -> *) x. Coercible z m => e z x -> m x
getReifiedPrimHandler (forall a. Reifies s a => a
forall k (s :: k) a. Reifies s a => a
reflect @s)
  {-# INLINE effPrimHandler #-}

type InterpretReifiedC e m a =
     forall s
   . ReifiesHandler s e m
  => InterpretC (ViaReifiedH s) e m a

type InterpretPrimReifiedC e m a =
     forall s
   . ReifiesPrimHandler s e m
  => InterpretPrimC (ViaReifiedH s) e m a

newtype InterpretSimpleC (e :: Effect) (m :: * -> *) a = InterpretSimpleC {
      InterpretSimpleC e m a -> ReaderT (ReifiedHandler e m) m a
unInterpretSimpleC :: ReaderT (ReifiedHandler e m) m a
    }
  deriving ( a -> InterpretSimpleC e m b -> InterpretSimpleC e m a
(a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b
(forall a b.
 (a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b)
-> (forall a b.
    a -> InterpretSimpleC e m b -> InterpretSimpleC e m a)
-> Functor (InterpretSimpleC e m)
forall a b. a -> InterpretSimpleC e m b -> InterpretSimpleC e m a
forall a b.
(a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretSimpleC e m b -> InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b
<$ :: a -> InterpretSimpleC e m b -> InterpretSimpleC e m a
$c<$ :: forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretSimpleC e m b -> InterpretSimpleC e m a
fmap :: (a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b
$cfmap :: forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b) -> InterpretSimpleC e m a -> InterpretSimpleC e m b
Functor, Functor (InterpretSimpleC e m)
a -> InterpretSimpleC e m a
Functor (InterpretSimpleC e m)
-> (forall a. a -> InterpretSimpleC e m a)
-> (forall a b.
    InterpretSimpleC e m (a -> b)
    -> InterpretSimpleC e m a -> InterpretSimpleC e m b)
-> (forall a b c.
    (a -> b -> c)
    -> InterpretSimpleC e m a
    -> InterpretSimpleC e m b
    -> InterpretSimpleC e m c)
-> (forall a b.
    InterpretSimpleC e m a
    -> InterpretSimpleC e m b -> InterpretSimpleC e m b)
-> (forall a b.
    InterpretSimpleC e m a
    -> InterpretSimpleC e m b -> InterpretSimpleC e m a)
-> Applicative (InterpretSimpleC e m)
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m a
InterpretSimpleC e m (a -> b)
-> InterpretSimpleC e m a -> InterpretSimpleC e m b
(a -> b -> c)
-> InterpretSimpleC e m a
-> InterpretSimpleC e m b
-> InterpretSimpleC e m c
forall a. a -> InterpretSimpleC e m a
forall a b.
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m a
forall a b.
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
forall a b.
InterpretSimpleC e m (a -> b)
-> InterpretSimpleC e m a -> InterpretSimpleC e m b
forall a b c.
(a -> b -> c)
-> InterpretSimpleC e m a
-> InterpretSimpleC e m b
-> InterpretSimpleC e m 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
forall (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m (a -> b)
-> InterpretSimpleC e m a -> InterpretSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretSimpleC e m a
-> InterpretSimpleC e m b
-> InterpretSimpleC e m c
<* :: InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m a
$c<* :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m a
*> :: InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
$c*> :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
liftA2 :: (a -> b -> c)
-> InterpretSimpleC e m a
-> InterpretSimpleC e m b
-> InterpretSimpleC e m c
$cliftA2 :: forall (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretSimpleC e m a
-> InterpretSimpleC e m b
-> InterpretSimpleC e m c
<*> :: InterpretSimpleC e m (a -> b)
-> InterpretSimpleC e m a -> InterpretSimpleC e m b
$c<*> :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretSimpleC e m (a -> b)
-> InterpretSimpleC e m a -> InterpretSimpleC e m b
pure :: a -> InterpretSimpleC e m a
$cpure :: forall (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretSimpleC e m a
$cp1Applicative :: forall (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretSimpleC e m)
Applicative, Applicative (InterpretSimpleC e m)
a -> InterpretSimpleC e m a
Applicative (InterpretSimpleC e m)
-> (forall a b.
    InterpretSimpleC e m a
    -> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m b)
-> (forall a b.
    InterpretSimpleC e m a
    -> InterpretSimpleC e m b -> InterpretSimpleC e m b)
-> (forall a. a -> InterpretSimpleC e m a)
-> Monad (InterpretSimpleC e m)
InterpretSimpleC e m a
-> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m b
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
forall a. a -> InterpretSimpleC e m a
forall a b.
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
forall a b.
InterpretSimpleC e m a
-> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m 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
forall (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretSimpleC e m a
-> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m b
return :: a -> InterpretSimpleC e m a
$creturn :: forall (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretSimpleC e m a
>> :: InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
$c>> :: forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m b -> InterpretSimpleC e m b
>>= :: InterpretSimpleC e m a
-> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m b
$c>>= :: forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretSimpleC e m a
-> (a -> InterpretSimpleC e m b) -> InterpretSimpleC e m b
$cp1Monad :: forall (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretSimpleC e m)
Monad
           , Applicative (InterpretSimpleC e m)
InterpretSimpleC e m a
Applicative (InterpretSimpleC e m)
-> (forall a. InterpretSimpleC e m a)
-> (forall a.
    InterpretSimpleC e m a
    -> InterpretSimpleC e m a -> InterpretSimpleC e m a)
-> (forall a. InterpretSimpleC e m a -> InterpretSimpleC e m [a])
-> (forall a. InterpretSimpleC e m a -> InterpretSimpleC e m [a])
-> Alternative (InterpretSimpleC e m)
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
InterpretSimpleC e m a -> InterpretSimpleC e m [a]
InterpretSimpleC e m a -> InterpretSimpleC e m [a]
forall a. InterpretSimpleC e m a
forall a. InterpretSimpleC e m a -> InterpretSimpleC e m [a]
forall a.
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a -> InterpretSimpleC e m [a]
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
many :: InterpretSimpleC e m a -> InterpretSimpleC e m [a]
$cmany :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a -> InterpretSimpleC e m [a]
some :: InterpretSimpleC e m a -> InterpretSimpleC e m [a]
$csome :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a -> InterpretSimpleC e m [a]
<|> :: InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
$c<|> :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
empty :: InterpretSimpleC e m a
$cempty :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretSimpleC e m a
$cp1Alternative :: forall (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretSimpleC e m)
Alternative, Monad (InterpretSimpleC e m)
Alternative (InterpretSimpleC e m)
InterpretSimpleC e m a
Alternative (InterpretSimpleC e m)
-> Monad (InterpretSimpleC e m)
-> (forall a. InterpretSimpleC e m a)
-> (forall a.
    InterpretSimpleC e m a
    -> InterpretSimpleC e m a -> InterpretSimpleC e m a)
-> MonadPlus (InterpretSimpleC e m)
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
forall a. InterpretSimpleC e m a
forall a.
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
mplus :: InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
$cmplus :: forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretSimpleC e m a
-> InterpretSimpleC e m a -> InterpretSimpleC e m a
mzero :: InterpretSimpleC e m a
$cmzero :: forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretSimpleC e m a
$cp2MonadPlus :: forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretSimpleC e m)
$cp1MonadPlus :: forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretSimpleC e m)
MonadPlus
           , Monad (InterpretSimpleC e m)
Monad (InterpretSimpleC e m)
-> (forall a.
    (a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a)
-> MonadFix (InterpretSimpleC e m)
(a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
forall a. (a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
mfix :: (a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
$cmfix :: forall (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
$cp1MonadFix :: forall (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretSimpleC e m)
MonadFix, Monad (InterpretSimpleC e m)
Monad (InterpretSimpleC e m)
-> (forall a. String -> InterpretSimpleC e m a)
-> MonadFail (InterpretSimpleC e m)
String -> InterpretSimpleC e m a
forall a. String -> InterpretSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretSimpleC e m a
fail :: String -> InterpretSimpleC e m a
$cfail :: forall (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretSimpleC e m a
$cp1MonadFail :: forall (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretSimpleC e m)
MonadFail, Monad (InterpretSimpleC e m)
Monad (InterpretSimpleC e m)
-> (forall a. IO a -> InterpretSimpleC e m a)
-> MonadIO (InterpretSimpleC e m)
IO a -> InterpretSimpleC e m a
forall a. IO a -> InterpretSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretSimpleC e m a
liftIO :: IO a -> InterpretSimpleC e m a
$cliftIO :: forall (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretSimpleC e m a
$cp1MonadIO :: forall (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretSimpleC e m)
MonadIO
           , Monad (InterpretSimpleC e m)
e -> InterpretSimpleC e m a
Monad (InterpretSimpleC e m)
-> (forall e a. Exception e => e -> InterpretSimpleC e m a)
-> MonadThrow (InterpretSimpleC e m)
forall e a. Exception e => e -> InterpretSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretSimpleC e m a
throwM :: e -> InterpretSimpleC e m a
$cthrowM :: forall (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretSimpleC e m a
$cp1MonadThrow :: forall (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretSimpleC e m)
MonadThrow, MonadThrow (InterpretSimpleC e m)
MonadThrow (InterpretSimpleC e m)
-> (forall e a.
    Exception e =>
    InterpretSimpleC e m a
    -> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a)
-> MonadCatch (InterpretSimpleC e m)
InterpretSimpleC e m a
-> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
forall e a.
Exception e =>
InterpretSimpleC e m a
-> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretSimpleC e m a
-> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
catch :: InterpretSimpleC e m a
-> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
$ccatch :: forall (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretSimpleC e m a
-> (e -> InterpretSimpleC e m a) -> InterpretSimpleC e m a
$cp1MonadCatch :: forall (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretSimpleC e m)
MonadCatch, MonadCatch (InterpretSimpleC e m)
MonadCatch (InterpretSimpleC e m)
-> (forall b.
    ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
     -> InterpretSimpleC e m b)
    -> InterpretSimpleC e m b)
-> (forall b.
    ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
     -> InterpretSimpleC e m b)
    -> InterpretSimpleC e m b)
-> (forall a b c.
    InterpretSimpleC e m a
    -> (a -> ExitCase b -> InterpretSimpleC e m c)
    -> (a -> InterpretSimpleC e m b)
    -> InterpretSimpleC e m (b, c))
-> MonadMask (InterpretSimpleC e m)
InterpretSimpleC e m a
-> (a -> ExitCase b -> InterpretSimpleC e m c)
-> (a -> InterpretSimpleC e m b)
-> InterpretSimpleC e m (b, c)
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
forall b.
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
forall a b c.
InterpretSimpleC e m a
-> (a -> ExitCase b -> InterpretSimpleC e m c)
-> (a -> InterpretSimpleC e m b)
-> InterpretSimpleC e m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
forall (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretSimpleC e m)
forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretSimpleC e m a
-> (a -> ExitCase b -> InterpretSimpleC e m c)
-> (a -> InterpretSimpleC e m b)
-> InterpretSimpleC e m (b, c)
generalBracket :: InterpretSimpleC e m a
-> (a -> ExitCase b -> InterpretSimpleC e m c)
-> (a -> InterpretSimpleC e m b)
-> InterpretSimpleC e m (b, c)
$cgeneralBracket :: forall (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretSimpleC e m a
-> (a -> ExitCase b -> InterpretSimpleC e m c)
-> (a -> InterpretSimpleC e m b)
-> InterpretSimpleC e m (b, c)
uninterruptibleMask :: ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
$cuninterruptibleMask :: forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
mask :: ((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
$cmask :: forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a. InterpretSimpleC e m a -> InterpretSimpleC e m a)
 -> InterpretSimpleC e m b)
-> InterpretSimpleC e m b
$cp1MonadMask :: forall (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretSimpleC e m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
       via ReaderT (ReifiedHandler e m) m

instance MonadTrans (InterpretSimpleC e) where
  lift :: m a -> InterpretSimpleC e m a
lift m a
m = ReaderT (ReifiedHandler e m) m a -> InterpretSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
ReaderT (ReifiedHandler e m) m a -> InterpretSimpleC e m a
InterpretSimpleC (m a -> ReaderT (ReifiedHandler e m) m a
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m a
m)
  {-# INLINE lift #-}

instance ( Threads (ReaderT (ReifiedHandler e m)) (Prims m)
         , RepresentationalEff e
         , Carrier m
         )
      => Carrier (InterpretSimpleC e m) where
  type Derivs (InterpretSimpleC e m) = e ': Derivs m
  type Prims  (InterpretSimpleC e m) = Prims m

  algPrims :: Algebra' (Prims (InterpretSimpleC e m)) (InterpretSimpleC e m) a
algPrims = (Union (Prims m) (ReaderT (ReifiedHandler e m) m) a
 -> ReaderT (ReifiedHandler e m) m a)
-> Union (Prims m) (InterpretSimpleC e m) a
-> InterpretSimpleC e m a
forall (n :: * -> *) (m :: * -> *) (e :: Effect) a b.
(Coercible n m, RepresentationalEff e) =>
(e m a -> m b) -> e n a -> n b
coerceAlg (Algebra (Prims m) m
-> Algebra (Prims m) (ReaderT (ReifiedHandler e m) m)
forall (t :: Effect) (p :: [Effect]) (m :: * -> *).
(Threads t p, Monad m) =>
Algebra p m -> Algebra p (t m)
thread @(ReaderT (ReifiedHandler e m)) (Carrier m => Algebra (Prims m) m
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @m))
  {-# INLINEABLE algPrims #-}

  reformulate :: Reformulation'
  (Derivs (InterpretSimpleC e m))
  (Prims (InterpretSimpleC e m))
  (InterpretSimpleC e m)
  z
  a
reformulate forall x. InterpretSimpleC e m x -> z x
n Algebra (Prims (InterpretSimpleC e m)) z
alg = Algebra' (Derivs m) z a
-> (e z a -> z a) -> Algebra' (e : Derivs m) z a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg (Reformulation' (Derivs m) (Prims m) m z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate (InterpretSimpleC e m x -> z x
forall x. InterpretSimpleC e m x -> z x
n (InterpretSimpleC e m x -> z x)
-> (m x -> InterpretSimpleC e m x) -> m x -> z x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m x -> InterpretSimpleC e m x
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift) forall x. Union (Prims m) z x -> z x
Algebra (Prims (InterpretSimpleC e m)) z
alg) ((e z a -> z a) -> Algebra' (e : Derivs m) z a)
-> (e z a -> z a) -> Algebra' (e : Derivs m) z a
forall a b. (a -> b) -> a -> b
$ \e z a
e -> do
    ReifiedHandler EffHandler e m
handler <- InterpretSimpleC e m (ReifiedHandler e m) -> z (ReifiedHandler e m)
forall x. InterpretSimpleC e m x -> z x
n (ReaderT (ReifiedHandler e m) m (ReifiedHandler e m)
-> InterpretSimpleC e m (ReifiedHandler e m)
forall (e :: Effect) (m :: * -> *) a.
ReaderT (ReifiedHandler e m) m a -> InterpretSimpleC e m a
InterpretSimpleC ReaderT (ReifiedHandler e m) m (ReifiedHandler e m)
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask)
    let !handlerState :: HandlerCState (Prims m) m z
handlerState = (forall x. m x -> z x)
-> (forall x. Union (Prims m) z x -> z x)
-> HandlerCState (Prims m) m z
forall (p :: [Effect]) (m :: * -> *) (z :: * -> *).
(forall x. m x -> z x) -> Algebra p z -> HandlerCState p m z
HandlerCState (InterpretSimpleC e m x -> z x
forall x. InterpretSimpleC e m x -> z x
n (InterpretSimpleC e m x -> z x)
-> (m x -> InterpretSimpleC e m x) -> m x -> z x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m x -> InterpretSimpleC e m x
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift) forall x. Union (Prims m) z x -> z x
Algebra (Prims (InterpretSimpleC e m)) z
alg
    HandlerCState (Prims m) m z
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
    pr s -> z a)
-> z a
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify HandlerCState (Prims m) m z
handlerState ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
  pr s -> z a)
 -> z a)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState (Prims m) m z)) =>
    pr s -> z a)
-> z a
forall a b. (a -> b) -> a -> b
$ \(pr s
_ :: p s) ->
      forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
HandlerC sHandler sReform r p m z a -> z a
forall (z :: * -> *) a.
HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a
unHandlerC @s @(CarrierReform m) @_ @_ @m (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a)
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a -> z a
forall a b. (a -> b) -> a -> b
$ Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a
forall k (m :: k -> *) (a :: k). Effly m a -> m a
runEffly (Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
 -> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a)
-> Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
-> HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z a
forall a b. (a -> b) -> a -> b
$
        e (Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z)) a
-> Effly (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z) a
EffHandler e m
handler (e z a
-> e (Effly
        (HandlerC s (CarrierReform m) (Derivs m) (Prims m) m z))
     a
coerce e z a
e)
  {-# INLINEABLE reformulate #-}

newtype InterpretPrimSimpleC (e :: Effect) (m :: * -> *) a =
    InterpretPrimSimpleC {
      InterpretPrimSimpleC e m a -> ReaderT (ReifiedPrimHandler e m) m a
unInterpretPrimSimpleC :: ReaderT (ReifiedPrimHandler e m) m a
    }
  deriving ( a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
(a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
(forall a b.
 (a -> b)
 -> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b)
-> (forall a b.
    a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a)
-> Functor (InterpretPrimSimpleC e m)
forall a b.
a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
forall a b.
(a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
<$ :: a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
$c<$ :: forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
a -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
fmap :: (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
$cfmap :: forall (e :: Effect) (m :: * -> *) a b.
Functor m =>
(a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
Functor, Functor (InterpretPrimSimpleC e m)
a -> InterpretPrimSimpleC e m a
Functor (InterpretPrimSimpleC e m)
-> (forall a. a -> InterpretPrimSimpleC e m a)
-> (forall a b.
    InterpretPrimSimpleC e m (a -> b)
    -> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b)
-> (forall a b c.
    (a -> b -> c)
    -> InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m b
    -> InterpretPrimSimpleC e m c)
-> (forall a b.
    InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b)
-> (forall a b.
    InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a)
-> Applicative (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
InterpretPrimSimpleC e m (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
(a -> b -> c)
-> InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b
-> InterpretPrimSimpleC e m c
forall a. a -> InterpretPrimSimpleC e m a
forall a b.
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
forall a b.
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
forall a b.
InterpretPrimSimpleC e m (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
forall a b c.
(a -> b -> c)
-> InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b
-> InterpretPrimSimpleC e m 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
forall (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b
-> InterpretPrimSimpleC e m c
<* :: InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
$c<* :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m a
*> :: InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
$c*> :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
liftA2 :: (a -> b -> c)
-> InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b
-> InterpretPrimSimpleC e m c
$cliftA2 :: forall (e :: Effect) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b
-> InterpretPrimSimpleC e m c
<*> :: InterpretPrimSimpleC e m (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
$c<*> :: forall (e :: Effect) (m :: * -> *) a b.
Applicative m =>
InterpretPrimSimpleC e m (a -> b)
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m b
pure :: a -> InterpretPrimSimpleC e m a
$cpure :: forall (e :: Effect) (m :: * -> *) a.
Applicative m =>
a -> InterpretPrimSimpleC e m a
$cp1Applicative :: forall (e :: Effect) (m :: * -> *).
Applicative m =>
Functor (InterpretPrimSimpleC e m)
Applicative, Applicative (InterpretPrimSimpleC e m)
a -> InterpretPrimSimpleC e m a
Applicative (InterpretPrimSimpleC e m)
-> (forall a b.
    InterpretPrimSimpleC e m a
    -> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m b)
-> (forall a b.
    InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b)
-> (forall a. a -> InterpretPrimSimpleC e m a)
-> Monad (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m b
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
forall a. a -> InterpretPrimSimpleC e m a
forall a b.
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
forall a b.
InterpretPrimSimpleC e m a
-> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m 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
forall (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimSimpleC e m a
-> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m b
return :: a -> InterpretPrimSimpleC e m a
$creturn :: forall (e :: Effect) (m :: * -> *) a.
Monad m =>
a -> InterpretPrimSimpleC e m a
>> :: InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
$c>> :: forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m b -> InterpretPrimSimpleC e m b
>>= :: InterpretPrimSimpleC e m a
-> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m b
$c>>= :: forall (e :: Effect) (m :: * -> *) a b.
Monad m =>
InterpretPrimSimpleC e m a
-> (a -> InterpretPrimSimpleC e m b) -> InterpretPrimSimpleC e m b
$cp1Monad :: forall (e :: Effect) (m :: * -> *).
Monad m =>
Applicative (InterpretPrimSimpleC e m)
Monad
           , Applicative (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
Applicative (InterpretPrimSimpleC e m)
-> (forall a. InterpretPrimSimpleC e m a)
-> (forall a.
    InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
-> (forall a.
    InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a])
-> (forall a.
    InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a])
-> Alternative (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
forall a. InterpretPrimSimpleC e m a
forall a.
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
forall a.
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
many :: InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
$cmany :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
some :: InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
$csome :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m [a]
<|> :: InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
$c<|> :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
empty :: InterpretPrimSimpleC e m a
$cempty :: forall (e :: Effect) (m :: * -> *) a.
Alternative m =>
InterpretPrimSimpleC e m a
$cp1Alternative :: forall (e :: Effect) (m :: * -> *).
Alternative m =>
Applicative (InterpretPrimSimpleC e m)
Alternative, Monad (InterpretPrimSimpleC e m)
Alternative (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
Alternative (InterpretPrimSimpleC e m)
-> Monad (InterpretPrimSimpleC e m)
-> (forall a. InterpretPrimSimpleC e m a)
-> (forall a.
    InterpretPrimSimpleC e m a
    -> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
-> MonadPlus (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
forall a. InterpretPrimSimpleC e m a
forall a.
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
mplus :: InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
$cmplus :: forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimSimpleC e m a
-> InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a
mzero :: InterpretPrimSimpleC e m a
$cmzero :: forall (e :: Effect) (m :: * -> *) a.
MonadPlus m =>
InterpretPrimSimpleC e m a
$cp2MonadPlus :: forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Monad (InterpretPrimSimpleC e m)
$cp1MonadPlus :: forall (e :: Effect) (m :: * -> *).
MonadPlus m =>
Alternative (InterpretPrimSimpleC e m)
MonadPlus
           , Monad (InterpretPrimSimpleC e m)
Monad (InterpretPrimSimpleC e m)
-> (forall a.
    (a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a)
-> MonadFix (InterpretPrimSimpleC e m)
(a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
forall a.
(a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
mfix :: (a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
$cmfix :: forall (e :: Effect) (m :: * -> *) a.
MonadFix m =>
(a -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
$cp1MonadFix :: forall (e :: Effect) (m :: * -> *).
MonadFix m =>
Monad (InterpretPrimSimpleC e m)
MonadFix, Monad (InterpretPrimSimpleC e m)
Monad (InterpretPrimSimpleC e m)
-> (forall a. String -> InterpretPrimSimpleC e m a)
-> MonadFail (InterpretPrimSimpleC e m)
String -> InterpretPrimSimpleC e m a
forall a. String -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretPrimSimpleC e m a
fail :: String -> InterpretPrimSimpleC e m a
$cfail :: forall (e :: Effect) (m :: * -> *) a.
MonadFail m =>
String -> InterpretPrimSimpleC e m a
$cp1MonadFail :: forall (e :: Effect) (m :: * -> *).
MonadFail m =>
Monad (InterpretPrimSimpleC e m)
MonadFail, Monad (InterpretPrimSimpleC e m)
Monad (InterpretPrimSimpleC e m)
-> (forall a. IO a -> InterpretPrimSimpleC e m a)
-> MonadIO (InterpretPrimSimpleC e m)
IO a -> InterpretPrimSimpleC e m a
forall a. IO a -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretPrimSimpleC e m a
liftIO :: IO a -> InterpretPrimSimpleC e m a
$cliftIO :: forall (e :: Effect) (m :: * -> *) a.
MonadIO m =>
IO a -> InterpretPrimSimpleC e m a
$cp1MonadIO :: forall (e :: Effect) (m :: * -> *).
MonadIO m =>
Monad (InterpretPrimSimpleC e m)
MonadIO
           , Monad (InterpretPrimSimpleC e m)
e -> InterpretPrimSimpleC e m a
Monad (InterpretPrimSimpleC e m)
-> (forall e a. Exception e => e -> InterpretPrimSimpleC e m a)
-> MonadThrow (InterpretPrimSimpleC e m)
forall e a. Exception e => e -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretPrimSimpleC e m a
throwM :: e -> InterpretPrimSimpleC e m a
$cthrowM :: forall (e :: Effect) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> InterpretPrimSimpleC e m a
$cp1MonadThrow :: forall (e :: Effect) (m :: * -> *).
MonadThrow m =>
Monad (InterpretPrimSimpleC e m)
MonadThrow, MonadThrow (InterpretPrimSimpleC e m)
MonadThrow (InterpretPrimSimpleC e m)
-> (forall e a.
    Exception e =>
    InterpretPrimSimpleC e m a
    -> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a)
-> MonadCatch (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
forall e a.
Exception e =>
InterpretPrimSimpleC e m a
-> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretPrimSimpleC e m a
-> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
catch :: InterpretPrimSimpleC e m a
-> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
$ccatch :: forall (e :: Effect) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
InterpretPrimSimpleC e m a
-> (e -> InterpretPrimSimpleC e m a) -> InterpretPrimSimpleC e m a
$cp1MonadCatch :: forall (e :: Effect) (m :: * -> *).
MonadCatch m =>
MonadThrow (InterpretPrimSimpleC e m)
MonadCatch, MonadCatch (InterpretPrimSimpleC e m)
MonadCatch (InterpretPrimSimpleC e m)
-> (forall b.
    ((forall a.
      InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
     -> InterpretPrimSimpleC e m b)
    -> InterpretPrimSimpleC e m b)
-> (forall b.
    ((forall a.
      InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
     -> InterpretPrimSimpleC e m b)
    -> InterpretPrimSimpleC e m b)
-> (forall a b c.
    InterpretPrimSimpleC e m a
    -> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
    -> (a -> InterpretPrimSimpleC e m b)
    -> InterpretPrimSimpleC e m (b, c))
-> MonadMask (InterpretPrimSimpleC e m)
InterpretPrimSimpleC e m a
-> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
-> (a -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m (b, c)
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
forall b.
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
forall a b c.
InterpretPrimSimpleC e m a
-> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
-> (a -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
forall (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretPrimSimpleC e m)
forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
forall (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretPrimSimpleC e m a
-> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
-> (a -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m (b, c)
generalBracket :: InterpretPrimSimpleC e m a
-> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
-> (a -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m (b, c)
$cgeneralBracket :: forall (e :: Effect) (m :: * -> *) a b c.
MonadMask m =>
InterpretPrimSimpleC e m a
-> (a -> ExitCase b -> InterpretPrimSimpleC e m c)
-> (a -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m (b, c)
uninterruptibleMask :: ((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
$cuninterruptibleMask :: forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
mask :: ((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
$cmask :: forall (e :: Effect) (m :: * -> *) b.
MonadMask m =>
((forall a.
  InterpretPrimSimpleC e m a -> InterpretPrimSimpleC e m a)
 -> InterpretPrimSimpleC e m b)
-> InterpretPrimSimpleC e m b
$cp1MonadMask :: forall (e :: Effect) (m :: * -> *).
MonadMask m =>
MonadCatch (InterpretPrimSimpleC e m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
       via ReaderT (ReifiedPrimHandler e m) m

instance MonadTrans (InterpretPrimSimpleC e) where
  lift :: m a -> InterpretPrimSimpleC e m a
lift m a
m = ReaderT (ReifiedPrimHandler e m) m a -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
ReaderT (ReifiedPrimHandler e m) m a -> InterpretPrimSimpleC e m a
InterpretPrimSimpleC (m a -> ReaderT (ReifiedPrimHandler e m) m a
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m a
m)
  {-# INLINE lift #-}

instance ( Threads (ReaderT (ReifiedPrimHandler e m)) (Prims m)
         , ThreadsEff (ReaderT (ReifiedPrimHandler e m)) e
         , RepresentationalEff e
         , Carrier m
         )
      => Carrier (InterpretPrimSimpleC e m) where
  type Derivs (InterpretPrimSimpleC e m) = e ': Derivs m
  type Prims  (InterpretPrimSimpleC e m) = e ': Prims m

  algPrims :: Algebra'
  (Prims (InterpretPrimSimpleC e m)) (InterpretPrimSimpleC e m) a
algPrims =
    Algebra' (Prims m) (InterpretPrimSimpleC e m) a
-> (e (InterpretPrimSimpleC e m) a -> InterpretPrimSimpleC e m a)
-> Algebra' (e : Prims m) (InterpretPrimSimpleC e m) a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg
      ((Union (Prims m) (ReaderT (ReifiedPrimHandler e m) m) a
 -> ReaderT (ReifiedPrimHandler e m) m a)
-> Algebra' (Prims m) (InterpretPrimSimpleC e m) a
coerce (Algebra (Prims m) m
-> Algebra (Prims m) (ReaderT (ReifiedPrimHandler e m) m)
forall (t :: Effect) (p :: [Effect]) (m :: * -> *).
(Threads t p, Monad m) =>
Algebra p m -> Algebra p (t m)
thread @(ReaderT (ReifiedPrimHandler e m)) (Carrier m => Algebra (Prims m) m
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @m)))
      ((e (InterpretPrimSimpleC e m) a -> InterpretPrimSimpleC e m a)
 -> Algebra' (e : Prims m) (InterpretPrimSimpleC e m) a)
-> (e (InterpretPrimSimpleC e m) a -> InterpretPrimSimpleC e m a)
-> Algebra' (e : Prims m) (InterpretPrimSimpleC e m) a
forall a b. (a -> b) -> a -> b
$ \e (InterpretPrimSimpleC e m) a
e -> ReaderT (ReifiedPrimHandler e m) m a -> InterpretPrimSimpleC e m a
forall (e :: Effect) (m :: * -> *) a.
ReaderT (ReifiedPrimHandler e m) m a -> InterpretPrimSimpleC e m a
InterpretPrimSimpleC (ReaderT (ReifiedPrimHandler e m) m a
 -> InterpretPrimSimpleC e m a)
-> ReaderT (ReifiedPrimHandler e m) m a
-> InterpretPrimSimpleC e m a
forall a b. (a -> b) -> a -> b
$ (ReifiedPrimHandler e m -> m a)
-> ReaderT (ReifiedPrimHandler e m) m a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((ReifiedPrimHandler e m -> m a)
 -> ReaderT (ReifiedPrimHandler e m) m a)
-> (ReifiedPrimHandler e m -> m a)
-> ReaderT (ReifiedPrimHandler e m) m a
forall a b. (a -> b) -> a -> b
$ \rh :: ReifiedPrimHandler e m
rh@(ReifiedPrimHandler forall (z :: * -> *) x. Coercible z m => e z x -> m x
h) ->
        ReaderT (ReifiedPrimHandler e m) m a
-> ReifiedPrimHandler e m -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((forall x. e m x -> m x)
-> e (ReaderT (ReifiedPrimHandler e m) m) a
-> ReaderT (ReifiedPrimHandler e m) m a
forall (t :: Effect) (e :: Effect) (m :: * -> *) a.
(ThreadsEff t e, Monad m) =>
(forall x. e m x -> m x) -> e (t m) a -> t m a
threadEff @(ReaderT (ReifiedPrimHandler e m)) forall x. e m x -> m x
forall (z :: * -> *) x. Coercible z m => e z x -> m x
h (e (InterpretPrimSimpleC e m) a
-> e (ReaderT (ReifiedPrimHandler e m) m) a
coerce e (InterpretPrimSimpleC e m) a
e)) ReifiedPrimHandler e m
rh
  {-# INLINEABLE algPrims #-}

  reformulate :: Reformulation'
  (Derivs (InterpretPrimSimpleC e m))
  (Prims (InterpretPrimSimpleC e m))
  (InterpretPrimSimpleC e m)
  z
  a
reformulate = Reformulation' (Derivs m) (Prims m) (InterpretPrimSimpleC e m) z a
-> Reformulation'
     (e : Derivs m) (e : Prims m) (InterpretPrimSimpleC e m) z a
forall (e :: Effect) (r :: [Effect]) (p :: [Effect]) (m :: * -> *)
       (z :: * -> *) a.
Monad z =>
Reformulation' r p m z a -> Reformulation' (e : r) (e : p) m z a
addPrim (Reformulation' (Derivs m) (Prims m) m z a
-> Reformulation'
     (Derivs m) (Prims m) (InterpretPrimSimpleC e m) z a
forall (t :: Effect) (m :: * -> *) (r :: [Effect]) (p :: [Effect])
       (z :: * -> *) a.
(MonadTrans t, Monad m) =>
Reformulation' r p m z a -> Reformulation' r p (t m) z a
liftReform Reformulation' (Derivs m) (Prims m) m z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate)
  {-# INLINEABLE reformulate #-}

-- | Interpret an effect in terms of other effects, without needing to
-- define an explicit 'Handler' instance. This is an alternative to
-- 'interpretViaHandler', and is more performant than 'interpretSimple'.
--
-- See 'EffHandler' for more information about the handler you pass to
-- this function.
--
-- @'Derivs' ('InterpretReifiedC' e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretReifiedC' e m) = 'Prims' m@
--
-- This has a higher-rank type, as it makes use of 'InterpretReifiedC'.
-- __This makes 'interpret' very difficult to use partially applied.__
-- __In particular, it can't be composed using @'.'@.__ You must use
-- paranthesis or '$'.
--
-- Consider using 'interpretSimple' instead if performance is secondary.
--
-- Example usage:
--
-- @
-- data Teletype :: Effect where
--   ReadTTY  :: Teletype m String
--   WriteTTY :: String -> Teletype m ()
--
-- readTTY :: 'Eff' Teletype m => m String
-- readTTY = send ReadTTY
--
-- writeTTY :: 'Eff' Teletype m => String -> m ()
-- writeTTY = send . WriteTTY
--
-- echo :: 'Eff' Teletype m => m ()
-- echo = readTTY >>= sendTTY
--
-- teletypeToIO :: 'Eff' ('Control.Effect.Embed' IO) m => 'Control.Effect.InterpreterFor' Teletype m
-- teletypeToIO = 'interpret' $ \case
--   ReadTTY -> 'Control.Effect.embed' getLine
--   WriteTTY str -> 'Control.Effect.embed' $ putStrLn str
--
-- main :: IO ()
-- main = 'Control.Effect.runM' $ teletypeToIO $ echo
-- @
--
interpret :: forall e m a
           . (RepresentationalEff e, Carrier m)
          => EffHandler e m
          -> InterpretReifiedC e m a
          -> m a
interpret :: EffHandler e m -> InterpretReifiedC e m a -> m a
interpret EffHandler e m
h InterpretReifiedC e m a
m = ReifiedHandler e m
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedHandler e m)) =>
    pr s -> m a)
-> m a
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify (EffHandler e m -> ReifiedHandler e m
forall (e :: Effect) (m :: * -> *).
(forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ Derivs m, Prims z ~ Prims m,
  MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> ReifiedHandler e m
ReifiedHandler EffHandler e m
h) ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (ReifiedHandler e m)) =>
  pr s -> m a)
 -> m a)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedHandler e m)) =>
    pr s -> m a)
-> m a
forall a b. (a -> b) -> a -> b
$ \(pr s
_ :: p s) ->
  InterpretC (ViaReifiedH s) e m a -> m a
forall h (e :: Effect) (m :: * -> *) a. InterpretC h e m a -> m a
unInterpretC @(ViaReifiedH s) InterpretC (ViaReifiedH s) e m a
InterpretReifiedC e m a
m
{-# INLINE interpret #-}

-- | Interpret an effect in terms of other effects, without needing to
-- define an explicit 'Handler' instance. This is an alternative to
-- 'interpretViaHandler'.
--
-- See 'EffHandler' for more information about the handler you pass to
-- this function.
--
-- @'Derivs' ('InterpretSimpleC' e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretSimpleC' e m) = 'Prims' m@
--
-- This is a significantly slower variant of 'interpret' that doesn't have
-- a higher-ranked type, making it much easier to use partially applied.
--
-- Note: this emits the threading constraint 'ReaderThreads' (see 'Threaders').
-- This makes 'interpretSimple' significantly less attractive to use
-- in application code, as it means propagating that constraint
-- through your application.
--
-- Example usage:
--
-- @
-- data Teletype :: Effect where
--   ReadTTY  :: Teletype m String
--   WriteTTY :: String -> Teletype m ()
--
-- readTTY :: 'Eff' Teletype m => m String
-- readTTY = send ReadTTY
--
-- writeTTY :: 'Eff' Teletype m => String -> m ()
-- writeTTY = send . WriteTTY
--
-- echo :: 'Eff' Teletype m => m ()
-- echo = readTTY >>= sendTTY
--
-- teletypeToIO :: 'Eff' ('Control.Effect.Embed' IO) m => 'Control.Effect.SimpleInterpreterFor' Teletype m
-- teletypeToIO = 'interpretSimple' $ \case
--   ReadTTY -> 'Control.Effect.embed' getLine
--   WriteTTY str -> 'Control.Effect.embed' $ putStrLn str
--
-- main :: IO ()
-- main = 'Control.Effect.runM' $ teletypeToIO $ echo
-- @
--
interpretSimple
  :: forall e m a p
   . ( RepresentationalEff e
     , Threaders '[ReaderThreads] m p
     , Carrier m
     )
  => EffHandler e m
  -> InterpretSimpleC e m a
  -> m a
interpretSimple :: EffHandler e m -> InterpretSimpleC e m a -> m a
interpretSimple EffHandler e m
h InterpretSimpleC e m a
m = InterpretSimpleC e m a -> ReifiedHandler e m -> m a
coerce InterpretSimpleC e m a
m (EffHandler e m -> ReifiedHandler e m
forall (e :: Effect) (m :: * -> *).
(forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ Derivs m, Prims z ~ Prims m,
  MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> ReifiedHandler e m
ReifiedHandler @e @m EffHandler e m
h)
{-# INLINE interpretSimple #-}

-- | Interpret an effect in terms of other effects by using
-- an explicit 'Handler' instance.
--
-- See 'Handler' for more information.
--
-- Unlike 'interpret', this does not have a higher-rank type,
-- making it easier to use partially applied, and unlike
-- 'interpretSimple' doesn't sacrifice performance.
--
-- @'Derivs' ('InterpretC' h e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretC' h e m) = 'Prims' m@
--
-- Example usage:
--
-- @
-- data Teletype :: Effect where
--   ReadTTY  :: Teletype m String
--   WriteTTY :: String -> Teletype m ()
--
-- readTTY :: 'Eff' Teletype m => m String
-- readTTY = send ReadTTY
--
-- writeTTY :: 'Eff' Teletype m => String -> m ()
-- writeTTY = send . WriteTTY
--
-- echo :: 'Eff' Teletype m => m ()
-- echo = readTTY >>= sendTTY
--
-- data TeletypeToIOH
--
-- instance 'Eff' ('Control.Effect.Embed' IO) m
--       => 'Handler' TeletypeToIOH Teletype m where
--   effHandler = \case
--     ReadTTY -> 'Control.Effect.embed' getLine
--     WriteTTY str -> 'Control.Effect.embed' $ putStrLn str
--
-- type TeletypeToIOC = 'InterpretC' TeletypeToIOH Teletype
--
-- teletypeToIO :: 'Eff' ('Control.Effect.Embed' IO) m => TeletypeToIOC m a -> m a
-- teletypeToIO = 'interpretViaHandler'
--
-- main :: IO ()
-- main = 'Control.Effect.runM' $ teletypeToIO $ echo
-- @
--
interpretViaHandler :: forall h e m a
                     . Handler h e m
                    => InterpretC h e m a
                    -> m a
interpretViaHandler :: InterpretC h e m a -> m a
interpretViaHandler = InterpretC h e m a -> m a
forall h (e :: Effect) (m :: * -> *) a. InterpretC h e m a -> m a
unInterpretC
{-# INLINE interpretViaHandler #-}

-- | Interpret an effect as a new primitive effect.
--
-- __Only interpret your own effects as primitives as a last resort.__
-- See 'EffPrimHandler'.
--
-- @'Derivs' ('InterpretPrimReifiedC' e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretPrimReifiedC' e m) = e ': 'Prims' m@
--
-- This has a higher-rank type, as it makes use of 'InterpretPrimReifiedC'.
-- __This makes 'interpretPrim' very difficult to use partially applied.__
-- __In particular, it can't be composed using @'.'@.__ You must use
-- paranthesis or '$'.
--
-- Consider using 'interpretPrimSimple' instead if performance is secondary.
interpretPrim :: forall e m a
               . (RepresentationalEff e, Carrier m)
              => EffPrimHandler e m
              -> InterpretPrimReifiedC e m a
              -> m a
interpretPrim :: EffPrimHandler e m -> InterpretPrimReifiedC e m a -> m a
interpretPrim EffPrimHandler e m
h InterpretPrimReifiedC e m a
m =
  let
    int :: ReifiedPrimHandler e m
    int :: ReifiedPrimHandler e m
int = (forall (z :: * -> *) x. Coercible z m => e z x -> m x)
-> ReifiedPrimHandler e m
forall (e :: Effect) (m :: * -> *).
(forall (z :: * -> *) x. Coercible z m => e z x -> m x)
-> ReifiedPrimHandler e m
ReifiedPrimHandler (e m x -> m x
EffPrimHandler e m
h (e m x -> m x) -> (e z x -> e m x) -> e z x -> m x
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# e z x -> e m x
coerce)
  in
    ReifiedPrimHandler e m
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedPrimHandler e m)) =>
    pr s -> m a)
-> m a
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify ReifiedPrimHandler e m
int ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (ReifiedPrimHandler e m)) =>
  pr s -> m a)
 -> m a)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedPrimHandler e m)) =>
    pr s -> m a)
-> m a
forall a b. (a -> b) -> a -> b
$
      \(pr s
_ :: p s) -> InterpretPrimC (ViaReifiedH s) e m a -> m a
forall h (e :: Effect) (m :: * -> *) a.
PrimHandler h e m =>
InterpretPrimC h e m a -> m a
interpretPrimViaHandler @(ViaReifiedH s) InterpretPrimC (ViaReifiedH s) e m a
InterpretPrimReifiedC e m a
m
{-# INLINE interpretPrim #-}

-- | Interpret an effect as a new primitive effect by using
-- an explicit 'PrimHandler' instance.
--
-- See 'PrimHandler' for more information.
--
-- __Only interpret your own effects as primitives as a last resort.__
-- See 'EffPrimHandler'.
---
-- @'Derivs' ('InterpretPrimC' h e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretPrimC' h e m) = e ': 'Prims' m@
--
-- Unlike 'interpretPrim', this does not have a higher-rank type,
-- making it easier to use partially applied, and unlike
-- 'interpretPrimSimple' doesn't sacrifice performance.
interpretPrimViaHandler
  :: forall h e m a
   . PrimHandler h e m
  => InterpretPrimC h e m a
  -> m a
interpretPrimViaHandler :: InterpretPrimC h e m a -> m a
interpretPrimViaHandler = InterpretPrimC h e m a -> m a
forall s (e :: Effect) (m :: * -> *) a.
InterpretPrimC s e m a -> m a
unInterpretPrimC
{-# INLINE interpretPrimViaHandler #-}

-- | A significantly slower variant of 'interpretPrim' that doesn't have
-- a higher-ranked type, making it much easier to use partially applied.
--
-- __Only interpret your own effects as primitives as a last resort.__
-- See 'EffPrimHandler'.
--
-- @'Derivs' ('InterpretPrimSimpleC' e m) = e ': 'Derivs' m@
--
-- @'Prims'  ('InterpretPrimSimpleC' e m) = e ': 'Prims' m@
--
-- Note the @ReaderThreads '[e]@ constraint, meaning
-- you need to define a @ThreadsEff e (ReaderT i)@ instance in order
-- to use 'interpretPrimSimple'.
interpretPrimSimple
  :: forall e m a p
   . ( RepresentationalEff e
     , Threaders '[ReaderThreads] m p
     , ReaderThreads '[e]
     , Carrier m
     )
  => EffPrimHandler e m
  -> InterpretPrimSimpleC e m a
  -> m a
interpretPrimSimple :: EffPrimHandler e m -> InterpretPrimSimpleC e m a -> m a
interpretPrimSimple EffPrimHandler e m
h InterpretPrimSimpleC e m a
m = InterpretPrimSimpleC e m a -> ReifiedPrimHandler e m -> m a
coerce InterpretPrimSimpleC e m a
m ((forall (z :: * -> *) x. Coercible z m => e z x -> m x)
-> ReifiedPrimHandler e m
forall (e :: Effect) (m :: * -> *).
(forall (z :: * -> *) x. Coercible z m => e z x -> m x)
-> ReifiedPrimHandler e m
ReifiedPrimHandler @e @m (e m x -> m x
EffPrimHandler e m
h (e m x -> m x) -> (e z x -> e m x) -> e z x -> m x
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# e z x -> e m x
coerce))
{-# INLINE interpretPrimSimple #-}

-- | Add a derived effect to a 'Reformulation'
-- by providing a handler for that effect.
--
-- The handler is an 'EffHandler', but with derived and primitive effects
-- determined by the transformed 'Reformulation'.
addDeriv :: ( RepresentationalEff e
            , Monad m
            )
         => (  forall z x
             . ( Carrier z
               , Derivs z ~ r
               , Prims z ~ p
               , MonadBase m z
               )
            => e (Effly z) x -> Effly z x
            )
         -> Reformulation r p m
         -> Reformulation (e ': r) p m
addDeriv :: (forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> Reformulation r p m -> Reformulation (e : r) p m
addDeriv !forall (z :: * -> *) x.
(Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
e (Effly z) x -> Effly z x
h !Reformulation r p m
reform = \ !forall x. m x -> z x
n !Algebra p z
alg ->
  let
    !handlerState :: HandlerCState p m z
handlerState = (forall x. m x -> z x) -> Algebra p z -> HandlerCState p m z
forall (p :: [Effect]) (m :: * -> *) (z :: * -> *).
(forall x. m x -> z x) -> Algebra p z -> HandlerCState p m z
HandlerCState forall x. m x -> z x
n Algebra p z
alg
  in
    HandlerCState p m z
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState p m z)) =>
    pr s -> Union (e : r) z x -> z x)
-> Union (e : r) z x
-> z x
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify HandlerCState p m z
handlerState ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (HandlerCState p m z)) =>
  pr s -> Union (e : r) z x -> z x)
 -> Union (e : r) z x -> z x)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (HandlerCState p m z)) =>
    pr s -> Union (e : r) z x -> z x)
-> Union (e : r) z x
-> z x
forall a b. (a -> b) -> a -> b
$ \(pr s
_ :: pr sHandler) ->
    ReifiedReformulation r p m
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedReformulation r p m)) =>
    pr s -> Union (e : r) z x -> z x)
-> Union (e : r) z x
-> z x
forall a r.
a
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s a) =>
    pr s -> r)
-> r
reify (Reformulation r p m -> ReifiedReformulation r p m
forall (r :: [Effect]) (p :: [Effect]) (m :: * -> *).
Reformulation r p m -> ReifiedReformulation r p m
ReifiedReformulation Reformulation r p m
reform) ((forall s (pr :: * -> *).
  (pr ~ Proxy, Reifies s (ReifiedReformulation r p m)) =>
  pr s -> Union (e : r) z x -> z x)
 -> Union (e : r) z x -> z x)
-> (forall s (pr :: * -> *).
    (pr ~ Proxy, Reifies s (ReifiedReformulation r p m)) =>
    pr s -> Union (e : r) z x -> z x)
-> Union (e : r) z x
-> z x
forall a b. (a -> b) -> a -> b
$ \(_ :: pr sReform) ->
      Algebra' r z x -> (e z x -> z x) -> Union (e : r) z x -> z x
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg ((forall x. m x -> z x) -> Algebra p z -> Algebra r z
Reformulation r p m
reform forall x. m x -> z x
n Algebra p z
alg) ((e z x -> z x) -> Union (e : r) z x -> z x)
-> (e z x -> z x) -> Union (e : r) z x -> z x
forall a b. (a -> b) -> a -> b
$ \e z x
e ->
        forall (r :: [Effect]) (p :: [Effect]) (m :: * -> *) (z :: * -> *)
       a.
HandlerC s s r p m z a -> z a
forall sHandler sReform (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
HandlerC sHandler sReform r p m z a -> z a
unHandlerC @sHandler @sReform (HandlerC s s r p m z x -> z x) -> HandlerC s s r p m z x -> z x
forall a b. (a -> b) -> a -> b
$ Effly (HandlerC s s r p m z) x -> HandlerC s s r p m z x
forall k (m :: k -> *) (a :: k). Effly m a -> m a
runEffly (Effly (HandlerC s s r p m z) x -> HandlerC s s r p m z x)
-> Effly (HandlerC s s r p m z) x -> HandlerC s s r p m z x
forall a b. (a -> b) -> a -> b
$ e (Effly (HandlerC s s r p m z)) x
-> Effly (HandlerC s s r p m z) x
forall (z :: * -> *) x.
(Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
e (Effly z) x -> Effly z x
h (e z x -> e (Effly (HandlerC s s r p m z)) x
coerce e z x
e)
{-# INLINE addDeriv #-}



newtype ReinterpretC h e new m a = ReinterpretC {
    ReinterpretC h e new m a -> IntroUnderC e new (InterpretC h e m) a
unReinterpretC :: IntroUnderC e new (InterpretC h e m) a
  }
  deriving ( a -> ReinterpretC h e new m b -> ReinterpretC h e new m a
(a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b
(forall a b.
 (a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b)
-> (forall a b.
    a -> ReinterpretC h e new m b -> ReinterpretC h e new m a)
-> Functor (ReinterpretC h e new m)
forall a b.
a -> ReinterpretC h e new m b -> ReinterpretC h e new m a
forall a b.
(a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
a -> ReinterpretC h e new m b -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ReinterpretC h e new m b -> ReinterpretC h e new m a
$c<$ :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
a -> ReinterpretC h e new m b -> ReinterpretC h e new m a
fmap :: (a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b
$cfmap :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReinterpretC h e new m a -> ReinterpretC h e new m b
Functor, Functor (ReinterpretC h e new m)
a -> ReinterpretC h e new m a
Functor (ReinterpretC h e new m)
-> (forall a. a -> ReinterpretC h e new m a)
-> (forall a b.
    ReinterpretC h e new m (a -> b)
    -> ReinterpretC h e new m a -> ReinterpretC h e new m b)
-> (forall a b c.
    (a -> b -> c)
    -> ReinterpretC h e new m a
    -> ReinterpretC h e new m b
    -> ReinterpretC h e new m c)
-> (forall a b.
    ReinterpretC h e new m a
    -> ReinterpretC h e new m b -> ReinterpretC h e new m b)
-> (forall a b.
    ReinterpretC h e new m a
    -> ReinterpretC h e new m b -> ReinterpretC h e new m a)
-> Applicative (ReinterpretC h e new m)
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m a
ReinterpretC h e new m (a -> b)
-> ReinterpretC h e new m a -> ReinterpretC h e new m b
(a -> b -> c)
-> ReinterpretC h e new m a
-> ReinterpretC h e new m b
-> ReinterpretC h e new m c
forall a. a -> ReinterpretC h e new m a
forall a b.
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m a
forall a b.
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
forall a b.
ReinterpretC h e new m (a -> b)
-> ReinterpretC h e new m a -> ReinterpretC h e new m b
forall a b c.
(a -> b -> c)
-> ReinterpretC h e new m a
-> ReinterpretC h e new m b
-> ReinterpretC h e new m c
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Applicative m =>
Functor (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Applicative m =>
a -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m (a -> b)
-> ReinterpretC h e new m a -> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReinterpretC h e new m a
-> ReinterpretC h e new m b
-> ReinterpretC h e new m 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
<* :: ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m a
$c<* :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m a
*> :: ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
$c*> :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
liftA2 :: (a -> b -> c)
-> ReinterpretC h e new m a
-> ReinterpretC h e new m b
-> ReinterpretC h e new m c
$cliftA2 :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReinterpretC h e new m a
-> ReinterpretC h e new m b
-> ReinterpretC h e new m c
<*> :: ReinterpretC h e new m (a -> b)
-> ReinterpretC h e new m a -> ReinterpretC h e new m b
$c<*> :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretC h e new m (a -> b)
-> ReinterpretC h e new m a -> ReinterpretC h e new m b
pure :: a -> ReinterpretC h e new m a
$cpure :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Applicative m =>
a -> ReinterpretC h e new m a
$cp1Applicative :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Applicative m =>
Functor (ReinterpretC h e new m)
Applicative, Applicative (ReinterpretC h e new m)
a -> ReinterpretC h e new m a
Applicative (ReinterpretC h e new m)
-> (forall a b.
    ReinterpretC h e new m a
    -> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m b)
-> (forall a b.
    ReinterpretC h e new m a
    -> ReinterpretC h e new m b -> ReinterpretC h e new m b)
-> (forall a. a -> ReinterpretC h e new m a)
-> Monad (ReinterpretC h e new m)
ReinterpretC h e new m a
-> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m b
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
forall a. a -> ReinterpretC h e new m a
forall a b.
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
forall a b.
ReinterpretC h e new m a
-> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Monad m =>
Applicative (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
a -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretC h e new m a
-> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m 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 -> ReinterpretC h e new m a
$creturn :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
a -> ReinterpretC h e new m a
>> :: ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
$c>> :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m b -> ReinterpretC h e new m b
>>= :: ReinterpretC h e new m a
-> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m b
$c>>= :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretC h e new m a
-> (a -> ReinterpretC h e new m b) -> ReinterpretC h e new m b
$cp1Monad :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Monad m =>
Applicative (ReinterpretC h e new m)
Monad
           , Applicative (ReinterpretC h e new m)
ReinterpretC h e new m a
Applicative (ReinterpretC h e new m)
-> (forall a. ReinterpretC h e new m a)
-> (forall a.
    ReinterpretC h e new m a
    -> ReinterpretC h e new m a -> ReinterpretC h e new m a)
-> (forall a.
    ReinterpretC h e new m a -> ReinterpretC h e new m [a])
-> (forall a.
    ReinterpretC h e new m a -> ReinterpretC h e new m [a])
-> Alternative (ReinterpretC h e new m)
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
ReinterpretC h e new m a -> ReinterpretC h e new m [a]
ReinterpretC h e new m a -> ReinterpretC h e new m [a]
forall a. ReinterpretC h e new m a
forall a. ReinterpretC h e new m a -> ReinterpretC h e new m [a]
forall a.
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Alternative m =>
Applicative (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a -> ReinterpretC h e new m [a]
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
many :: ReinterpretC h e new m a -> ReinterpretC h e new m [a]
$cmany :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a -> ReinterpretC h e new m [a]
some :: ReinterpretC h e new m a -> ReinterpretC h e new m [a]
$csome :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a -> ReinterpretC h e new m [a]
<|> :: ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
$c<|> :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
empty :: ReinterpretC h e new m a
$cempty :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretC h e new m a
$cp1Alternative :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
Alternative m =>
Applicative (ReinterpretC h e new m)
Alternative, Monad (ReinterpretC h e new m)
Alternative (ReinterpretC h e new m)
ReinterpretC h e new m a
Alternative (ReinterpretC h e new m)
-> Monad (ReinterpretC h e new m)
-> (forall a. ReinterpretC h e new m a)
-> (forall a.
    ReinterpretC h e new m a
    -> ReinterpretC h e new m a -> ReinterpretC h e new m a)
-> MonadPlus (ReinterpretC h e new m)
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
forall a. ReinterpretC h e new m a
forall a.
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Monad (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Alternative (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
$cmplus :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretC h e new m a
-> ReinterpretC h e new m a -> ReinterpretC h e new m a
mzero :: ReinterpretC h e new m a
$cmzero :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretC h e new m a
$cp2MonadPlus :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Monad (ReinterpretC h e new m)
$cp1MonadPlus :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Alternative (ReinterpretC h e new m)
MonadPlus
           , Monad (ReinterpretC h e new m)
Monad (ReinterpretC h e new m)
-> (forall a.
    (a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a)
-> MonadFix (ReinterpretC h e new m)
(a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall a.
(a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFix m =>
Monad (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFix m =>
(a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
$cmfix :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFix m =>
(a -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
$cp1MonadFix :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFix m =>
Monad (ReinterpretC h e new m)
MonadFix, Monad (ReinterpretC h e new m)
Monad (ReinterpretC h e new m)
-> (forall a. String -> ReinterpretC h e new m a)
-> MonadFail (ReinterpretC h e new m)
String -> ReinterpretC h e new m a
forall a. String -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFail m =>
Monad (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFail m =>
String -> ReinterpretC h e new m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: String -> ReinterpretC h e new m a
$cfail :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFail m =>
String -> ReinterpretC h e new m a
$cp1MonadFail :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFail m =>
Monad (ReinterpretC h e new m)
MonadFail, Monad (ReinterpretC h e new m)
Monad (ReinterpretC h e new m)
-> (forall a. IO a -> ReinterpretC h e new m a)
-> MonadIO (ReinterpretC h e new m)
IO a -> ReinterpretC h e new m a
forall a. IO a -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadIO m =>
Monad (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadIO m =>
IO a -> ReinterpretC h e new m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> ReinterpretC h e new m a
$cliftIO :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadIO m =>
IO a -> ReinterpretC h e new m a
$cp1MonadIO :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadIO m =>
Monad (ReinterpretC h e new m)
MonadIO
           , Monad (ReinterpretC h e new m)
e -> ReinterpretC h e new m a
Monad (ReinterpretC h e new m)
-> (forall e a. Exception e => e -> ReinterpretC h e new m a)
-> MonadThrow (ReinterpretC h e new m)
forall e a. Exception e => e -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadThrow m =>
Monad (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReinterpretC h e new m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> ReinterpretC h e new m a
$cthrowM :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReinterpretC h e new m a
$cp1MonadThrow :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadThrow m =>
Monad (ReinterpretC h e new m)
MonadThrow, MonadThrow (ReinterpretC h e new m)
MonadThrow (ReinterpretC h e new m)
-> (forall e a.
    Exception e =>
    ReinterpretC h e new m a
    -> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a)
-> MonadCatch (ReinterpretC h e new m)
ReinterpretC h e new m a
-> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall e a.
Exception e =>
ReinterpretC h e new m a
-> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadCatch m =>
MonadThrow (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReinterpretC h e new m a
-> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: ReinterpretC h e new m a
-> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
$ccatch :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReinterpretC h e new m a
-> (e -> ReinterpretC h e new m a) -> ReinterpretC h e new m a
$cp1MonadCatch :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadCatch m =>
MonadThrow (ReinterpretC h e new m)
MonadCatch, MonadCatch (ReinterpretC h e new m)
MonadCatch (ReinterpretC h e new m)
-> (forall b.
    ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
     -> ReinterpretC h e new m b)
    -> ReinterpretC h e new m b)
-> (forall b.
    ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
     -> ReinterpretC h e new m b)
    -> ReinterpretC h e new m b)
-> (forall a b c.
    ReinterpretC h e new m a
    -> (a -> ExitCase b -> ReinterpretC h e new m c)
    -> (a -> ReinterpretC h e new m b)
    -> ReinterpretC h e new m (b, c))
-> MonadMask (ReinterpretC h e new m)
ReinterpretC h e new m a
-> (a -> ExitCase b -> ReinterpretC h e new m c)
-> (a -> ReinterpretC h e new m b)
-> ReinterpretC h e new m (b, c)
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
forall b.
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
forall a b c.
ReinterpretC h e new m a
-> (a -> ExitCase b -> ReinterpretC h e new m c)
-> (a -> ReinterpretC h e new m b)
-> ReinterpretC h e new m (b, c)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadMask m =>
MonadCatch (ReinterpretC h e new m)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
MonadMask m =>
ReinterpretC h e new m a
-> (a -> ExitCase b -> ReinterpretC h e new m c)
-> (a -> ReinterpretC h e new m b)
-> ReinterpretC h e new m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: ReinterpretC h e new m a
-> (a -> ExitCase b -> ReinterpretC h e new m c)
-> (a -> ReinterpretC h e new m b)
-> ReinterpretC h e new m (b, c)
$cgeneralBracket :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
MonadMask m =>
ReinterpretC h e new m a
-> (a -> ExitCase b -> ReinterpretC h e new m c)
-> (a -> ReinterpretC h e new m b)
-> ReinterpretC h e new m (b, c)
uninterruptibleMask :: ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
$cuninterruptibleMask :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
mask :: ((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
$cmask :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a. ReinterpretC h e new m a -> ReinterpretC h e new m a)
 -> ReinterpretC h e new m b)
-> ReinterpretC h e new m b
$cp1MonadMask :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadMask m =>
MonadCatch (ReinterpretC h e new m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
  deriving (m a -> ReinterpretC h e new m a
(forall (m :: * -> *) a.
 Monad m =>
 m a -> ReinterpretC h e new m a)
-> MonadTrans (ReinterpretC h e new)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
m a -> ReinterpretC h e new m a
forall (m :: * -> *) a. Monad m => m a -> ReinterpretC h e new m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> ReinterpretC h e new m a
$clift :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
m a -> ReinterpretC h e new m a
MonadTrans, MonadTrans (ReinterpretC h e new)
m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a
MonadTrans (ReinterpretC h e new)
-> (forall (m :: * -> *) a.
    Monad m =>
    (Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a)
-> MonadTransControl (ReinterpretC h e new)
(Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]).
MonadTrans (ReinterpretC h e new)
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
(Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a
forall (m :: * -> *) a.
Monad m =>
m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a
forall (m :: * -> *) a.
Monad m =>
(Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a
forall (t :: Effect).
MonadTrans t
-> (forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a
$crestoreT :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
m (StT (ReinterpretC h e new) a) -> ReinterpretC h e new m a
liftWith :: (Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a
$cliftWith :: forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
(Run (ReinterpretC h e new) -> m a) -> ReinterpretC h e new m a
$cp1MonadTransControl :: forall h (e :: Effect) (new :: [Effect]).
MonadTrans (ReinterpretC h e new)
MonadTransControl) via IdentityT

deriving
  via
    IntroUnderC e new (InterpretC h e m)
  instance
       ( Handler h e m
       , Carrier m
       , KnownList new
       , IntroConsistent '[] new m
       )
    => Carrier (ReinterpretC h e new m)

type ReifiesHandler s e m = Reifies s (ReifiedHandler e m)
type ReifiesPrimHandler s e m = Reifies s (ReifiedPrimHandler e m)

type ReinterpretReifiedC e new m a =
     forall s
   . ReifiesHandler s e m
  => ReinterpretC (ViaReifiedH s) e new m a

-- | Reinterpret an effect in terms of newly introduced effects.
--
-- This combines 'interpret' and 'introUnder' in order to introduce the effects
-- @new@ under @e@, which you then may make use of inside the handler for @e@.
--
-- @'Derivs' ('ReinterpretReifiedC' e new m) = e ': 'StripPrefix' new ('Derivs' m)@
--
-- @'Prims'  ('ReinterpretReifiedC' e new m) = 'Prims' m@
--
-- This has a higher-rank type, as it makes use of 'ReinterpretReifiedC'.
-- __This makes 'reinterpret' very difficult to use partially applied.__
-- __In particular, it can't be composed using @'.'@.__ You must use
-- paranthesis or '$'.
--
-- Consider using 'reinterpretSimple' instead if performance is secondary.
reinterpret :: forall e new m a
             . ( RepresentationalEff e
               , KnownList new
               , HeadEffs new m
               )
            => EffHandler e m
            -> ReinterpretReifiedC e new m a
            -> m a
reinterpret :: EffHandler e m -> ReinterpretReifiedC e new m a -> m a
reinterpret EffHandler e m
h ReinterpretReifiedC e new m a
main = EffHandler e m -> InterpretReifiedC e m a -> m a
forall (e :: Effect) (m :: * -> *) a.
(RepresentationalEff e, Carrier m) =>
EffHandler e m -> InterpretReifiedC e m a -> m a
interpret EffHandler e m
h (InterpretReifiedC e m a -> m a) -> InterpretReifiedC e m a -> m a
forall a b. (a -> b) -> a -> b
$ IntroUnderC e new (InterpretC (ViaReifiedH s) e m) a
-> InterpretC (ViaReifiedH s) e m a
forall (new :: [Effect]) (e :: Effect) (m :: * -> *) a.
(KnownList new, IntroConsistent '[e] new m) =>
IntroUnderC e new m a -> m a
introUnder (ReinterpretC (ViaReifiedH s) e new m a
-> IntroUnderC e new (InterpretC (ViaReifiedH s) e m) a
forall h (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
ReinterpretC h e new m a -> IntroUnderC e new (InterpretC h e m) a
unReinterpretC ReinterpretC (ViaReifiedH s) e new m a
ReinterpretReifiedC e new m a
main)
{-# INLINE reinterpret #-}

-- | Reinterpret an effect in terms of newly introduced effects by using
-- an explicit 'Handler' instance.
--
-- See 'Handler' for more information.
--
-- This combines 'interpretViaHandler' and 'introUnder' in order to introduce
-- the effects @new@ under @e@, which you then may make use of inside the handler
-- for @e@.
--
-- @'Derivs' ('ReinterpretC' h e new m) = e ': 'StripPrefix' new ('Derivs' m)@
--
-- @'Prims'  ('ReinterpretC' h e new m) = 'Prims' m@
--
-- Unlike 'reinterpret', this does not have a higher-rank type,
-- making it easier to use partially applied, and unlike
-- 'reinterpretSimple' doesn't sacrifice performance.
reinterpretViaHandler :: forall h e new m a
                       . ( Handler h e m
                         , KnownList new
                         , HeadEffs new m
                         )
                      => ReinterpretC h e new m a
                      -> m a
reinterpretViaHandler :: ReinterpretC h e new m a -> m a
reinterpretViaHandler = ReinterpretC h e new m a -> m a
coerce
{-# INLINE reinterpretViaHandler #-}

newtype ReinterpretSimpleC e new m a = ReinterpretSimpleC {
    ReinterpretSimpleC e new m a
-> IntroUnderC e new (InterpretSimpleC e m) a
unReinterpretSimpleC :: IntroUnderC e new (InterpretSimpleC e m) a
  }
  deriving ( a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
(a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
(forall a b.
 (a -> b)
 -> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b)
-> (forall a b.
    a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a)
-> Functor (ReinterpretSimpleC e new m)
forall a b.
a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
forall a b.
(a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
(a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
<$ :: a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
$c<$ :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
a -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
fmap :: (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
$cfmap :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Functor m =>
(a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
Functor, Functor (ReinterpretSimpleC e new m)
a -> ReinterpretSimpleC e new m a
Functor (ReinterpretSimpleC e new m)
-> (forall a. a -> ReinterpretSimpleC e new m a)
-> (forall a b.
    ReinterpretSimpleC e new m (a -> b)
    -> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b)
-> (forall a b c.
    (a -> b -> c)
    -> ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m b
    -> ReinterpretSimpleC e new m c)
-> (forall a b.
    ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b)
-> (forall a b.
    ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a)
-> Applicative (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
ReinterpretSimpleC e new m (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
(a -> b -> c)
-> ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b
-> ReinterpretSimpleC e new m c
forall a. a -> ReinterpretSimpleC e new m a
forall a b.
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
forall a b.
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
forall a b.
ReinterpretSimpleC e new m (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
forall a b c.
(a -> b -> c)
-> ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b
-> ReinterpretSimpleC e new m 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
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Applicative m =>
Functor (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Applicative m =>
a -> ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b
-> ReinterpretSimpleC e new m c
<* :: ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
$c<* :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m a
*> :: ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
$c*> :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
liftA2 :: (a -> b -> c)
-> ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b
-> ReinterpretSimpleC e new m c
$cliftA2 :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b
-> ReinterpretSimpleC e new m c
<*> :: ReinterpretSimpleC e new m (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
$c<*> :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Applicative m =>
ReinterpretSimpleC e new m (a -> b)
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m b
pure :: a -> ReinterpretSimpleC e new m a
$cpure :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Applicative m =>
a -> ReinterpretSimpleC e new m a
$cp1Applicative :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Applicative m =>
Functor (ReinterpretSimpleC e new m)
Applicative, Applicative (ReinterpretSimpleC e new m)
a -> ReinterpretSimpleC e new m a
Applicative (ReinterpretSimpleC e new m)
-> (forall a b.
    ReinterpretSimpleC e new m a
    -> (a -> ReinterpretSimpleC e new m b)
    -> ReinterpretSimpleC e new m b)
-> (forall a b.
    ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b)
-> (forall a. a -> ReinterpretSimpleC e new m a)
-> Monad (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
forall a. a -> ReinterpretSimpleC e new m a
forall a b.
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
forall a b.
ReinterpretSimpleC e new m a
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m 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
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Monad m =>
Applicative (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
a -> ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretSimpleC e new m a
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
return :: a -> ReinterpretSimpleC e new m a
$creturn :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Monad m =>
a -> ReinterpretSimpleC e new m a
>> :: ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
$c>> :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m b -> ReinterpretSimpleC e new m b
>>= :: ReinterpretSimpleC e new m a
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
$c>>= :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b.
Monad m =>
ReinterpretSimpleC e new m a
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
$cp1Monad :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Monad m =>
Applicative (ReinterpretSimpleC e new m)
Monad
           , Applicative (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
Applicative (ReinterpretSimpleC e new m)
-> (forall a. ReinterpretSimpleC e new m a)
-> (forall a.
    ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
-> (forall a.
    ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a])
-> (forall a.
    ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a])
-> Alternative (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
forall a. ReinterpretSimpleC e new m a
forall a.
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
forall a.
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Alternative m =>
Applicative (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
many :: ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
$cmany :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
some :: ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
$csome :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m [a]
<|> :: ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
$c<|> :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
empty :: ReinterpretSimpleC e new m a
$cempty :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
Alternative m =>
ReinterpretSimpleC e new m a
$cp1Alternative :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
Alternative m =>
Applicative (ReinterpretSimpleC e new m)
Alternative, Monad (ReinterpretSimpleC e new m)
Alternative (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
Alternative (ReinterpretSimpleC e new m)
-> Monad (ReinterpretSimpleC e new m)
-> (forall a. ReinterpretSimpleC e new m a)
-> (forall a.
    ReinterpretSimpleC e new m a
    -> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
-> MonadPlus (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
forall a. ReinterpretSimpleC e new m a
forall a.
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Monad (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Alternative (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretSimpleC e new m a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
mplus :: ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
$cmplus :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretSimpleC e new m a
-> ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a
mzero :: ReinterpretSimpleC e new m a
$cmzero :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadPlus m =>
ReinterpretSimpleC e new m a
$cp2MonadPlus :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Monad (ReinterpretSimpleC e new m)
$cp1MonadPlus :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadPlus m =>
Alternative (ReinterpretSimpleC e new m)
MonadPlus
           , Monad (ReinterpretSimpleC e new m)
Monad (ReinterpretSimpleC e new m)
-> (forall a.
    (a -> ReinterpretSimpleC e new m a)
    -> ReinterpretSimpleC e new m a)
-> MonadFix (ReinterpretSimpleC e new m)
(a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a
forall a.
(a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFix m =>
Monad (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFix m =>
(a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a
mfix :: (a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a
$cmfix :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFix m =>
(a -> ReinterpretSimpleC e new m a) -> ReinterpretSimpleC e new m a
$cp1MonadFix :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFix m =>
Monad (ReinterpretSimpleC e new m)
MonadFix, Monad (ReinterpretSimpleC e new m)
Monad (ReinterpretSimpleC e new m)
-> (forall a. String -> ReinterpretSimpleC e new m a)
-> MonadFail (ReinterpretSimpleC e new m)
String -> ReinterpretSimpleC e new m a
forall a. String -> ReinterpretSimpleC e new m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFail m =>
Monad (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFail m =>
String -> ReinterpretSimpleC e new m a
fail :: String -> ReinterpretSimpleC e new m a
$cfail :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadFail m =>
String -> ReinterpretSimpleC e new m a
$cp1MonadFail :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadFail m =>
Monad (ReinterpretSimpleC e new m)
MonadFail, Monad (ReinterpretSimpleC e new m)
Monad (ReinterpretSimpleC e new m)
-> (forall a. IO a -> ReinterpretSimpleC e new m a)
-> MonadIO (ReinterpretSimpleC e new m)
IO a -> ReinterpretSimpleC e new m a
forall a. IO a -> ReinterpretSimpleC e new m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadIO m =>
Monad (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadIO m =>
IO a -> ReinterpretSimpleC e new m a
liftIO :: IO a -> ReinterpretSimpleC e new m a
$cliftIO :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
MonadIO m =>
IO a -> ReinterpretSimpleC e new m a
$cp1MonadIO :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadIO m =>
Monad (ReinterpretSimpleC e new m)
MonadIO
           , Monad (ReinterpretSimpleC e new m)
e -> ReinterpretSimpleC e new m a
Monad (ReinterpretSimpleC e new m)
-> (forall e a. Exception e => e -> ReinterpretSimpleC e new m a)
-> MonadThrow (ReinterpretSimpleC e new m)
forall e a. Exception e => e -> ReinterpretSimpleC e new m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadThrow m =>
Monad (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReinterpretSimpleC e new m a
throwM :: e -> ReinterpretSimpleC e new m a
$cthrowM :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReinterpretSimpleC e new m a
$cp1MonadThrow :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadThrow m =>
Monad (ReinterpretSimpleC e new m)
MonadThrow, MonadThrow (ReinterpretSimpleC e new m)
MonadThrow (ReinterpretSimpleC e new m)
-> (forall e a.
    Exception e =>
    ReinterpretSimpleC e new m a
    -> (e -> ReinterpretSimpleC e new m a)
    -> ReinterpretSimpleC e new m a)
-> MonadCatch (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> (e -> ReinterpretSimpleC e new m a)
-> ReinterpretSimpleC e new m a
forall e a.
Exception e =>
ReinterpretSimpleC e new m a
-> (e -> ReinterpretSimpleC e new m a)
-> ReinterpretSimpleC e new m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadCatch m =>
MonadThrow (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReinterpretSimpleC e new m a
-> (e -> ReinterpretSimpleC e new m a)
-> ReinterpretSimpleC e new m a
catch :: ReinterpretSimpleC e new m a
-> (e -> ReinterpretSimpleC e new m a)
-> ReinterpretSimpleC e new m a
$ccatch :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReinterpretSimpleC e new m a
-> (e -> ReinterpretSimpleC e new m a)
-> ReinterpretSimpleC e new m a
$cp1MonadCatch :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadCatch m =>
MonadThrow (ReinterpretSimpleC e new m)
MonadCatch, MonadCatch (ReinterpretSimpleC e new m)
MonadCatch (ReinterpretSimpleC e new m)
-> (forall b.
    ((forall a.
      ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
     -> ReinterpretSimpleC e new m b)
    -> ReinterpretSimpleC e new m b)
-> (forall b.
    ((forall a.
      ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
     -> ReinterpretSimpleC e new m b)
    -> ReinterpretSimpleC e new m b)
-> (forall a b c.
    ReinterpretSimpleC e new m a
    -> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
    -> (a -> ReinterpretSimpleC e new m b)
    -> ReinterpretSimpleC e new m (b, c))
-> MonadMask (ReinterpretSimpleC e new m)
ReinterpretSimpleC e new m a
-> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m (b, c)
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
forall b.
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
forall a b c.
ReinterpretSimpleC e new m a
-> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadMask m =>
MonadCatch (ReinterpretSimpleC e new m)
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
MonadMask m =>
ReinterpretSimpleC e new m a
-> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m (b, c)
generalBracket :: ReinterpretSimpleC e new m a
-> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m (b, c)
$cgeneralBracket :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a b c.
MonadMask m =>
ReinterpretSimpleC e new m a
-> (a -> ExitCase b -> ReinterpretSimpleC e new m c)
-> (a -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m (b, c)
uninterruptibleMask :: ((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
$cuninterruptibleMask :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
mask :: ((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
$cmask :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *) b.
MonadMask m =>
((forall a.
  ReinterpretSimpleC e new m a -> ReinterpretSimpleC e new m a)
 -> ReinterpretSimpleC e new m b)
-> ReinterpretSimpleC e new m b
$cp1MonadMask :: forall (e :: Effect) (new :: [Effect]) (m :: * -> *).
MonadMask m =>
MonadCatch (ReinterpretSimpleC e new m)
MonadMask
           , MonadBase b, MonadBaseControl b
           )
  deriving m a -> ReinterpretSimpleC e new m a
(forall (m :: * -> *) a.
 Monad m =>
 m a -> ReinterpretSimpleC e new m a)
-> MonadTrans (ReinterpretSimpleC e new)
forall (new :: [Effect]) (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> ReinterpretSimpleC e new m a
forall (m :: * -> *) a.
Monad m =>
m a -> ReinterpretSimpleC e new m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> ReinterpretSimpleC e new m a
$clift :: forall (new :: [Effect]) (e :: Effect) (m :: * -> *) a.
Monad m =>
m a -> ReinterpretSimpleC e new m a
MonadTrans via InterpretSimpleC e

deriving via IntroUnderC e new (InterpretSimpleC e m)
    instance ( Threads (ReaderT (ReifiedHandler e m)) (Prims m)
             , RepresentationalEff e
             , KnownList new
             , HeadEffs new m
             , Carrier m
             )
          => Carrier (ReinterpretSimpleC e new m)

-- | Reinterpret an effect in terms of newly introduced effects.
--
-- This combines 'interpretSimple' and 'introUnder' in order to introduce
-- the effects @new@ under @e@, which you then may make use of inside the
-- handler for @e@.
--
-- @'Derivs' ('ReinterpretSimpleC' e new m) = e ': 'StripPrefix' new ('Derivs' m)@
--
-- @'Prims'  ('ReinterpretSimpleC' e new m) = 'Prims' m@
--
-- This is a significantly slower variant of 'reinterpret' that doesn't have
-- a higher-ranked type, making it much easier to use partially applied.
reinterpretSimple :: forall e new m a p
                   . ( RepresentationalEff e
                     , KnownList new
                     , HeadEffs new m
                     , Threaders '[ReaderThreads] m p
                     )
                  => EffHandler e m
                  -> ReinterpretSimpleC e new m a
                  -> m a
reinterpretSimple :: EffHandler e m -> ReinterpretSimpleC e new m a -> m a
reinterpretSimple EffHandler e m
h =
     EffHandler e m -> InterpretSimpleC e m a -> m a
forall (e :: Effect) (m :: * -> *) a (p :: [Effect]).
(RepresentationalEff e, Threaders '[ReaderThreads] m p,
 Carrier m) =>
EffHandler e m -> InterpretSimpleC e m a -> m a
interpretSimple EffHandler e m
h
  (InterpretSimpleC e m a -> m a)
-> (IntroUnderC e new (InterpretSimpleC e m) a
    -> InterpretSimpleC e m a)
-> IntroUnderC e new (InterpretSimpleC e m) a
-> m a
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# IntroUnderC e new (InterpretSimpleC e m) a
-> InterpretSimpleC e m a
forall (new :: [Effect]) (e :: Effect) (m :: * -> *) a.
(KnownList new, IntroConsistent '[e] new m) =>
IntroUnderC e new m a -> m a
introUnder
  (IntroUnderC e new (InterpretSimpleC e m) a -> m a)
-> (ReinterpretSimpleC e new m a
    -> IntroUnderC e new (InterpretSimpleC e m) a)
-> ReinterpretSimpleC e new m a
-> m a
forall b a c. Coercible b a => (b -> c) -> (a -> b) -> a -> c
.# ReinterpretSimpleC e new m a
-> IntroUnderC e new (InterpretSimpleC e m) a
forall (e :: Effect) (new :: [Effect]) (m :: * -> *) a.
ReinterpretSimpleC e new m a
-> IntroUnderC e new (InterpretSimpleC e m) a
unReinterpretSimpleC
{-# INLINE reinterpretSimple #-}