packages feed

fused-effects 1.1.2.2 → 1.1.2.3

raw patch · 5 files changed

+19/−6 lines, 5 filesdep ~basedep ~containersdep ~hedgehogPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base, containers, hedgehog

API changes (from Hackage documentation)

- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Accum.AccumT w m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.CPS.RWST r w s m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.Strict.RWST r w s m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.CPS.WriterT w m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.Lazy.WriterT w m)
- Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.Strict.WriterT w m)
- Control.Algebra: instance Control.Algebra.Algebra (Control.Effect.Error.Internal.Error e) (Data.Either.Either e)
- Control.Algebra: instance Control.Algebra.Algebra (Control.Effect.Lift.Internal.Lift Data.Functor.Identity.Identity) Data.Functor.Identity.Identity
- Control.Algebra: instance Control.Algebra.Algebra Control.Effect.Choose.Internal.Choose GHC.Base.NonEmpty
- Control.Algebra: instance Control.Algebra.Algebra Control.Effect.Empty.Internal.Empty GHC.Maybe.Maybe
- Control.Algebra: instance Control.Algebra.Algebra sig m => Control.Algebra.Algebra sig (Data.Monoid.Ap m)
- Control.Algebra: instance Control.Algebra.Algebra sig m => Control.Algebra.Algebra sig (Data.Semigroup.Internal.Alt m)
- Control.Algebra: instance GHC.Base.Functor (Control.Algebra.RWSTF w s)
- Control.Algebra: instance GHC.Base.Functor (Control.Algebra.Swap s)
- Control.Algebra: instance GHC.Base.Monoid w => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w) ((,) w)
- Control.Algebra: type Handler ctx m n = forall x. ctx (m x) -> n (ctx x)
- Control.Algebra.Handler: type Handler ctx m n = forall x. ctx (m x) -> n (ctx x)
- Control.Carrier.Accum.Church: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (Control.Monad.Fail.MonadFail m, GHC.Base.Monoid w) => Control.Monad.Fail.MonadFail (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (Control.Monad.Fix.MonadFix m, GHC.Base.Monoid w) => Control.Monad.Fix.MonadFix (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (Control.Monad.IO.Class.MonadIO m, GHC.Base.Monoid w) => Control.Monad.IO.Class.MonadIO (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (GHC.Base.Alternative m, GHC.Base.Monad m, GHC.Base.Monoid w) => GHC.Base.Alternative (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (GHC.Base.Monad m, GHC.Base.Monoid w) => GHC.Base.Monad (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance (GHC.Base.MonadPlus m, GHC.Base.Monoid w) => GHC.Base.MonadPlus (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance GHC.Base.Functor (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.Church: instance GHC.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Carrier.Accum.Church.AccumC w)
- Control.Carrier.Accum.Church: instance GHC.Base.Monoid w => GHC.Base.Applicative (Control.Carrier.Accum.Church.AccumC w m)
- Control.Carrier.Accum.IORef: instance (Control.Algebra.Algebra sig m, GHC.Base.Semigroup w, Control.Monad.IO.Class.MonadIO m) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.IORef: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Accum.IORef.AccumC w m)
- Control.Carrier.Accum.Strict: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (Control.Monad.Fail.MonadFail m, GHC.Base.Monoid w) => Control.Monad.Fail.MonadFail (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (Control.Monad.Fix.MonadFix m, GHC.Base.Monoid w) => Control.Monad.Fix.MonadFix (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (Control.Monad.IO.Class.MonadIO m, GHC.Base.Monoid w) => Control.Monad.IO.Class.MonadIO (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m, GHC.Base.Monoid w) => GHC.Base.Alternative (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (GHC.Base.Monad m, GHC.Base.Monoid w) => GHC.Base.Applicative (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (GHC.Base.Monad m, GHC.Base.Monoid w) => GHC.Base.Monad (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance (GHC.Base.MonadPlus m, GHC.Base.Monoid w) => GHC.Base.MonadPlus (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Accum.Strict.AccumC w m)
- Control.Carrier.Accum.Strict: instance GHC.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Carrier.Accum.Strict.AccumC w)
- Control.Carrier.Choose.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Choose.Church.ChooseC m)
- Control.Carrier.Choose.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Choose.Church.ChooseC m)
- Control.Carrier.Choose.Church: instance GHC.Base.Applicative (Control.Carrier.Choose.Church.ChooseC m)
- Control.Carrier.Choose.Church: instance GHC.Base.Functor (Control.Carrier.Choose.Church.ChooseC m)
- Control.Carrier.Choose.Church: instance GHC.Base.Monad (Control.Carrier.Choose.Church.ChooseC m)
- Control.Carrier.Cull.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance GHC.Base.Alternative (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance GHC.Base.Applicative (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance GHC.Base.Functor (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance GHC.Base.Monad (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cull.Church: instance GHC.Base.MonadPlus (Control.Carrier.Cull.Church.CullC m)
- Control.Carrier.Cut.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance GHC.Base.Alternative (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance GHC.Base.Applicative (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance GHC.Base.Functor (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance GHC.Base.Monad (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Cut.Church: instance GHC.Base.MonadPlus (Control.Carrier.Cut.Church.CutC m)
- Control.Carrier.Empty.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Empty.Church.EmptyC m)
- Control.Carrier.Empty.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Empty.Church.EmptyC m)
- Control.Carrier.Empty.Church: instance GHC.Base.Applicative (Control.Carrier.Empty.Church.EmptyC m)
- Control.Carrier.Empty.Church: instance GHC.Base.Functor (Control.Carrier.Empty.Church.EmptyC m)
- Control.Carrier.Empty.Church: instance GHC.Base.Monad (Control.Carrier.Empty.Church.EmptyC m)
- Control.Carrier.Empty.Maybe: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Empty.Maybe.EmptyC m)
- Control.Carrier.Empty.Maybe: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Empty.Maybe.EmptyC m)
- Control.Carrier.Empty.Maybe: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Empty.Maybe.EmptyC m)
- Control.Carrier.Empty.Maybe: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Empty.Maybe.EmptyC m)
- Control.Carrier.Empty.Maybe: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Empty.Maybe.EmptyC m)
- Control.Carrier.Error.Church: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance GHC.Base.Applicative (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance GHC.Base.Functor (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Church: instance GHC.Base.Monad (Control.Carrier.Error.Church.ErrorC e m)
- Control.Carrier.Error.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Error.Either: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Error.Either.ErrorC e m)
- Control.Carrier.Fail.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance Control.Algebra.Algebra sig m => Control.Monad.Fail.MonadFail (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fail.Either: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Fail.Either.FailC m)
- Control.Carrier.Fresh.Church: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance GHC.Base.Applicative (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance GHC.Base.Functor (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Church: instance GHC.Base.Monad (Control.Carrier.Fresh.Church.FreshC m)
- Control.Carrier.Fresh.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Fresh.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Fresh.Strict.FreshC m)
- Control.Carrier.Interpret: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Interpret: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Carrier.Interpret.InterpretC s sig m)
- Control.Carrier.Lift: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.Monad m => Control.Algebra.Algebra (Control.Effect.Lift.Internal.Lift m) (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Lift.LiftC m)
- Control.Carrier.Lift: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Carrier.Lift.LiftC m)
- Control.Carrier.NonDet.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance GHC.Base.Alternative (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance GHC.Base.Applicative (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance GHC.Base.Functor (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance GHC.Base.Monad (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.NonDet.Church: instance GHC.Base.MonadPlus (Control.Carrier.NonDet.Church.NonDetC m)
- Control.Carrier.Reader: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.Reader: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.Reader: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Reader.ReaderC s m)
- Control.Carrier.Reader: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.Reader: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.Reader: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.Reader: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Reader.ReaderC r m)
- Control.Carrier.State.Church: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance GHC.Base.Applicative (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance GHC.Base.Functor (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.Church: instance GHC.Base.Monad (Control.Carrier.State.Church.StateC s m)
- Control.Carrier.State.IORef: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.IORef: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.State.IORef.StateC s m)
- Control.Carrier.State.Lazy: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Lazy: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.State.Lazy.StateC s m)
- Control.Carrier.State.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.State.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.State.Strict.StateC s m)
- Control.Carrier.Throw.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Throw.Either: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Throw.Either.ThrowC e m)
- Control.Carrier.Trace.Ignoring: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Ignoring: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Carrier.Trace.Ignoring.TraceC m)
- Control.Carrier.Trace.Printing: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Printing: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Carrier.Trace.Printing.TraceC m)
- Control.Carrier.Trace.Returning: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Trace.Returning: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Trace.Returning.TraceC m)
- Control.Carrier.Writer.Church: instance (Control.Algebra.Algebra sig m, GHC.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance GHC.Base.Applicative (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance GHC.Base.Functor (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Church: instance GHC.Base.Monad (Control.Carrier.Writer.Church.WriterC w m)
- Control.Carrier.Writer.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance (GHC.Base.Alternative m, GHC.Base.Monad m) => GHC.Base.MonadPlus (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance (GHC.Base.Monoid w, Control.Algebra.Algebra sig m) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Carrier.Writer.Strict: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Carrier.Writer.Strict.WriterC w m)
- Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Base.Alternative (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Base.MonadPlus (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Base.Monoid (Control.Effect.Choose.Choosing m a)
- Control.Effect.Choose: instance Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m => GHC.Base.Semigroup (Control.Effect.Choose.Choosing m a)
- Control.Effect.Choose: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance Data.Traversable.Traversable m => Data.Traversable.Traversable (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Effect.Choose.Choosing m)
- Control.Effect.Choose: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Effect.Choose.Choosing m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Fail.MonadFail (sub m) => Control.Monad.Fail.MonadFail (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Fix.MonadFix (sub m) => Control.Monad.Fix.MonadFix (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Alternative (sub m) => GHC.Base.Alternative (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Alternative m => GHC.Base.Alternative (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Applicative (sub m) => GHC.Base.Applicative (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Applicative m => GHC.Base.Applicative (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Functor (sub m) => GHC.Base.Functor (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Functor m => GHC.Base.Functor (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Monad (sub m) => GHC.Base.Monad (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Monad m => GHC.Base.Monad (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.MonadPlus (sub m) => GHC.Base.MonadPlus (Control.Effect.Labelled.Labelled label sub m)
- Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Effect.Labelled.UnderLabel label sub m)
- Control.Effect.Sum: instance (Data.Foldable.Foldable (f m), Data.Foldable.Foldable (g m)) => Data.Foldable.Foldable ((Control.Effect.Sum.:+:) f g m)
- Control.Effect.Sum: instance (Data.Traversable.Traversable (f m), Data.Traversable.Traversable (g m)) => Data.Traversable.Traversable ((Control.Effect.Sum.:+:) f g m)
- Control.Effect.Sum: instance (GHC.Base.Functor (f m), GHC.Base.Functor (g m)) => GHC.Base.Functor ((Control.Effect.Sum.:+:) f g m)
- Control.Effect.Sum: instance (GHC.Show.Show (f m k), GHC.Show.Show (g m k)) => GHC.Show.Show ((Control.Effect.Sum.:+:) f g m k)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Accum.AccumT w m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.CPS.RWST r w s m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Reader.Internal.Reader r Control.Effect.Sum.:+: (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: (Control.Effect.State.Internal.State s Control.Effect.Sum.:+: sig))) (Control.Monad.Trans.RWS.Strict.RWST r w s m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.CPS.WriterT w m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.Lazy.WriterT w m)
+ Control.Algebra: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Monad.Trans.Writer.Strict.WriterT w m)
+ Control.Algebra: instance Control.Algebra.Algebra (Control.Effect.Error.Internal.Error e) (GHC.Internal.Data.Either.Either e)
+ Control.Algebra: instance Control.Algebra.Algebra (Control.Effect.Lift.Internal.Lift GHC.Internal.Data.Functor.Identity.Identity) GHC.Internal.Data.Functor.Identity.Identity
+ Control.Algebra: instance Control.Algebra.Algebra Control.Effect.Choose.Internal.Choose GHC.Internal.Base.NonEmpty
+ Control.Algebra: instance Control.Algebra.Algebra Control.Effect.Empty.Internal.Empty GHC.Internal.Maybe.Maybe
+ Control.Algebra: instance Control.Algebra.Algebra sig m => Control.Algebra.Algebra sig (GHC.Internal.Data.Monoid.Ap m)
+ Control.Algebra: instance Control.Algebra.Algebra sig m => Control.Algebra.Algebra sig (GHC.Internal.Data.Semigroup.Internal.Alt m)
+ Control.Algebra: instance GHC.Internal.Base.Functor (Control.Algebra.RWSTF w s)
+ Control.Algebra: instance GHC.Internal.Base.Functor (Control.Algebra.Swap s)
+ Control.Algebra: instance GHC.Internal.Base.Monoid w => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w) ((,) w)
+ Control.Algebra: type Handler (ctx :: Type -> Type) (m :: Type -> Type) (n :: Type -> Type) = forall x. () => ctx m x -> n ctx x
+ Control.Algebra.Handler: type Handler (ctx :: Type -> Type) (m :: Type -> Type) (n :: Type -> Type) = forall x. () => ctx m x -> n ctx x
+ Control.Carrier.Accum.Church: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (Control.Monad.IO.Class.MonadIO m, GHC.Internal.Base.Monoid w) => Control.Monad.IO.Class.MonadIO (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.Alternative (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (GHC.Internal.Base.Monad m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.Monad (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (GHC.Internal.Base.MonadPlus m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.MonadPlus (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (GHC.Internal.Control.Monad.Fail.MonadFail m, GHC.Internal.Base.Monoid w) => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance (GHC.Internal.Control.Monad.Fix.MonadFix m, GHC.Internal.Base.Monoid w) => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.Church: instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Carrier.Accum.Church.AccumC w)
+ Control.Carrier.Accum.Church: instance GHC.Internal.Base.Monoid w => GHC.Internal.Base.Applicative (Control.Carrier.Accum.Church.AccumC w m)
+ Control.Carrier.Accum.IORef: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Semigroup w, Control.Monad.IO.Class.MonadIO m) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.IORef: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Accum.IORef.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Accum.Internal.Accum w Control.Effect.Sum.:+: sig) (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (Control.Monad.IO.Class.MonadIO m, GHC.Internal.Base.Monoid w) => Control.Monad.IO.Class.MonadIO (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.Alternative (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Base.Monad m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.Applicative (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Base.Monad m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.Monad (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Base.MonadPlus m, GHC.Internal.Base.Monoid w) => GHC.Internal.Base.MonadPlus (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Control.Monad.Fail.MonadFail m, GHC.Internal.Base.Monoid w) => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance (GHC.Internal.Control.Monad.Fix.MonadFix m, GHC.Internal.Base.Monoid w) => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Accum.Strict.AccumC w m)
+ Control.Carrier.Accum.Strict: instance GHC.Internal.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Carrier.Accum.Strict.AccumC w)
+ Control.Carrier.Choose.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Choose.Church.ChooseC m)
+ Control.Carrier.Choose.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Choose.Church.ChooseC m)
+ Control.Carrier.Choose.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Choose.Church.ChooseC m)
+ Control.Carrier.Choose.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Choose.Church.ChooseC m)
+ Control.Carrier.Choose.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Choose.Church.ChooseC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Base.Alternative (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Base.MonadPlus (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cull.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Cull.Church.CullC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Base.Alternative (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Base.MonadPlus (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Cut.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Cut.Church.CutC m)
+ Control.Carrier.Empty.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Empty.Church.EmptyC m)
+ Control.Carrier.Empty.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Empty.Church.EmptyC m)
+ Control.Carrier.Empty.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Empty.Church.EmptyC m)
+ Control.Carrier.Empty.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Empty.Church.EmptyC m)
+ Control.Carrier.Empty.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Empty.Church.EmptyC m)
+ Control.Carrier.Empty.Maybe: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Empty.Maybe.EmptyC m)
+ Control.Carrier.Empty.Maybe: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Empty.Maybe.EmptyC m)
+ Control.Carrier.Empty.Maybe: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Empty.Maybe.EmptyC m)
+ Control.Carrier.Empty.Maybe: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Empty.Maybe.EmptyC m)
+ Control.Carrier.Empty.Maybe: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Empty.Maybe.EmptyC m)
+ Control.Carrier.Error.Church: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Error.Church.ErrorC e m)
+ Control.Carrier.Error.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Error.Either: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Error.Either.ErrorC e m)
+ Control.Carrier.Fail.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance Control.Algebra.Algebra sig m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fail.Either: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Fail.Either.FailC m)
+ Control.Carrier.Fresh.Church: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Fresh.Church.FreshC m)
+ Control.Carrier.Fresh.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Fresh.Strict: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Fresh.Strict.FreshC m)
+ Control.Carrier.Interpret: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Interpret: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Interpret.InterpretC s sig m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.Monad m => Control.Algebra.Algebra (Control.Effect.Lift.Internal.Lift m) (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.Lift: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Lift.LiftC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Base.Alternative (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Base.Functor (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Base.Monad (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Base.MonadPlus (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.NonDet.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.NonDet.Church.NonDetC m)
+ Control.Carrier.Reader: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Reader.ReaderC r m)
+ Control.Carrier.Reader: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Reader.ReaderC s m)
+ Control.Carrier.State.Church: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Base.Functor (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Base.Monad (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.State.Church.StateC s m)
+ Control.Carrier.State.IORef: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.IORef: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.State.IORef.StateC s m)
+ Control.Carrier.State.Lazy: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Lazy: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.State.Lazy.StateC s m)
+ Control.Carrier.State.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.State.Strict: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.State.Strict.StateC s m)
+ Control.Carrier.Throw.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Throw.Either: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Throw.Either.ThrowC e m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Ignoring: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Ignoring.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Printing: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Printing.TraceC m)
+ Control.Carrier.Trace.Returning: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Trace.Returning: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Trace.Returning.TraceC m)
+ Control.Carrier.Writer.Church: instance (Control.Algebra.Algebra sig m, GHC.Internal.Base.Monoid w) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Base.Applicative (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Base.Functor (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Base.Monad (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Church: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Writer.Church.WriterC w m)
+ Control.Carrier.Writer.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Alternative (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance (GHC.Internal.Base.Alternative m, GHC.Internal.Base.Monad m) => GHC.Internal.Base.MonadPlus (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance (GHC.Internal.Base.Monoid w, Control.Algebra.Algebra sig m) => Control.Algebra.Algebra (Control.Effect.Writer.Internal.Writer w Control.Effect.Sum.:+: sig) (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Carrier.Writer.Strict: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Carrier.Writer.Strict.WriterC w m)
+ Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Internal.Base.Alternative (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Internal.Base.MonadPlus (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance (Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m, Control.Algebra.Has Control.Effect.Empty.Internal.Empty sig m) => GHC.Internal.Base.Monoid (Control.Effect.Choose.Choosing m a)
+ Control.Effect.Choose: instance Control.Algebra.Has Control.Effect.Choose.Internal.Choose sig m => GHC.Internal.Base.Semigroup (Control.Effect.Choose.Choosing m a)
+ Control.Effect.Choose: instance GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Data.Foldable.Foldable m => GHC.Internal.Data.Foldable.Foldable (Control.Effect.Choose.Choosing m)
+ Control.Effect.Choose: instance GHC.Internal.Data.Traversable.Traversable m => GHC.Internal.Data.Traversable.Traversable (Control.Effect.Choose.Choosing m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Alternative (sub m) => GHC.Internal.Base.Alternative (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Applicative (sub m) => GHC.Internal.Base.Applicative (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Functor (sub m) => GHC.Internal.Base.Functor (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Monad (sub m) => GHC.Internal.Base.Monad (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.MonadPlus (sub m) => GHC.Internal.Base.MonadPlus (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Control.Monad.Fail.MonadFail (sub m) => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Control.Monad.Fail.MonadFail m => GHC.Internal.Control.Monad.Fail.MonadFail (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Control.Monad.Fix.MonadFix (sub m) => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Effect.Labelled.Labelled label sub m)
+ Control.Effect.Labelled: instance forall k (label :: k) (sub :: (* -> *) -> * -> *) (m :: * -> *). GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Monad.Fix.MonadFix (Control.Effect.Labelled.UnderLabel label sub m)
+ Control.Effect.Sum: instance (GHC.Internal.Base.Functor (f m), GHC.Internal.Base.Functor (g m)) => GHC.Internal.Base.Functor ((Control.Effect.Sum.:+:) f g m)
+ Control.Effect.Sum: instance (GHC.Internal.Data.Foldable.Foldable (f m), GHC.Internal.Data.Foldable.Foldable (g m)) => GHC.Internal.Data.Foldable.Foldable ((Control.Effect.Sum.:+:) f g m)
+ Control.Effect.Sum: instance (GHC.Internal.Data.Traversable.Traversable (f m), GHC.Internal.Data.Traversable.Traversable (g m)) => GHC.Internal.Data.Traversable.Traversable ((Control.Effect.Sum.:+:) f g m)
+ Control.Effect.Sum: instance (GHC.Internal.Show.Show (f m k), GHC.Internal.Show.Show (g m k)) => GHC.Internal.Show.Show ((Control.Effect.Sum.:+:) f g m k)
- Control.Algebra: (~<~) :: (Functor n, Functor ctx1) => Handler ctx1 m n -> Handler ctx2 l m -> Handler (Compose ctx1 ctx2) l n
+ Control.Algebra: (~<~) :: forall (n :: Type -> Type) (ctx1 :: Type -> Type) (m :: Type -> Type) (ctx2 :: Type -> Type) (l :: Type -> Type). (Functor n, Functor ctx1) => Handler ctx1 m n -> Handler ctx2 l m -> Handler (Compose ctx1 ctx2) l n
- Control.Algebra: L :: f m k -> (:+:) f g (m :: Type -> Type) k
+ Control.Algebra: L :: f m k -> (:+:) (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) k
- Control.Algebra: R :: g m k -> (:+:) f g (m :: Type -> Type) k
+ Control.Algebra: R :: g m k -> (:+:) (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) k
- Control.Algebra: alg :: (Algebra sig m, Functor ctx) => Handler ctx n m -> sig n a -> ctx () -> m (ctx a)
+ Control.Algebra: alg :: forall ctx (n :: Type -> Type) a. (Algebra sig m, Functor ctx) => Handler ctx n m -> sig n a -> ctx () -> m (ctx a)
- Control.Algebra: class Monad m => Algebra sig m | m -> sig
+ Control.Algebra: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Algebra: data ( f :+: g ) (m :: Type -> Type) k
+ Control.Algebra: data ( (f :: Type -> Type -> Type -> Type) :+: (g :: Type -> Type -> Type -> Type) ) (m :: Type -> Type) k
- Control.Algebra: send :: (Member eff sig, Algebra sig m) => eff m a -> m a
+ Control.Algebra: send :: forall eff (sig :: (Type -> Type) -> Type -> Type) m a. (Member eff sig, Algebra sig m) => eff m a -> m a
- Control.Algebra: thread :: (Functor ctx1, Functor ctx2, Algebra sig m) => Handler (Compose ctx1 ctx2) n m -> sig n a -> ctx1 (ctx2 ()) -> m (ctx1 (ctx2 a))
+ Control.Algebra: thread :: forall ctx1 ctx2 sig m (n :: Type -> Type) a. (Functor ctx1, Functor ctx2, Algebra sig m) => Handler (Compose ctx1 ctx2) n m -> sig n a -> ctx1 (ctx2 ()) -> m (ctx1 (ctx2 a))
- Control.Algebra: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Algebra: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Algebra.Handler: (~<~) :: (Functor n, Functor ctx1) => Handler ctx1 m n -> Handler ctx2 l m -> Handler (Compose ctx1 ctx2) l n
+ Control.Algebra.Handler: (~<~) :: forall (n :: Type -> Type) (ctx1 :: Type -> Type) (m :: Type -> Type) (ctx2 :: Type -> Type) (l :: Type -> Type). (Functor n, Functor ctx1) => Handler ctx1 m n -> Handler ctx2 l m -> Handler (Compose ctx1 ctx2) l n
- Control.Carrier.Accum.Church: AccumC :: (forall r. (w -> a -> m r) -> w -> m r) -> AccumC w m a
+ Control.Carrier.Accum.Church: AccumC :: (forall r. () => (w -> a -> m r) -> w -> m r) -> AccumC w (m :: Type -> Type) a
- Control.Carrier.Accum.Church: newtype AccumC w m a
+ Control.Carrier.Accum.Church: newtype AccumC w (m :: Type -> Type) a
- Control.Carrier.Accum.IORef: AccumC :: ReaderC (IORef w) m a -> AccumC w m a
+ Control.Carrier.Accum.IORef: AccumC :: ReaderC (IORef w) m a -> AccumC w (m :: Type -> Type) a
- Control.Carrier.Accum.IORef: newtype AccumC w m a
+ Control.Carrier.Accum.IORef: newtype AccumC w (m :: Type -> Type) a
- Control.Carrier.Accum.Strict: AccumC :: (w -> m (w, a)) -> AccumC w m a
+ Control.Carrier.Accum.Strict: AccumC :: (w -> m (w, a)) -> AccumC w (m :: Type -> Type) a
- Control.Carrier.Accum.Strict: newtype AccumC w m a
+ Control.Carrier.Accum.Strict: newtype AccumC w (m :: Type -> Type) a
- Control.Carrier.Choose.Church: ChooseC :: (forall b. (m b -> m b -> m b) -> (a -> m b) -> m b) -> ChooseC m a
+ Control.Carrier.Choose.Church: ChooseC :: (forall b. () => (m b -> m b -> m b) -> (a -> m b) -> m b) -> ChooseC (m :: Type -> Type) a
- Control.Carrier.Choose.Church: newtype ChooseC m a
+ Control.Carrier.Choose.Church: newtype ChooseC (m :: Type -> Type) a
- Control.Carrier.Cull.Church: CullC :: ReaderC Bool (NonDetC m) a -> CullC m a
+ Control.Carrier.Cull.Church: CullC :: ReaderC Bool (NonDetC m) a -> CullC (m :: Type -> Type) a
- Control.Carrier.Cull.Church: newtype CullC m a
+ Control.Carrier.Cull.Church: newtype CullC (m :: Type -> Type) a
- Control.Carrier.Cut.Church: CutC :: (forall b. (a -> m b -> m b) -> m b -> m b -> m b) -> CutC m a
+ Control.Carrier.Cut.Church: CutC :: (forall b. () => (a -> m b -> m b) -> m b -> m b -> m b) -> CutC (m :: Type -> Type) a
- Control.Carrier.Cut.Church: newtype CutC m a
+ Control.Carrier.Cut.Church: newtype CutC (m :: Type -> Type) a
- Control.Carrier.Empty.Church: EmptyC :: (forall b. m b -> (a -> m b) -> m b) -> EmptyC m a
+ Control.Carrier.Empty.Church: EmptyC :: (forall b. () => m b -> (a -> m b) -> m b) -> EmptyC (m :: Type -> Type) a
- Control.Carrier.Empty.Church: newtype EmptyC m a
+ Control.Carrier.Empty.Church: newtype EmptyC (m :: Type -> Type) a
- Control.Carrier.Empty.Maybe: EmptyC :: MaybeT m a -> EmptyC m a
+ Control.Carrier.Empty.Maybe: EmptyC :: MaybeT m a -> EmptyC (m :: Type -> Type) a
- Control.Carrier.Empty.Maybe: newtype EmptyC m a
+ Control.Carrier.Empty.Maybe: newtype EmptyC (m :: Type -> Type) a
- Control.Carrier.Error.Church: ErrorC :: (forall b. (e -> m b) -> (a -> m b) -> m b) -> ErrorC e m a
+ Control.Carrier.Error.Church: ErrorC :: (forall b. () => (e -> m b) -> (a -> m b) -> m b) -> ErrorC e (m :: Type -> Type) a
- Control.Carrier.Error.Church: [runErrorC] :: ErrorC e m a -> forall b. (e -> m b) -> (a -> m b) -> m b
+ Control.Carrier.Error.Church: [runErrorC] :: ErrorC e (m :: Type -> Type) a -> forall b. () => (e -> m b) -> (a -> m b) -> m b
- Control.Carrier.Error.Church: newtype ErrorC e m a
+ Control.Carrier.Error.Church: newtype ErrorC e (m :: Type -> Type) a
- Control.Carrier.Error.Either: ErrorC :: ExceptT e m a -> ErrorC e m a
+ Control.Carrier.Error.Either: ErrorC :: ExceptT e m a -> ErrorC e (m :: Type -> Type) a
- Control.Carrier.Error.Either: newtype ErrorC e m a
+ Control.Carrier.Error.Either: newtype ErrorC e (m :: Type -> Type) a
- Control.Carrier.Fail.Either: FailC :: ThrowC String m a -> FailC m a
+ Control.Carrier.Fail.Either: FailC :: ThrowC String m a -> FailC (m :: Type -> Type) a
- Control.Carrier.Fail.Either: newtype FailC m a
+ Control.Carrier.Fail.Either: newtype FailC (m :: Type -> Type) a
- Control.Carrier.Fresh.Church: FreshC :: StateC Int m a -> FreshC m a
+ Control.Carrier.Fresh.Church: FreshC :: StateC Int m a -> FreshC (m :: Type -> Type) a
- Control.Carrier.Fresh.Church: newtype FreshC m a
+ Control.Carrier.Fresh.Church: newtype FreshC (m :: Type -> Type) a
- Control.Carrier.Fresh.Strict: FreshC :: StateC Int m a -> FreshC m a
+ Control.Carrier.Fresh.Strict: FreshC :: StateC Int m a -> FreshC (m :: Type -> Type) a
- Control.Carrier.Fresh.Strict: newtype FreshC m a
+ Control.Carrier.Fresh.Strict: newtype FreshC (m :: Type -> Type) a
- Control.Carrier.Interpret: InterpretC :: m a -> InterpretC s (sig :: (Type -> Type) -> Type -> Type) m a
+ Control.Carrier.Interpret: InterpretC :: m a -> InterpretC s (sig :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a
- Control.Carrier.Interpret: class Monad m => Algebra sig m | m -> sig
+ Control.Carrier.Interpret: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Carrier.Interpret: data Interpreter sig m
+ Control.Carrier.Interpret: data Interpreter (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type)
- Control.Carrier.Interpret: newtype InterpretC s (sig :: (Type -> Type) -> (Type -> Type)) m a
+ Control.Carrier.Interpret: newtype InterpretC s (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) a
- Control.Carrier.Interpret: runInterpret :: (forall ctx n x. Functor ctx => Handler ctx n m -> eff n x -> ctx () -> m (ctx x)) -> (forall s. Reifies s (Interpreter eff m) => InterpretC s eff m a) -> m a
+ Control.Carrier.Interpret: runInterpret :: (forall (ctx :: Type -> Type) (n :: Type -> Type) x. Functor ctx => Handler ctx n m -> eff n x -> ctx () -> m (ctx x)) -> (forall s. Reifies s (Interpreter eff m) => InterpretC s eff m a) -> m a
- Control.Carrier.Interpret: runInterpretState :: (forall ctx n x. Functor ctx => Handler ctx n (StateC s m) -> eff n x -> s -> ctx () -> m (s, ctx x)) -> s -> (forall t. Reifies t (Interpreter eff (StateC s m)) => InterpretC t eff (StateC s m) a) -> m (s, a)
+ Control.Carrier.Interpret: runInterpretState :: (forall (ctx :: Type -> Type) (n :: Type -> Type) x. Functor ctx => Handler ctx n (StateC s m) -> eff n x -> s -> ctx () -> m (s, ctx x)) -> s -> (forall t. Reifies t (Interpreter eff (StateC s m)) => InterpretC t eff (StateC s m) a) -> m (s, a)
- Control.Carrier.Interpret: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Carrier.Interpret: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Carrier.Lift: LiftC :: m a -> LiftC m a
+ Control.Carrier.Lift: LiftC :: m a -> LiftC (m :: Type -> Type) a
- Control.Carrier.Lift: newtype LiftC m a
+ Control.Carrier.Lift: newtype LiftC (m :: Type -> Type) a
- Control.Carrier.NonDet.Church: NonDetC :: (forall b. (m b -> m b -> m b) -> (a -> m b) -> m b -> m b) -> NonDetC m a
+ Control.Carrier.NonDet.Church: NonDetC :: (forall b. () => (m b -> m b -> m b) -> (a -> m b) -> m b -> m b) -> NonDetC (m :: Type -> Type) a
- Control.Carrier.NonDet.Church: newtype NonDetC m a
+ Control.Carrier.NonDet.Church: newtype NonDetC (m :: Type -> Type) a
- Control.Carrier.Reader: ReaderC :: (r -> m a) -> ReaderC r m a
+ Control.Carrier.Reader: ReaderC :: (r -> m a) -> ReaderC r (m :: Type -> Type) a
- Control.Carrier.Reader: newtype ReaderC r m a
+ Control.Carrier.Reader: newtype ReaderC r (m :: Type -> Type) a
- Control.Carrier.State.Church: StateC :: (forall r. (s -> a -> m r) -> s -> m r) -> StateC s m a
+ Control.Carrier.State.Church: StateC :: (forall r. () => (s -> a -> m r) -> s -> m r) -> StateC s (m :: Type -> Type) a
- Control.Carrier.State.Church: newtype StateC s m a
+ Control.Carrier.State.Church: newtype StateC s (m :: Type -> Type) a
- Control.Carrier.State.IORef: StateC :: ReaderC (IORef s) m a -> StateC s m a
+ Control.Carrier.State.IORef: StateC :: ReaderC (IORef s) m a -> StateC s (m :: Type -> Type) a
- Control.Carrier.State.IORef: [runStateC] :: StateC s m a -> ReaderC (IORef s) m a
+ Control.Carrier.State.IORef: [runStateC] :: StateC s (m :: Type -> Type) a -> ReaderC (IORef s) m a
- Control.Carrier.State.IORef: newtype StateC s m a
+ Control.Carrier.State.IORef: newtype StateC s (m :: Type -> Type) a
- Control.Carrier.State.Lazy: StateC :: (s -> m (s, a)) -> StateC s m a
+ Control.Carrier.State.Lazy: StateC :: (s -> m (s, a)) -> StateC s (m :: Type -> Type) a
- Control.Carrier.State.Lazy: newtype StateC s m a
+ Control.Carrier.State.Lazy: newtype StateC s (m :: Type -> Type) a
- Control.Carrier.State.Strict: StateC :: (s -> m (s, a)) -> StateC s m a
+ Control.Carrier.State.Strict: StateC :: (s -> m (s, a)) -> StateC s (m :: Type -> Type) a
- Control.Carrier.State.Strict: newtype StateC s m a
+ Control.Carrier.State.Strict: newtype StateC s (m :: Type -> Type) a
- Control.Carrier.Throw.Either: ThrowC :: ErrorC e m a -> ThrowC e m a
+ Control.Carrier.Throw.Either: ThrowC :: ErrorC e m a -> ThrowC e (m :: Type -> Type) a
- Control.Carrier.Throw.Either: newtype ThrowC e m a
+ Control.Carrier.Throw.Either: newtype ThrowC e (m :: Type -> Type) a
- Control.Carrier.Trace.Ignoring: TraceC :: m a -> TraceC m a
+ Control.Carrier.Trace.Ignoring: TraceC :: m a -> TraceC (m :: Type -> Type) a
- Control.Carrier.Trace.Ignoring: newtype TraceC m a
+ Control.Carrier.Trace.Ignoring: newtype TraceC (m :: Type -> Type) a
- Control.Carrier.Trace.Printing: TraceC :: m a -> TraceC m a
+ Control.Carrier.Trace.Printing: TraceC :: m a -> TraceC (m :: Type -> Type) a
- Control.Carrier.Trace.Printing: newtype TraceC m a
+ Control.Carrier.Trace.Printing: newtype TraceC (m :: Type -> Type) a
- Control.Carrier.Trace.Returning: TraceC :: WriterC (Endo [String]) m a -> TraceC m a
+ Control.Carrier.Trace.Returning: TraceC :: WriterC (Endo [String]) m a -> TraceC (m :: Type -> Type) a
- Control.Carrier.Trace.Returning: newtype TraceC m a
+ Control.Carrier.Trace.Returning: newtype TraceC (m :: Type -> Type) a
- Control.Carrier.Writer.Church: WriterC :: StateC w m a -> WriterC w m a
+ Control.Carrier.Writer.Church: WriterC :: StateC w m a -> WriterC w (m :: Type -> Type) a
- Control.Carrier.Writer.Church: newtype WriterC w m a
+ Control.Carrier.Writer.Church: newtype WriterC w (m :: Type -> Type) a
- Control.Carrier.Writer.Strict: WriterC :: StateC w m a -> WriterC w m a
+ Control.Carrier.Writer.Strict: WriterC :: StateC w m a -> WriterC w (m :: Type -> Type) a
- Control.Carrier.Writer.Strict: newtype WriterC w m a
+ Control.Carrier.Writer.Strict: newtype WriterC w (m :: Type -> Type) a
- Control.Effect.Accum: [Add] :: w -> Accum w m ()
+ Control.Effect.Accum: [Add] :: forall w (m :: Type -> Type). w -> Accum w m ()
- Control.Effect.Accum: [Look] :: Accum w m w
+ Control.Effect.Accum: [Look] :: forall w (m :: Type -> Type). Accum w m w
- Control.Effect.Accum: add :: Has (Accum w) sig m => w -> m ()
+ Control.Effect.Accum: add :: forall w (sig :: (Type -> Type) -> Type -> Type) m. Has (Accum w) sig m => w -> m ()
- Control.Effect.Accum: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Accum: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Accum: look :: Has (Accum w) sig m => m w
+ Control.Effect.Accum: look :: forall w (sig :: (Type -> Type) -> Type -> Type) m. Has (Accum w) sig m => m w
- Control.Effect.Accum: looks :: Has (Accum w) sig m => (w -> a) -> m a
+ Control.Effect.Accum: looks :: forall w (sig :: (Type -> Type) -> Type -> Type) m a. Has (Accum w) sig m => (w -> a) -> m a
- Control.Effect.Accum: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Accum: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Catch: [Catch] :: m a -> (e -> m a) -> Catch e m a
+ Control.Effect.Catch: [Catch] :: forall (m :: Type -> Type) k e. m k -> (e -> m k) -> Catch e m k
- Control.Effect.Catch: catchError :: Has (Catch e) sig m => m a -> (e -> m a) -> m a
+ Control.Effect.Catch: catchError :: forall e (sig :: (Type -> Type) -> Type -> Type) m a. Has (Catch e) sig m => m a -> (e -> m a) -> m a
- Control.Effect.Catch: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Catch: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Catch: data Catch e m k
+ Control.Effect.Catch: data Catch e (m :: Type -> Type) k
- Control.Effect.Catch: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Catch: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Choose: (<|>) :: Has Choose sig m => m a -> m a -> m a
+ Control.Effect.Choose: (<|>) :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Choose sig m => m a -> m a -> m a
- Control.Effect.Choose: Choosing :: m a -> Choosing m a
+ Control.Effect.Choose: Choosing :: m a -> Choosing (m :: Type -> Type) a
- Control.Effect.Choose: [Choose] :: Choose m Bool
+ Control.Effect.Choose: [Choose] :: forall (m :: Type -> Type). Choose m Bool
- Control.Effect.Choose: [getChoosing] :: Choosing m a -> m a
+ Control.Effect.Choose: [getChoosing] :: Choosing (m :: Type -> Type) a -> m a
- Control.Effect.Choose: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Choose: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Choose: many :: Has Choose sig m => m a -> m [a]
+ Control.Effect.Choose: many :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Choose sig m => m a -> m [a]
- Control.Effect.Choose: newtype Choosing m a
+ Control.Effect.Choose: newtype Choosing (m :: Type -> Type) a
- Control.Effect.Choose: optional :: Has Choose sig m => m a -> m (Maybe a)
+ Control.Effect.Choose: optional :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Choose sig m => m a -> m (Maybe a)
- Control.Effect.Choose: some :: Has Choose sig m => m a -> m [a]
+ Control.Effect.Choose: some :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Choose sig m => m a -> m [a]
- Control.Effect.Choose: some1 :: Has Choose sig m => m a -> m (NonEmpty a)
+ Control.Effect.Choose: some1 :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Choose sig m => m a -> m (NonEmpty a)
- Control.Effect.Choose: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Choose: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Cull: [Cull] :: m a -> Cull m a
+ Control.Effect.Cull: [Cull] :: forall (m :: Type -> Type) k. m k -> Cull m k
- Control.Effect.Cull: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Cull: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Cull: cull :: Has Cull sig m => m a -> m a
+ Control.Effect.Cull: cull :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Cull sig m => m a -> m a
- Control.Effect.Cull: data Cull m k
+ Control.Effect.Cull: data Cull (m :: Type -> Type) k
- Control.Effect.Cull: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Cull: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Cut: [Call] :: m a -> Cut m a
+ Control.Effect.Cut: [Call] :: forall (m :: Type -> Type) k. m k -> Cut m k
- Control.Effect.Cut: [Cutfail] :: Cut m a
+ Control.Effect.Cut: [Cutfail] :: forall (m :: Type -> Type) k. Cut m k
- Control.Effect.Cut: call :: Has Cut sig m => m a -> m a
+ Control.Effect.Cut: call :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Cut sig m => m a -> m a
- Control.Effect.Cut: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Cut: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Cut: cut :: (Alternative m, Has Cut sig m) => m ()
+ Control.Effect.Cut: cut :: forall m (sig :: (Type -> Type) -> Type -> Type). (Alternative m, Has Cut sig m) => m ()
- Control.Effect.Cut: cutfail :: Has Cut sig m => m a
+ Control.Effect.Cut: cutfail :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Cut sig m => m a
- Control.Effect.Cut: data Cut m k
+ Control.Effect.Cut: data Cut (m :: Type -> Type) k
- Control.Effect.Cut: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Cut: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Empty: [Empty] :: Empty m a
+ Control.Effect.Empty: [Empty] :: forall (m :: Type -> Type) k. Empty m k
- Control.Effect.Empty: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Empty: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Empty: empty :: Has Empty sig m => m a
+ Control.Effect.Empty: empty :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has Empty sig m => m a
- Control.Effect.Empty: guard :: Has Empty sig m => Bool -> m ()
+ Control.Effect.Empty: guard :: forall (sig :: (Type -> Type) -> Type -> Type) m. Has Empty sig m => Bool -> m ()
- Control.Effect.Empty: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Empty: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Fail: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Fail: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Fail: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Fail: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Fresh: [Fresh] :: Fresh m Int
+ Control.Effect.Fresh: [Fresh] :: forall (m :: Type -> Type). Fresh m Int
- Control.Effect.Fresh: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Fresh: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Fresh: fresh :: Has Fresh sig m => m Int
+ Control.Effect.Fresh: fresh :: forall (sig :: (Type -> Type) -> Type -> Type) m. Has Fresh sig m => m Int
- Control.Effect.Fresh: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Fresh: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Labelled: Labelled :: sub m a -> Labelled (label :: k) (sub :: (Type -> Type) -> Type -> Type) m a
+ Control.Effect.Labelled: Labelled :: sub m a -> Labelled (label :: k) (sub :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a
- Control.Effect.Labelled: class LabelledMember label (sub :: (Type -> Type) -> (Type -> Type)) sup | label sup -> sub
+ Control.Effect.Labelled: class LabelledMember (label :: k) (sub :: Type -> Type -> Type -> Type) (sup :: Type -> Type -> Type -> Type) | label sup -> sub
- Control.Effect.Labelled: injLabelled :: LabelledMember label sub sup => Labelled label sub m a -> sup m a
+ Control.Effect.Labelled: injLabelled :: forall (m :: Type -> Type) a. LabelledMember label sub sup => Labelled label sub m a -> sup m a
- Control.Effect.Labelled: newtype Labelled (label :: k) (sub :: (Type -> Type) -> (Type -> Type)) m a
+ Control.Effect.Labelled: newtype Labelled (label :: k) (sub :: Type -> Type -> Type -> Type) (m :: Type -> Type) a
- Control.Effect.Labelled: newtype UnderLabel (label :: k) (sub :: (Type -> Type) -> (Type -> Type)) (m :: Type -> Type) a
+ Control.Effect.Labelled: newtype UnderLabel (label :: k) (sub :: Type -> Type -> Type -> Type) (m :: Type -> Type) a
- Control.Effect.Labelled: runLabelled :: forall label sub m a. Labelled label sub m a -> sub m a
+ Control.Effect.Labelled: runLabelled :: forall {k} (label :: k) sub (m :: Type -> Type) a. Labelled label sub m a -> sub m a
- Control.Effect.Labelled: runUnderLabel :: forall label sub m a. UnderLabel label sub m a -> m a
+ Control.Effect.Labelled: runUnderLabel :: forall {k} (label :: k) (sub :: (Type -> Type) -> Type -> Type) m a. UnderLabel label sub m a -> m a
- Control.Effect.Labelled: sendLabelled :: forall label eff sig m a. HasLabelled label eff sig m => eff m a -> m a
+ Control.Effect.Labelled: sendLabelled :: forall {k} (label :: k) eff (sig :: (Type -> Type) -> Type -> Type) m a. HasLabelled label eff sig m => eff m a -> m a
- Control.Effect.Labelled: type HasLabelled label eff sig m = (LabelledMember label eff sig, Algebra sig m)
+ Control.Effect.Labelled: type HasLabelled (label :: k) (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (LabelledMember label eff sig, Algebra sig m)
- Control.Effect.Lift: [LiftWith] :: (forall ctx. Functor ctx => Handler ctx m sig -> ctx () -> sig (ctx a)) -> Lift sig m a
+ Control.Effect.Lift: [LiftWith] :: forall (m :: Type -> Type) (sig :: Type -> Type) k. (forall (ctx :: Type -> Type). Functor ctx => Handler ctx m sig -> ctx () -> sig (ctx k)) -> Lift sig m k
- Control.Effect.Lift: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Lift: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Lift: data Lift sig m k
+ Control.Effect.Lift: data Lift (sig :: Type -> Type) (m :: Type -> Type) k
- Control.Effect.Lift: liftWith :: Has (Lift n) sig m => (forall ctx. Functor ctx => Handler ctx m n -> ctx () -> n (ctx a)) -> m a
+ Control.Effect.Lift: liftWith :: forall n (sig :: (Type -> Type) -> Type -> Type) m a. Has (Lift n) sig m => (forall (ctx :: Type -> Type). Functor ctx => Handler ctx m n -> ctx () -> n (ctx a)) -> m a
- Control.Effect.Lift: sendIO :: Has (Lift IO) sig m => IO a -> m a
+ Control.Effect.Lift: sendIO :: forall (sig :: (Type -> Type) -> Type -> Type) m a. Has (Lift IO) sig m => IO a -> m a
- Control.Effect.Lift: sendM :: (Has (Lift n) sig m, Functor n) => n a -> m a
+ Control.Effect.Lift: sendM :: forall n (sig :: (Type -> Type) -> Type -> Type) m a. (Has (Lift n) sig m, Functor n) => n a -> m a
- Control.Effect.Lift: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Lift: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.NonDet: [Choose] :: Choose m Bool
+ Control.Effect.NonDet: [Choose] :: forall (m :: Type -> Type). Choose m Bool
- Control.Effect.NonDet: [Empty] :: Empty m a
+ Control.Effect.NonDet: [Empty] :: forall (m :: Type -> Type) k. Empty m k
- Control.Effect.NonDet: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.NonDet: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.NonDet: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.NonDet: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Reader: [Ask] :: Reader r m r
+ Control.Effect.Reader: [Ask] :: forall r (m :: Type -> Type). Reader r m r
- Control.Effect.Reader: [Local] :: (r -> r) -> m a -> Reader r m a
+ Control.Effect.Reader: [Local] :: forall r (m :: Type -> Type) k. (r -> r) -> m k -> Reader r m k
- Control.Effect.Reader: ask :: Has (Reader r) sig m => m r
+ Control.Effect.Reader: ask :: forall r (sig :: (Type -> Type) -> Type -> Type) m. Has (Reader r) sig m => m r
- Control.Effect.Reader: asks :: Has (Reader r) sig m => (r -> a) -> m a
+ Control.Effect.Reader: asks :: forall r (sig :: (Type -> Type) -> Type -> Type) m a. Has (Reader r) sig m => (r -> a) -> m a
- Control.Effect.Reader: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Reader: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Reader: data Reader r m k
+ Control.Effect.Reader: data Reader r (m :: Type -> Type) k
- Control.Effect.Reader: local :: Has (Reader r) sig m => (r -> r) -> m a -> m a
+ Control.Effect.Reader: local :: forall r (sig :: (Type -> Type) -> Type -> Type) m a. Has (Reader r) sig m => (r -> r) -> m a -> m a
- Control.Effect.Reader: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Reader: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Reader.Labelled: ask :: forall label r m sig. HasLabelled label (Reader r) sig m => m r
+ Control.Effect.Reader.Labelled: ask :: forall {k} (label :: k) r m (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (Reader r) sig m => m r
- Control.Effect.Reader.Labelled: asks :: forall label r m a sig. HasLabelled label (Reader r) sig m => (r -> a) -> m a
+ Control.Effect.Reader.Labelled: asks :: forall {k} (label :: k) r m a (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (Reader r) sig m => (r -> a) -> m a
- Control.Effect.Reader.Labelled: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Reader.Labelled: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Reader.Labelled: data Reader r m k
+ Control.Effect.Reader.Labelled: data Reader r (m :: Type -> Type) k
- Control.Effect.Reader.Labelled: local :: forall label r m a sig. HasLabelled label (Reader r) sig m => (r -> r) -> m a -> m a
+ Control.Effect.Reader.Labelled: local :: forall {k} (label :: k) r m a (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (Reader r) sig m => (r -> r) -> m a -> m a
- Control.Effect.Reader.Labelled: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Reader.Labelled: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Reader.Labelled: type HasLabelled label eff sig m = (LabelledMember label eff sig, Algebra sig m)
+ Control.Effect.Reader.Labelled: type HasLabelled (label :: k) (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (LabelledMember label eff sig, Algebra sig m)
- Control.Effect.State: [Get] :: State s m s
+ Control.Effect.State: [Get] :: forall s (m :: Type -> Type). State s m s
- Control.Effect.State: [Put] :: s -> State s m ()
+ Control.Effect.State: [Put] :: forall s (m :: Type -> Type). s -> State s m ()
- Control.Effect.State: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.State: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.State: get :: Has (State s) sig m => m s
+ Control.Effect.State: get :: forall s (sig :: (Type -> Type) -> Type -> Type) m. Has (State s) sig m => m s
- Control.Effect.State: gets :: Has (State s) sig m => (s -> a) -> m a
+ Control.Effect.State: gets :: forall s (sig :: (Type -> Type) -> Type -> Type) m a. Has (State s) sig m => (s -> a) -> m a
- Control.Effect.State: modify :: Has (State s) sig m => (s -> s) -> m ()
+ Control.Effect.State: modify :: forall s (sig :: (Type -> Type) -> Type -> Type) m. Has (State s) sig m => (s -> s) -> m ()
- Control.Effect.State: modifyLazy :: Has (State s) sig m => (s -> s) -> m ()
+ Control.Effect.State: modifyLazy :: forall s (sig :: (Type -> Type) -> Type -> Type) m. Has (State s) sig m => (s -> s) -> m ()
- Control.Effect.State: put :: Has (State s) sig m => s -> m ()
+ Control.Effect.State: put :: forall s (sig :: (Type -> Type) -> Type -> Type) m. Has (State s) sig m => s -> m ()
- Control.Effect.State: state :: Has (State s) sig m => (s -> (s, a)) -> m a
+ Control.Effect.State: state :: forall s (sig :: (Type -> Type) -> Type -> Type) m a. Has (State s) sig m => (s -> (s, a)) -> m a
- Control.Effect.State: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.State: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.State.Labelled: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.State.Labelled: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.State.Labelled: get :: forall label s m sig. HasLabelled label (State s) sig m => m s
+ Control.Effect.State.Labelled: get :: forall {k} (label :: k) s m (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => m s
- Control.Effect.State.Labelled: gets :: forall label s m a sig. HasLabelled label (State s) sig m => (s -> a) -> m a
+ Control.Effect.State.Labelled: gets :: forall {k} (label :: k) s m a (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => (s -> a) -> m a
- Control.Effect.State.Labelled: modify :: forall label s m sig. HasLabelled label (State s) sig m => (s -> s) -> m ()
+ Control.Effect.State.Labelled: modify :: forall {k} (label :: k) s m (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => (s -> s) -> m ()
- Control.Effect.State.Labelled: modifyLazy :: forall label s m sig. HasLabelled label (State s) sig m => (s -> s) -> m ()
+ Control.Effect.State.Labelled: modifyLazy :: forall {k} (label :: k) s m (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => (s -> s) -> m ()
- Control.Effect.State.Labelled: put :: forall label s m sig. HasLabelled label (State s) sig m => s -> m ()
+ Control.Effect.State.Labelled: put :: forall {k} (label :: k) s m (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => s -> m ()
- Control.Effect.State.Labelled: state :: forall label s m a sig. HasLabelled label (State s) sig m => (s -> (s, a)) -> m a
+ Control.Effect.State.Labelled: state :: forall {k} (label :: k) s m a (sig :: (Type -> Type) -> Type -> Type). HasLabelled label (State s) sig m => (s -> (s, a)) -> m a
- Control.Effect.State.Labelled: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.State.Labelled: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.State.Labelled: type HasLabelled label eff sig m = (LabelledMember label eff sig, Algebra sig m)
+ Control.Effect.State.Labelled: type HasLabelled (label :: k) (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (LabelledMember label eff sig, Algebra sig m)
- Control.Effect.Sum: L :: f m k -> (:+:) f g (m :: Type -> Type) k
+ Control.Effect.Sum: L :: f m k -> (:+:) (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) k
- Control.Effect.Sum: R :: g m k -> (:+:) f g (m :: Type -> Type) k
+ Control.Effect.Sum: R :: g m k -> (:+:) (f :: (Type -> Type) -> Type -> Type) (g :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) k
- Control.Effect.Sum: class Member (sub :: (Type -> Type) -> (Type -> Type)) sup
+ Control.Effect.Sum: class Member (sub :: Type -> Type -> Type -> Type) (sup :: Type -> Type -> Type -> Type)
- Control.Effect.Sum: data ( f :+: g ) (m :: Type -> Type) k
+ Control.Effect.Sum: data ( (f :: Type -> Type -> Type -> Type) :+: (g :: Type -> Type -> Type -> Type) ) (m :: Type -> Type) k
- Control.Effect.Sum: inj :: Member sub sup => sub m a -> sup m a
+ Control.Effect.Sum: inj :: forall (m :: Type -> Type) a. Member sub sup => sub m a -> sup m a
- Control.Effect.Sum: reassociateSumL :: (l1 :+: (l2 :+: r)) m a -> ((l1 :+: l2) :+: r) m a
+ Control.Effect.Sum: reassociateSumL :: forall (l1 :: (Type -> Type) -> Type -> Type) (l2 :: (Type -> Type) -> Type -> Type) (r :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a. (l1 :+: (l2 :+: r)) m a -> ((l1 :+: l2) :+: r) m a
- Control.Effect.Sum: type family Members sub sup :: Constraint
+ Control.Effect.Sum: type family Members (sub :: Type -> Type -> Type -> Type) (sup :: Type -> Type -> Type -> Type)
- Control.Effect.Throw: [Throw] :: e -> Throw e m a
+ Control.Effect.Throw: [Throw] :: forall e (m :: Type -> Type) k. e -> Throw e m k
- Control.Effect.Throw: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Throw: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Throw: liftEither :: Has (Throw e) sig m => Either e a -> m a
+ Control.Effect.Throw: liftEither :: forall e (sig :: (Type -> Type) -> Type -> Type) m a. Has (Throw e) sig m => Either e a -> m a
- Control.Effect.Throw: throwError :: Has (Throw e) sig m => e -> m a
+ Control.Effect.Throw: throwError :: forall e (sig :: (Type -> Type) -> Type -> Type) m a. Has (Throw e) sig m => e -> m a
- Control.Effect.Throw: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Throw: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Trace: [Trace] :: String -> Trace m ()
+ Control.Effect.Trace: [Trace] :: forall (m :: Type -> Type). String -> Trace m ()
- Control.Effect.Trace: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Trace: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Trace: trace :: Has Trace sig m => String -> m ()
+ Control.Effect.Trace: trace :: forall (sig :: (Type -> Type) -> Type -> Type) m. Has Trace sig m => String -> m ()
- Control.Effect.Trace: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Trace: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)
- Control.Effect.Writer: [Censor] :: (w -> w) -> m a -> Writer w m a
+ Control.Effect.Writer: [Censor] :: forall w (m :: Type -> Type) k. (w -> w) -> m k -> Writer w m k
- Control.Effect.Writer: [Listen] :: m a -> Writer w m (w, a)
+ Control.Effect.Writer: [Listen] :: forall (m :: Type -> Type) a w. m a -> Writer w m (w, a)
- Control.Effect.Writer: [Tell] :: w -> Writer w m ()
+ Control.Effect.Writer: [Tell] :: forall w (m :: Type -> Type). w -> Writer w m ()
- Control.Effect.Writer: censor :: Has (Writer w) sig m => (w -> w) -> m a -> m a
+ Control.Effect.Writer: censor :: forall w (sig :: (Type -> Type) -> Type -> Type) m a. Has (Writer w) sig m => (w -> w) -> m a -> m a
- Control.Effect.Writer: class Monad m => Algebra sig m | m -> sig
+ Control.Effect.Writer: class Monad m => Algebra (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) | m -> sig
- Control.Effect.Writer: data Writer w m k
+ Control.Effect.Writer: data Writer w (m :: Type -> Type) k
- Control.Effect.Writer: listen :: Has (Writer w) sig m => m a -> m (w, a)
+ Control.Effect.Writer: listen :: forall w (sig :: (Type -> Type) -> Type -> Type) m a. Has (Writer w) sig m => m a -> m (w, a)
- Control.Effect.Writer: listens :: Has (Writer w) sig m => (w -> b) -> m a -> m (b, a)
+ Control.Effect.Writer: listens :: forall w (sig :: (Type -> Type) -> Type -> Type) m b a. Has (Writer w) sig m => (w -> b) -> m a -> m (b, a)
- Control.Effect.Writer: tell :: Has (Writer w) sig m => w -> m ()
+ Control.Effect.Writer: tell :: forall w (sig :: (Type -> Type) -> Type -> Type) m. Has (Writer w) sig m => w -> m ()
- Control.Effect.Writer: type Has eff sig m = (Members eff sig, Algebra sig m)
+ Control.Effect.Writer: type Has (eff :: Type -> Type -> Type -> Type) (sig :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Members eff sig, Algebra sig m)

Files

ChangeLog.md view
@@ -1,3 +1,7 @@+# v1.1.2.3++- Adds support for `ghc` 9.8 and 9.10, `base` 4.19 and 4.20, and `containers` 0.7.+ # v1.1.2.2  - Adds support for `ghc` 9.6, `base` 4.18, and `transformers` 0.6.
benchmark/Bench/NonDet/NQueens.hs view
@@ -4,6 +4,7 @@ {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-redundant-constraints #-}+{-# OPTIONS_GHC -Wno-unused-imports #-}  -- Based largely on the implementation by Sreekar Shastry, -- available at https://github.com/sshastry/queenslogic
fused-effects.cabal view
@@ -1,7 +1,7 @@ cabal-version:       2.2  name:                fused-effects-version:             1.1.2.2+version:             1.1.2.3 synopsis:            A fast, flexible, fused effect system. description:         A fast, flexible, fused effect system, à la Effect Handlers in Scope, Monad Transformers and Modular Algebraic Effects: What Binds Them Together, and Fusion for Free—Efficient Algebraic Effect Handlers. homepage:            https://github.com/fused-effects/fused-effects@@ -27,6 +27,8 @@   GHC == 9.2.1   GHC == 9.4.2   GHC == 9.6.2+  GHC == 9.8.2+  GHC == 9.10.1  common common   default-language: Haskell2010@@ -56,6 +58,12 @@   if (impl(ghc >= 9.6))     ghc-options:       -Wno-redundant-constraints+  if (impl(ghc >= 9.8))+    ghc-options:+      -Wno-missing-role-annotations+      -Wno-term-variable-capture+      -Wno-x-partial+      -Wno-missing-poly-kind-signatures    library   import:         common@@ -125,7 +133,7 @@     Control.Effect.Throw.Internal     Control.Effect.Writer.Internal   build-depends:-      base          >= 4.9 && < 4.19+      base          >= 4.9 && < 4.21     , transformers  >= 0.4 && < 0.7     , unliftio-core >= 0.2 && < 0.3 @@ -145,7 +153,7 @@   build-depends:     , base     , fused-effects-    , hedgehog           >= 1 && < 1.3+    , hedgehog           >= 1 && < 1.6     , hedgehog-fn        ^>= 1  @@ -178,7 +186,7 @@     Writer   build-depends:     , base-    , containers          >= 0.5 && < 0.7+    , containers          >= 0.5 && < 0.8     , fused-effects     , hedgehog     , hedgehog-fn
src/Control/Carrier/Accum/Strict.hs view
@@ -10,7 +10,7 @@ These appends are left-associative; as such, @[]@ is a poor choice of monoid for computations that entail many calls to 'tell'. The [Seq](http://hackage.haskell.org/package/containersdocs/Data-Sequence.html) or [DList](http://hackage.haskell.org/package/dlist) monoids may be a superior choice. --- | @since 1.1.2.0+@since 1.1.2.0 -}  module Control.Carrier.Accum.Strict
src/Control/Effect/Labelled.hs view
@@ -41,7 +41,7 @@ import Control.Monad.IO.Class import Control.Monad.Trans.Class import Data.Functor.Identity-import Data.Kind (Type)+import Data.Kind  -- | An effect transformer turning effects into labelled effects, and a carrier transformer turning carriers into labelled carriers for the same (labelled) effects. --