in-other-words-0.1.0.0: A higher-order effect system where the sky's the limit

Control.Effect.Intercept

Synopsis

# Effects

data Intercept (e :: Effect) :: Effect where Source #

An effect for intercepting actions of a first-order effect.

Even for this library, proper usage of this effect is very complicated. When properly used, this can be a very useful helper effect, allowing you write interpretations for a class of higher-order effects that wouldn't otherwise be possible.

Constructors

 Intercept :: Coercible z m => (forall x. e z x -> m x) -> m a -> Intercept e m a

#### Instances

Instances details
 (FirstOrder e, Eff (Unravel (InterceptB e)) m) => Handler InterceptH (Intercept e) m Source # Instance detailsDefined in Control.Effect.Internal.Intercept Methods

data InterceptCont (e :: Effect) :: Effect where Source #

A variant of InterceptCont that is significantly more powerful, allowing you to capture the continuation of the program at each use-site of an effect, as well as aborting execution of the parameter computation early.

Constructors

 InterceptCont :: Coercible z m => InterceptionMode -> (forall x. (x -> m a) -> e z x -> m a) -> m a -> InterceptCont e m a

#### Instances

Instances details
 (FirstOrder e, Member e (Derivs m), Eff (Unravel (InterceptB e)) m) => Handler InterceptH (InterceptCont e) m Source # Instance detailsDefined in Control.Effect.Internal.Intercept Methods

Constructors

 InterceptOne InterceptAll

# Actions

intercept :: Eff (Intercept e) m => (forall x. e m x -> m x) -> m a -> m a Source #

Intercept all uses of an effect within a region.

interceptCont :: Eff (InterceptCont e) m => (forall x. (x -> m a) -> e m x -> m a) -> m a -> m a Source #

Intercept all uses of an effect within a region -- and at each use-site, capture the continuation of the argument computation, and also allow for early abortion (by not invoking the continuation).

interceptCont1 :: Eff (InterceptCont e) m => (forall x. (x -> m a) -> e m x -> m a) -> m a -> m a Source #

Intercept only the first use of an effect within a region -- and at that use-site, capture the continuation of the argument computation, and also allow for early abortion (by not invoking the continuation).

# Interpretations

runInterceptCont :: forall e m a p. (FirstOrder e, Carrier m, Member e (Derivs m), Threaders '[SteppedThreads] m p) => InterceptContC e m a -> m a Source #

Run Intercept e, InterceptCont e and e effects, provided that e is first-order and also part of the remaining effect stack.

There are three very important things to note here:

• e must be first-order.
• Any action of e made by a handler run after runInterceptCont won't get be intercepted. What this means is that you typically want to run the handler for e immediately after runInterceptCont.
• This imposes the very restrictive primitive effect Unravel. Most notably, neither StateThreads nor WriterThreads accepts it. Because of that, this module offers various alternatives of several common State and Tell interpreters with threading constraints that do accept Unravel.
Derivs (InterceptContC e m) = InterceptCont e ': Intercept e ': e ': Derivs m
Prims  (InterceptContC e m) = Unravel (InterceptB e) ': Prims m

runInterceptR :: forall e m a p. (FirstOrder e, Member e (Derivs m), Carrier m, Threaders '[ReaderThreads] m p) => InterceptRC e m a -> m a Source #

Run Intercept e and e effects, provided e is first-order and part of the effect stack.

runInterceptR differs from runInterceptCont in four different ways:

• It doesn't handle InterceptCont.
• It has the significantly less restrictive threading constraint ReaderThreads instead of SteppedThreads
• It imposes the significantly more restrictive primitive effect Unlift instead of Unravel.
• It is significantly faster.

There are some interpreters -- such as bracketToIO and concToIO -- that runInterceptCont can't be used together with in any capacity due to its SteppedThreads threading constraint. In these cases, runInterceptR can be used instead.

Derivs (InterceptRC e m) = Intercept e ': e ': 'Derivs m'
Prims  (InterceptRC e m) = Unlift (ReaderT (ReifiedFOHandler e m)) ': 'Derivs m'

# Interpretations for other effects

runStateStepped :: forall s m a p. (Carrier m, Threaders '[SteppedThreads] m p) => s -> SteppedC (State s) m a -> m (s, a) Source #

A variant of runState with a SteppedThreads threading constraint instead of a StateThreads threading constraint.

runTellStepped :: forall w m a p. (Monoid w, Carrier m, Threaders '[SteppedThreads] m p) => SteppedC (Tell w) m a -> m (w, a) Source #

A variant of runTell with a SteppedThreads threading constraint instead of a StateThreads threading constraint.

runTellListStepped :: forall o m a p. (Carrier m, Threaders '[SteppedThreads] m p) => SteppedC (Tell o) m a -> m ([o], a) Source #

A variant of runTell with a SteppedThreads threading constraint instead of a StateThreads threading constraint.

runListenStepped :: forall w m a p. (Monoid w, Carrier m, Threaders '[SteppedThreads] m p) => ListenSteppedC w m a -> m (w, a) Source #

A variant of runListen with a SteppedThreads threading constraint instead of a StateThreads threading constraint.

Derivs (ListenSteppedC w m) = Listen w ': Tell w ': Derivs m
Prims (ListenSteppedC w m) = ListenPrim w ': Derivs m

SteppedThreads accepts the following primitive effects:

• Regional s
• Optional s (when s is a functor)
• Unravel p
• ListenPrim s (when s is a Monoid)
• ReaderPrim i

# Carriers

data InterceptRC (e :: Effect) m a Source #

#### Instances

Instances details