Safe Haskell | None |
---|---|
Language | Haskell2010 |
- data Effect l a
- runEffect :: Effect Nil a -> a
- send :: (Functor f, Member f l) => f a -> Effect l a
- sendEffect :: (Functor f, Member f l, Effectful l r) => f r -> r
- class (l ~ EffectsOf r) => Effectful l r where
- eliminate :: Effectful l r => (a -> r) -> (f r -> r) -> Effect (f :+ l) a -> r
- intercept :: (Effectful l r, Member f l) => (a -> r) -> (f r -> r) -> Effect l a -> r
- extend :: Effect l a -> Effect (f :+ l) a
- enable :: Effect (f :- l) a -> Effect l a
- conceal :: Member f l => Effect (f :+ l) a -> Effect l a
- reveal :: Member f l => Effect l a -> Effect (f :+ l) a
- rename :: Functor g => (forall r. f r -> g r) -> Effect (f :+ l) a -> Effect (g :+ l) a
- swap :: Effect (f :+ (g :+ l)) a -> Effect (g :+ (f :+ l)) a
- rotate :: Effect (f :+ (g :+ (h :+ l))) a -> Effect (g :+ (h :+ (f :+ l))) a
- mask :: (Functor f, KnownLength l, Member f m) => (forall r. Union l r -> f r) -> Effect (l :++ m) a -> Effect m a
- unmask :: (Functor f, Inclusive l, Member f m) => (forall r. f r -> Union l r) -> Effect m a -> Effect (l :++ m) a
- data Union l a
- flatten :: Inclusive l => Effect (Union l :+ m) a -> Effect (l :++ m) a
- unflatten :: KnownLength l => Effect (l :++ m) a -> Effect (Union l :+ m) a
- class KnownNat (IndexOf e l) => Member e l
- class (Member f l, f ~ InstanceOf name l) => MemberEffect name f l
- type family Is name f :: Bool
- data Row a
- type family l :++ m
- class KnownNat (Length l) => KnownLength l
- class KnownLength l => Inclusive l
The Effect Monad
An effectful computation. An Effect l a
may perform any of the effects
specified by the list of effects l
before returning a result of type a
.
The definition is isomorphic to the following GADT:
data Effect l a where
Done :: a -> Effect l a
Side :: Union
l (Effect l a) -> Effect l a
(Member (* -> *) (Exception e) l, (~) (* -> *) (Exception e) (InstanceOf (* -> * -> *) Exception l)) => MonadError e (Effect l) | |
(Member (* -> *) (Reader r) l, (~) (* -> *) (Reader r) (InstanceOf (* -> * -> *) Reader l)) => MonadReader r (Effect l) | |
(Member (* -> *) (State s) l, (~) (* -> *) (State s) (InstanceOf (* -> * -> *) State l)) => MonadState s (Effect l) | |
(Monoid w, Member (* -> *) (Writer w) l, (~) (* -> *) (Writer w) (InstanceOf (* -> * -> *) Writer l)) => MonadWriter w (Effect l) | |
Effectful l (Effect l a) | |
EffectList l => Alternative (Effect l) | |
Monad (Effect l) | |
Functor (Effect l) | |
EffectList l => MonadPlus (Effect l) | |
Applicative (Effect l) | |
EffectLift IO l => MonadIO (Effect l) | |
type EffectsOf (Effect l a) = l |
runEffect :: Effect Nil a -> a Source
Converts an computation that produces no effects into a regular value.
send :: (Functor f, Member f l) => f a -> Effect l a Source
Executes an effect of type f
that produces a return value of type a
.
sendEffect :: (Functor f, Member f l, Effectful l r) => f r -> r Source
Executes an effect of type f
that produces a return value of type r
.
Note that a specific instance of this function is of type
(Functor f, Member f l) => f (Effect l a) -> Effect l a
, which allows users
to send effects parameterized by effects.
Effect Handlers
class (l ~ EffectsOf r) => Effectful l r Source
The class of types which result in an effect. That is:
Effect l r a -> Effect l r a -> b -> Effect l r ...
eliminate :: Effectful l r => (a -> r) -> (f r -> r) -> Effect (f :+ l) a -> r Source
Completely handles an effect. The given function is passed an effect value
parameterized by the output type (i.e. the return type of handle
).
The most common instantiation of this function is:
(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect (f ': l) a -> Effect l b
intercept :: (Effectful l r, Member f l) => (a -> r) -> (f r -> r) -> Effect l a -> r Source
Handles an effect without eliminating it. The given function is passed an
effect value parameterized by the output type (i.e. the return type of
handle
).
The most common instantiation of this function is:
(a -> Effect l b) -> (f (Effect l b) -> Effect l b) -> Effect l a -> Effect l b
extend :: Effect l a -> Effect (f :+ l) a Source
Adds an arbitrary effect to the head of the effect list.
conceal :: Member f l => Effect (f :+ l) a -> Effect l a Source
Hides an effect g
by translating each instance of g
into an instance of
another effect f
.
reveal :: Member f l => Effect l a -> Effect (f :+ l) a Source
Hides an effect g
by translating each instance of another effect f
into
an instance of g
.
rename :: Functor g => (forall r. f r -> g r) -> Effect (f :+ l) a -> Effect (g :+ l) a Source
Translates the first effect in the effect list into another effect.
swap :: Effect (f :+ (g :+ l)) a -> Effect (g :+ (f :+ l)) a Source
Reorders the first two effects in a computation.
rotate :: Effect (f :+ (g :+ (h :+ l))) a -> Effect (g :+ (h :+ (f :+ l))) a Source
Rotates the first three effects in a computation.
mask :: (Functor f, KnownLength l, Member f m) => (forall r. Union l r -> f r) -> Effect (l :++ m) a -> Effect m a Source
unmask :: (Functor f, Inclusive l, Member f m) => (forall r. f r -> Union l r) -> Effect m a -> Effect (l :++ m) a Source
Unions
Represents a union of the list of type constructors in l
parameterized
by a
. As an effect, it represents the union of each type constructor's
corresponding effect. From the user's perspective, it provides a way to
encapsulate multiple effects.
flatten :: Inclusive l => Effect (Union l :+ m) a -> Effect (l :++ m) a Source
Distributes the sub-effects of a Union
effect across a computation.
unflatten :: KnownLength l => Effect (l :++ m) a -> Effect (Union l :+ m) a Source
Collects some effects in a computation into a Union
effect.
Membership
class KnownNat (IndexOf e l) => Member e l Source
A constraint specifying that e
is a member of the Row
l
.
KnownNat (IndexOf k e l) => Member k e l |
class (Member f l, f ~ InstanceOf name l) => MemberEffect name f l Source
A refined Member
ship constraint that can infer f
from l
, given
name
. In order for this to be used,
must be defined.
For example:Is
name f
data Reader r a = ... type instance Is Reader f = IsReader f type IsReader f where IsReader (Reader r) = True IsReader f = False type ReaderEffect r l = MemberEffect Reader (Reader r) l ask :: ReaderEffect r l => Effect l r ask = ...
Given the constraint ReaderEffect r l
in the above example, r
can be
inferred from l
.
(Member (* -> *) f l, (~) (* -> *) f (InstanceOf k name l)) => MemberEffect k name f l |
type family Is name f :: Bool Source
Returns a boolean value indicating whether f
belongs to the group of
effects identified by name
. This allows MemberEffect
to infer the
associated types for arbitrary effects.
Effect Rows
A type level list with explicit removals.
class KnownNat (Length l) => KnownLength l Source
The class of Row
s with statically known lengths.
KnownNat (Length k l) => KnownLength k l |