Safe Haskell | None |
---|---|
Language | Haskell2010 |
Control.Effect.Intercept
Synopsis
- data Intercept (e :: Effect) :: Effect where
- data InterceptCont (e :: Effect) :: Effect where
- InterceptCont :: Coercible z m => InterceptionMode -> (forall x. (x -> m a) -> e z x -> m a) -> m a -> InterceptCont e m a
- data InterceptionMode
- intercept :: Eff (Intercept e) m => (forall x. e m x -> m x) -> m a -> m a
- interceptCont :: Eff (InterceptCont e) m => (forall x. (x -> m a) -> e m x -> m a) -> m a -> m a
- interceptCont1 :: Eff (InterceptCont e) m => (forall x. (x -> m a) -> e m x -> m a) -> m a -> m a
- runInterceptCont :: forall e m a p. (FirstOrder e, Carrier m, Member e (Derivs m), Threaders '[SteppedThreads] m p) => InterceptContC e m a -> m a
- runInterceptR :: forall e m a p. (FirstOrder e, Member e (Derivs m), Carrier m, Threaders '[ReaderThreads] m p) => InterceptRC e m a -> m a
- runStateStepped :: forall s m a p. (Carrier m, Threaders '[SteppedThreads] m p) => s -> SteppedC (State s) m a -> m (s, a)
- runTellStepped :: forall w m a p. (Monoid w, Carrier m, Threaders '[SteppedThreads] m p) => SteppedC (Tell w) m a -> m (w, a)
- runTellListStepped :: forall o m a p. (Carrier m, Threaders '[SteppedThreads] m p) => SteppedC (Tell o) m a -> m ([o], a)
- runListenStepped :: forall w m a p. (Monoid w, Carrier m, Threaders '[SteppedThreads] m p) => ListenSteppedC w m a -> m (w, a)
- type SteppedThreads = FreeThreads
- data InterceptContC e m a
- data InterceptRC (e :: Effect) m a
- data SteppedC (e :: Effect) m a
- data ListenSteppedC w m a
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.
For more information, see the wiki.
Instances
(FirstOrder e, Eff (Unravel (InterceptB e)) m) => Handler InterceptH (Intercept e) m Source # | |
Defined in Control.Effect.Internal.Intercept Methods effHandler :: EffHandler (Intercept e) m Source # |
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
(FirstOrder e, Member e (Derivs m), Eff (Unravel (InterceptB e)) m) => Handler InterceptH (InterceptCont e) m Source # | |
Defined in Control.Effect.Internal.Intercept Methods effHandler :: EffHandler (InterceptCont e) m Source # |
data InterceptionMode Source #
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
and InterceptCont
ee
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 afterrunInterceptCont
won't get be intercepted. What this means is that you typically want to run the handler fore
immediately afterrunInterceptCont
. - This imposes the very restrictive primitive effect
Unravel
. Most notably, neitherStateThreads
norWriterThreads
accepts it. Because of that, this module offers various alternatives of several commonState
andTell
interpreters with threading constraints that do acceptUnravel
.
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
and Intercept
ee
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 ofSteppedThreads
- It imposes the significantly more restrictive primitive effect
Unlift
instead ofUnravel
. - 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
Threading constraints
type SteppedThreads = FreeThreads Source #
SteppedThreads
accepts the following primitive effects:
Regional
s
Optional
s
(whens
is a functor)Unravel
p
ListenPrim
o
(wheno
is aMonoid
)ReaderPrim
i
Carriers
data InterceptContC e m a Source #
Instances
data InterceptRC (e :: Effect) m a Source #
Instances
data SteppedC (e :: Effect) m a Source #
A carrier for any first-order effect e
that allows for
dividing a computation into several steps, where
each step is seperated by the use of the effect.
This can be used to implement coroutines.
Instances
data ListenSteppedC w m a Source #