| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Control.Algebra
Contents
Description
Synopsis
Documentation
class (HFunctor sig, Monad m) => Algebra sig m | m -> sig where Source #
The class of carriers (results) for algebras (effect handlers) over signatures (effects), whose actions are given by the alg method.
Since: 1.0.0.0
Methods
alg :: sig m a -> m a Source #
Construct a value in the carrier for an effect signature (typically a sum of a handled effect and any remaining effects).
Instances
run :: Identity a -> a Source #
Run an action exhausted of effects to produce its final result value.
Since: 1.0.0.0
type Has eff sig m = (Members eff sig, Algebra sig m) Source #
m is a carrier for sig containing eff.
Note that if eff is a sum, it will be decomposed into multiple Member constraints. While this technically allows one to combine multiple unrelated effects into a single Has constraint, doing so has two significant drawbacks:
- Due to a problem with recursive type families, this can lead to significantly slower compiles.
- It defeats
ghc’s warnings for redundant constraints, and thus can lead to a proliferation of redundant constraints as code is changed.
send :: (Member eff sig, Algebra sig m) => eff m a -> m a Source #
Construct a request for an effect to be interpreted by some handler later on.
Re-exports
data (f :+: g) (m :: * -> *) k infixr 4 Source #
Higher-order sums are used to combine multiple effects into a signature, typically by chaining on the right.
Instances
| Algebra NonDet [] Source # | |
Defined in Control.Algebra | |
| Member l r => Member l (l' :+: r) Source # | Right-recursion: if |
Defined in Control.Effect.Sum | |
| Member l (l :+: r) Source # | Left-occurrence: if |
Defined in Control.Effect.Sum | |
| Member t (l1 :+: (l2 :+: r)) => Member t ((l1 :+: l2) :+: r) Source # | Left-recursion: if |
| Algebra (Error e) (Either e) Source # | |
| Generic1 ((f :+: g) m :: Type -> Type) Source # | |
| (Effect f, Effect g) => Effect (f :+: g) Source # | |
| (HFunctor f, HFunctor g) => HFunctor (f :+: g) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Choose :+: sig) (ChooseC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Empty :+: sig) (EmptyC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (NonDet :+: sig) (NonDetC m) Source # | |
| (MonadIO m, Algebra sig m) => Algebra (Trace :+: sig) (TraceC m) Source # | |
| Algebra sig m => Algebra (Trace :+: sig) (TraceC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Trace :+: sig) (TraceC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Fail :+: sig) (FailC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Fresh :+: sig) (FreshC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Cut :+: (NonDet :+: sig)) (CutC m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Cull :+: (NonDet :+: sig)) (CullC m) Source # | |
| Algebra sig m => Algebra (Reader r :+: sig) (ReaderT r m) Source # | |
| Algebra sig m => Algebra (Reader r :+: sig) (ReaderC r m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (State s :+: sig) (StateT s m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (State s :+: sig) (StateT s m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (State s :+: sig) (StateC s m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (State s :+: sig) (StateC s m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Throw e :+: sig) (ThrowC e m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Error e :+: sig) (ExceptT e m) Source # | |
| (Algebra sig m, Effect sig) => Algebra (Error e :+: sig) (ErrorC e m) Source # | |
| (Algebra sig m, Effect sig, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m) Source # | |
| (Algebra sig m, Effect sig, Monoid w) => Algebra (Writer w :+: sig) (WriterT w m) Source # | |
| (Monoid w, Algebra sig m, Effect sig) => Algebra (Writer w :+: sig) (WriterC w m) Source # | |
| (HFunctor eff, HFunctor sig, Reifies s (Handler eff m), Monad m, Algebra sig m) => Algebra (eff :+: sig) (InterpretC s eff m) Source # | |
Defined in Control.Carrier.Interpret Methods alg :: (eff :+: sig) (InterpretC s eff m) a -> InterpretC s eff m a Source # | |
| (Algebra sig m, Effect sig, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m) Source # | |
| (Algebra sig m, Effect sig, Monoid w) => Algebra (Reader r :+: (Writer w :+: (State s :+: sig))) (RWST r w s m) Source # | |
| (Functor (f m), Functor (g m)) => Functor ((f :+: g) m) Source # | |
| (Foldable (f m), Foldable (g m)) => Foldable ((f :+: g) m) Source # | |
Defined in Control.Effect.Sum Methods fold :: Monoid m0 => (f :+: g) m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> (f :+: g) m a -> m0 # foldr :: (a -> b -> b) -> b -> (f :+: g) m a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) m a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) m a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) m a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) m a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) m a -> a # toList :: (f :+: g) m a -> [a] # null :: (f :+: g) m a -> Bool # length :: (f :+: g) m a -> Int # elem :: Eq a => a -> (f :+: g) m a -> Bool # maximum :: Ord a => (f :+: g) m a -> a # minimum :: Ord a => (f :+: g) m a -> a # | |
| (Traversable (f m), Traversable (g m)) => Traversable ((f :+: g) m) Source # | |
Defined in Control.Effect.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) m a -> f0 ((f :+: g) m b) # sequenceA :: Applicative f0 => (f :+: g) m (f0 a) -> f0 ((f :+: g) m a) # mapM :: Monad m0 => (a -> m0 b) -> (f :+: g) m a -> m0 ((f :+: g) m b) # sequence :: Monad m0 => (f :+: g) m (m0 a) -> m0 ((f :+: g) m a) # | |
| (Eq (f m k), Eq (g m k)) => Eq ((f :+: g) m k) Source # | |
| (Ord (f m k), Ord (g m k)) => Ord ((f :+: g) m k) Source # | |
Defined in Control.Effect.Sum Methods compare :: (f :+: g) m k -> (f :+: g) m k -> Ordering # (<) :: (f :+: g) m k -> (f :+: g) m k -> Bool # (<=) :: (f :+: g) m k -> (f :+: g) m k -> Bool # (>) :: (f :+: g) m k -> (f :+: g) m k -> Bool # (>=) :: (f :+: g) m k -> (f :+: g) m k -> Bool # | |
| (Show (f m k), Show (g m k)) => Show ((f :+: g) m k) Source # | |
| type Rep1 ((f :+: g) m :: Type -> Type) Source # | |
Defined in Control.Effect.Sum type Rep1 ((f :+: g) m :: Type -> Type) = D1 (MetaData ":+:" "Control.Effect.Sum" "fused-effects-1.0.0.0-inplace" False) (C1 (MetaCons "L" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (f m))) :+: C1 (MetaCons "R" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (g m)))) | |
module Control.Effect.Class