ether 0.4.0.2 → 0.4.1.0
raw patch · 3 files changed
+7/−2 lines, 3 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Control.Monad.Ether.Except.Class: instance forall (k :: BOX) (tag :: k) e (t :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Trans.Lift.Catch.LiftCatch t, GHC.Base.Monad (t m), Control.Monad.Ether.Except.Class.MonadExcept tag e m) => Control.Monad.Ether.Except.Class.MonadExcept tag e (t m)
- Control.Monad.Ether.Except.Class: instance forall (k :: BOX) (tag :: k) e e' (m :: * -> *). (GHC.Base.Monad m, e ~ e') => Control.Monad.Ether.Except.Class.MonadExcept tag e (Control.Monad.Trans.Ether.Except.ExceptT tag e' m)
- Control.Monad.Ether.Reader.Class: instance forall (k :: BOX) (tag :: k) r (t :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Trans.Lift.Local.LiftLocal t, GHC.Base.Monad (t m), Control.Monad.Ether.Reader.Class.MonadReader tag r m) => Control.Monad.Ether.Reader.Class.MonadReader tag r (t m)
- Control.Monad.Ether.Reader.Class: instance forall (k :: BOX) (tag :: k) r r' (m :: * -> *). (GHC.Base.Monad m, r ~ r') => Control.Monad.Ether.Reader.Class.MonadReader tag r (Control.Monad.Trans.Ether.Reader.ReaderT tag r' m)
- Control.Monad.Ether.State.Class: instance forall (k :: BOX) (tag :: k) s (t :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Ether.State.Class.MonadState tag s m) => Control.Monad.Ether.State.Class.MonadState tag s (t m)
- Control.Monad.Ether.State.Class: instance forall (k :: BOX) (tag :: k) s s' (m :: * -> *). (GHC.Base.Monad m, s ~ s') => Control.Monad.Ether.State.Class.MonadState tag s (Control.Monad.Trans.Ether.State.Lazy.StateT tag s' m)
- Control.Monad.Ether.State.Class: instance forall (k :: BOX) (tag :: k) s s' (m :: * -> *). (GHC.Base.Monad m, s ~ s') => Control.Monad.Ether.State.Class.MonadState tag s (Control.Monad.Trans.Ether.State.Strict.StateT tag s' m)
- Control.Monad.Ether.Writer.Class: instance forall (k :: BOX) (tag :: k) w (t :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Trans.Lift.Listen.LiftListen t, Control.Monad.Trans.Lift.Pass.LiftPass t, GHC.Base.Monad (t m), Control.Monad.Ether.Writer.Class.MonadWriter tag w m, GHC.Base.Monoid w) => Control.Monad.Ether.Writer.Class.MonadWriter tag w (t m)
- Control.Monad.Ether.Writer.Class: instance forall (k :: BOX) (tag :: k) w w' (m :: * -> *). (GHC.Base.Monoid w, GHC.Base.Monad m, w ~ w') => Control.Monad.Ether.Writer.Class.MonadWriter tag w (Control.Monad.Trans.Ether.Writer.WriterT tag w' m)
- Control.Monad.Trans.Ether.Dispatch: data DispatchT dp m a
- Control.Monad.Trans.Ether.Dispatch: instance GHC.Generics.Constructor Control.Monad.Trans.Ether.Dispatch.C1_0DispatchT
- Control.Monad.Trans.Ether.Dispatch: instance GHC.Generics.Datatype Control.Monad.Trans.Ether.Dispatch.D1DispatchT
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (b :: * -> *) (dp :: k) (m :: * -> *). Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (b :: * -> *) (dp :: k) (m :: * -> *). Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *) a. GHC.Generics.Generic (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m a)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). GHC.Base.Alternative m => GHC.Base.Alternative (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k) (m :: * -> *). GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Morph.MFunctor (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Morph.MMonad (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Lift.CallCC.LiftCallCC (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Lift.Catch.LiftCatch (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Lift.Listen.LiftListen (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Lift.Local.LiftLocal (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (dp :: k). Control.Monad.Trans.Lift.Pass.LiftPass (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (k1 :: BOX) (tOld :: k) e (tNew :: k1) (m :: * -> *). Control.Monad.Ether.Except.Class.MonadExcept tNew e m => Control.Monad.Ether.Except.Class.MonadExcept tOld e (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld tNew m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (k1 :: BOX) (tOld :: k) r (tNew :: k1) (m :: * -> *). Control.Monad.Ether.Reader.Class.MonadReader tNew r m => Control.Monad.Ether.Reader.Class.MonadReader tOld r (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld tNew m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (k1 :: BOX) (tOld :: k) s (tNew :: k1) (m :: * -> *). Control.Monad.Ether.State.Class.MonadState tNew s m => Control.Monad.Ether.State.Class.MonadState tOld s (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld tNew m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) (k1 :: BOX) (tOld :: k) w (tNew :: k1) (m :: * -> *). Control.Monad.Ether.Writer.Class.MonadWriter tNew w m => Control.Monad.Ether.Writer.Class.MonadWriter tOld w (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld tNew m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) e (tag :: k) (m :: * -> *). Control.Monad.Ether.Except.Class.MonadExcept tag e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) r (tag :: k) (m :: * -> *). Control.Monad.Ether.Reader.Class.MonadReader tag r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) s (tag :: k) (m :: * -> *). Control.Monad.Ether.State.Class.MonadState tag s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
- Control.Monad.Trans.Ether.Dispatch: instance forall (k :: BOX) w (tag :: k) (m :: * -> *). Control.Monad.Ether.Writer.Class.MonadWriter tag w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
- Control.Monad.Trans.Ether.Tagged: instance GHC.Generics.Constructor Control.Monad.Trans.Ether.Tagged.C1_0TaggedTrans
- Control.Monad.Trans.Ether.Tagged: instance GHC.Generics.Datatype Control.Monad.Trans.Ether.Tagged.D1TaggedTrans
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (b :: * -> *) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Base.MonadBase b m, Control.Monad.Trans.Class.MonadTrans trans, Control.Ether.Util.MonadApplicative (trans m)) => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (b :: * -> *) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Trans.Control.MonadBaseControl b m, Control.Monad.Trans.Control.MonadTransControl trans, Control.Ether.Util.MonadApplicative (trans m)) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (k1 :: BOX) (tag :: k) (trans :: (* -> *) -> k1 -> *) (m :: * -> *) (a :: k1). GHC.Generics.Generic (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m a)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Cont.Class.MonadCont m, Control.Monad.Trans.Lift.CallCC.LiftCallCC trans, GHC.Base.Monad (trans m)) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Catch.MonadCatch (trans m) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Catch.MonadMask (trans m) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Catch.MonadThrow (trans m) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.Fix.MonadFix (trans m) => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). Control.Monad.IO.Class.MonadIO (trans m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Alternative (trans m) => GHC.Base.Alternative (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Applicative (trans m) => GHC.Base.Applicative (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Functor (trans m) => GHC.Base.Functor (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.Monad (trans m) => GHC.Base.Monad (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). GHC.Base.MonadPlus (trans m) => GHC.Base.MonadPlus (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Morph.MFunctor trans => Control.Monad.Morph.MFunctor (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Morph.MMonad trans => Control.Monad.Morph.MMonad (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Class.MonadTrans trans => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Control.MonadTransControl trans => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Lift.CallCC.LiftCallCC trans => Control.Monad.Trans.Lift.CallCC.LiftCallCC (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Lift.Catch.LiftCatch trans => Control.Monad.Trans.Lift.Catch.LiftCatch (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Lift.Listen.LiftListen trans => Control.Monad.Trans.Lift.Listen.LiftListen (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Lift.Local.LiftLocal trans => Control.Monad.Trans.Lift.Local.LiftLocal (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) (tag :: k) (trans :: (* -> *) -> * -> *). Control.Monad.Trans.Lift.Pass.LiftPass trans => Control.Monad.Trans.Lift.Pass.LiftPass (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) e (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Error.Class.MonadError e m, Control.Monad.Trans.Lift.Catch.LiftCatch trans, GHC.Base.Monad (trans m)) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) r (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Reader.Class.MonadReader r m, Control.Monad.Trans.Lift.Local.LiftLocal trans, GHC.Base.Monad (trans m)) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) s (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.State.Class.MonadState s m, Control.Monad.Trans.Class.MonadTrans trans, GHC.Base.Monad (trans m)) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Trans.Ether.Tagged: instance forall (k :: BOX) w (tag :: k) (trans :: (* -> *) -> * -> *) (m :: * -> *). (Control.Monad.Writer.Class.MonadWriter w m, Control.Monad.Trans.Lift.Listen.LiftListen trans, Control.Monad.Trans.Lift.Pass.LiftPass trans, GHC.Base.Monad (trans m)) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Ether.Except.Class: instance forall k (m :: * -> *) e e' (tag :: k). (GHC.Base.Monad m, e ~ e') => Control.Monad.Ether.Except.Class.MonadExcept tag e (Control.Monad.Trans.Ether.Except.ExceptT tag e' m)
+ Control.Monad.Ether.Except.Class: instance forall k (t :: (* -> *) -> * -> *) (m :: * -> *) (tag :: k) e. (Control.Monad.Trans.Lift.Catch.LiftCatch t, GHC.Base.Monad (t m), Control.Monad.Ether.Except.Class.MonadExcept tag e m) => Control.Monad.Ether.Except.Class.MonadExcept tag e (t m)
+ Control.Monad.Ether.Reader.Class: instance forall k (m :: * -> *) r r' (tag :: k). (GHC.Base.Monad m, r ~ r') => Control.Monad.Ether.Reader.Class.MonadReader tag r (Control.Monad.Trans.Ether.Reader.ReaderT tag r' m)
+ Control.Monad.Ether.Reader.Class: instance forall k (t :: (* -> *) -> * -> *) (m :: * -> *) (tag :: k) r. (Control.Monad.Trans.Lift.Local.LiftLocal t, GHC.Base.Monad (t m), Control.Monad.Ether.Reader.Class.MonadReader tag r m) => Control.Monad.Ether.Reader.Class.MonadReader tag r (t m)
+ Control.Monad.Ether.State.Class: instance forall k (m :: * -> *) s s' (tag :: k). (GHC.Base.Monad m, s ~ s') => Control.Monad.Ether.State.Class.MonadState tag s (Control.Monad.Trans.Ether.State.Lazy.StateT tag s' m)
+ Control.Monad.Ether.State.Class: instance forall k (m :: * -> *) s s' (tag :: k). (GHC.Base.Monad m, s ~ s') => Control.Monad.Ether.State.Class.MonadState tag s (Control.Monad.Trans.Ether.State.Strict.StateT tag s' m)
+ Control.Monad.Ether.State.Class: instance forall k (t :: (* -> *) -> * -> *) (m :: * -> *) (tag :: k) s. (Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m), Control.Monad.Ether.State.Class.MonadState tag s m) => Control.Monad.Ether.State.Class.MonadState tag s (t m)
+ Control.Monad.Ether.Writer.Class: instance forall k (t :: (* -> *) -> * -> *) (m :: * -> *) (tag :: k) w. (Control.Monad.Trans.Lift.Listen.LiftListen t, Control.Monad.Trans.Lift.Pass.LiftPass t, GHC.Base.Monad (t m), Control.Monad.Ether.Writer.Class.MonadWriter tag w m, GHC.Base.Monoid w) => Control.Monad.Ether.Writer.Class.MonadWriter tag w (t m)
+ Control.Monad.Ether.Writer.Class: instance forall k w (m :: * -> *) w' (tag :: k). (GHC.Base.Monoid w, GHC.Base.Monad m, w ~ w') => Control.Monad.Ether.Writer.Class.MonadWriter tag w (Control.Monad.Trans.Ether.Writer.WriterT tag w' m)
+ Control.Monad.Trans.Ether.Dispatch: DispatchT :: (IdentityT m a) -> DispatchT dp m a
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (b :: * -> *) (m :: * -> *) (dp :: k). Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (b :: * -> *) (m :: * -> *) (dp :: k). Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). GHC.Base.Alternative m => GHC.Base.Alternative (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) (m :: * -> *). GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k) k1 (m :: k1 -> *) (a :: k1). GHC.Generics.Generic (Control.Monad.Trans.Ether.Dispatch.DispatchT dp m a)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Morph.MFunctor (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Morph.MMonad (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Lift.CallCC.LiftCallCC (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Lift.Catch.LiftCatch (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Lift.Listen.LiftListen (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Lift.Local.LiftLocal (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall k (dp :: k). Control.Monad.Trans.Lift.Pass.LiftPass (Control.Monad.Trans.Ether.Dispatch.DispatchT dp)
+ Control.Monad.Trans.Ether.Dispatch: instance forall t (tag :: t) e (m :: * -> *). Control.Monad.Ether.Except.Class.MonadExcept tag e m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall t (tag :: t) r (m :: * -> *). Control.Monad.Ether.Reader.Class.MonadReader tag r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall t (tag :: t) s (m :: * -> *). Control.Monad.Ether.State.Class.MonadState tag s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall t (tag :: t) w (m :: * -> *). Control.Monad.Ether.Writer.Class.MonadWriter tag w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Ether.Dispatch.DispatchTagAttachT tag m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall tOld tNew (tNew1 :: tNew) e (m :: * -> *) (tOld1 :: tOld). Control.Monad.Ether.Except.Class.MonadExcept tNew1 e m => Control.Monad.Ether.Except.Class.MonadExcept tOld1 e (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld1 tNew1 m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall tOld tNew (tNew1 :: tNew) r (m :: * -> *) (tOld1 :: tOld). Control.Monad.Ether.Reader.Class.MonadReader tNew1 r m => Control.Monad.Ether.Reader.Class.MonadReader tOld1 r (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld1 tNew1 m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall tOld tNew (tNew1 :: tNew) s (m :: * -> *) (tOld1 :: tOld). Control.Monad.Ether.State.Class.MonadState tNew1 s m => Control.Monad.Ether.State.Class.MonadState tOld1 s (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld1 tNew1 m)
+ Control.Monad.Trans.Ether.Dispatch: instance forall tOld tNew (tNew1 :: tNew) w (m :: * -> *) (tOld1 :: tOld). Control.Monad.Ether.Writer.Class.MonadWriter tNew1 w m => Control.Monad.Ether.Writer.Class.MonadWriter tOld1 w (Control.Monad.Trans.Ether.Dispatch.DispatchTagReplaceT tOld1 tNew1 m)
+ Control.Monad.Trans.Ether.Dispatch: newtype DispatchT dp m a
+ Control.Monad.Trans.Ether.Tagged: instance forall k (b :: * -> *) (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Base.MonadBase b m, Control.Monad.Trans.Class.MonadTrans trans, Control.Ether.Util.MonadApplicative (trans m)) => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (b :: * -> *) (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Trans.Control.MonadBaseControl b m, Control.Monad.Trans.Control.MonadTransControl trans, Control.Ether.Util.MonadApplicative (trans m)) => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Cont.Class.MonadCont m, Control.Monad.Trans.Lift.CallCC.LiftCallCC trans, GHC.Base.Monad (trans m)) => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). Control.Monad.Catch.MonadCatch (trans m) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). Control.Monad.Catch.MonadMask (trans m) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). Control.Monad.Catch.MonadThrow (trans m) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). Control.Monad.Fix.MonadFix (trans m) => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). Control.Monad.IO.Class.MonadIO (trans m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). GHC.Base.Alternative (trans m) => GHC.Base.Alternative (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). GHC.Base.Applicative (trans m) => GHC.Base.Applicative (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). GHC.Base.Functor (trans m) => GHC.Base.Functor (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). GHC.Base.Monad (trans m) => GHC.Base.Monad (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *) (m :: GHC.Types.* -> GHC.Types.*). GHC.Base.MonadPlus (trans m) => GHC.Base.MonadPlus (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *). Control.Monad.Morph.MFunctor trans => Control.Monad.Morph.MFunctor (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *). Control.Monad.Morph.MMonad trans => Control.Monad.Morph.MMonad (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) (trans :: (GHC.Types.* -> GHC.Types.*) -> * -> *). Control.Monad.Trans.Class.MonadTrans trans => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (tag :: k) k1 (trans :: (GHC.Types.* -> GHC.Types.*) -> k1 -> *) (m :: GHC.Types.* -> GHC.Types.*) (a :: k1). GHC.Generics.Generic (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m a)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Control.MonadTransControl trans => Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Lift.CallCC.LiftCallCC trans => Control.Monad.Trans.Lift.CallCC.LiftCallCC (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Lift.Catch.LiftCatch trans => Control.Monad.Trans.Lift.Catch.LiftCatch (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Lift.Listen.LiftListen trans => Control.Monad.Trans.Lift.Listen.LiftListen (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Lift.Local.LiftLocal trans => Control.Monad.Trans.Lift.Local.LiftLocal (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k (trans :: (* -> *) -> * -> *) (tag :: k). Control.Monad.Trans.Lift.Pass.LiftPass trans => Control.Monad.Trans.Lift.Pass.LiftPass (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans)
+ Control.Monad.Trans.Ether.Tagged: instance forall k e (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Error.Class.MonadError e m, Control.Monad.Trans.Lift.Catch.LiftCatch trans, GHC.Base.Monad (trans m)) => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k r (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Reader.Class.MonadReader r m, Control.Monad.Trans.Lift.Local.LiftLocal trans, GHC.Base.Monad (trans m)) => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k s (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.State.Class.MonadState s m, Control.Monad.Trans.Class.MonadTrans trans, GHC.Base.Monad (trans m)) => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
+ Control.Monad.Trans.Ether.Tagged: instance forall k w (m :: * -> *) (trans :: (* -> *) -> * -> *) (tag :: k). (Control.Monad.Writer.Class.MonadWriter w m, Control.Monad.Trans.Lift.Listen.LiftListen trans, Control.Monad.Trans.Lift.Pass.LiftPass trans, GHC.Base.Monad (trans m)) => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Trans.Ether.Tagged.TaggedTrans tag trans m)
- Control.Monad.Ether.Implicit.Except: catch :: MonadExcept e m => m a -> (e -> m a) -> m a
+ Control.Monad.Ether.Implicit.Except: catch :: forall e m a. MonadExcept e m => m a -> (e -> m a) -> m a
- Control.Monad.Ether.Implicit.Except: throw :: MonadExcept e m => e -> m a
+ Control.Monad.Ether.Implicit.Except: throw :: forall e m a. MonadExcept e m => e -> m a
- Control.Monad.Ether.Implicit.Reader: ask :: MonadReader r m => m r
+ Control.Monad.Ether.Implicit.Reader: ask :: forall r m. MonadReader r m => m r
- Control.Monad.Ether.Implicit.Reader: asks :: MonadReader r m => (r -> a) -> m a
+ Control.Monad.Ether.Implicit.Reader: asks :: forall r m a. MonadReader r m => (r -> a) -> m a
- Control.Monad.Ether.Implicit.Reader: local :: MonadReader r m => (r -> r) -> m a -> m a
+ Control.Monad.Ether.Implicit.Reader: local :: forall r m a. MonadReader r m => (r -> r) -> m a -> m a
- Control.Monad.Ether.Implicit.Reader: reader :: MonadReader r m => (r -> a) -> m a
+ Control.Monad.Ether.Implicit.Reader: reader :: forall r m a. MonadReader r m => (r -> a) -> m a
- Control.Monad.Ether.Implicit.State.Lazy: get :: MonadState s m => m s
+ Control.Monad.Ether.Implicit.State.Lazy: get :: forall s m. MonadState s m => m s
- Control.Monad.Ether.Implicit.State.Lazy: gets :: MonadState s m => (s -> a) -> m a
+ Control.Monad.Ether.Implicit.State.Lazy: gets :: forall s m a. MonadState s m => (s -> a) -> m a
- Control.Monad.Ether.Implicit.State.Lazy: modify :: MonadState s m => (s -> s) -> m ()
+ Control.Monad.Ether.Implicit.State.Lazy: modify :: forall s m. MonadState s m => (s -> s) -> m ()
- Control.Monad.Ether.Implicit.State.Lazy: put :: MonadState s m => s -> m ()
+ Control.Monad.Ether.Implicit.State.Lazy: put :: forall s m. MonadState s m => s -> m ()
- Control.Monad.Ether.Implicit.State.Lazy: state :: MonadState s m => (s -> (a, s)) -> m a
+ Control.Monad.Ether.Implicit.State.Lazy: state :: forall s m a. MonadState s m => (s -> (a, s)) -> m a
- Control.Monad.Ether.Implicit.State.Strict: get :: MonadState s m => m s
+ Control.Monad.Ether.Implicit.State.Strict: get :: forall s m. MonadState s m => m s
- Control.Monad.Ether.Implicit.State.Strict: gets :: MonadState s m => (s -> a) -> m a
+ Control.Monad.Ether.Implicit.State.Strict: gets :: forall s m a. MonadState s m => (s -> a) -> m a
- Control.Monad.Ether.Implicit.State.Strict: modify :: MonadState s m => (s -> s) -> m ()
+ Control.Monad.Ether.Implicit.State.Strict: modify :: forall s m. MonadState s m => (s -> s) -> m ()
- Control.Monad.Ether.Implicit.State.Strict: put :: MonadState s m => s -> m ()
+ Control.Monad.Ether.Implicit.State.Strict: put :: forall s m. MonadState s m => s -> m ()
- Control.Monad.Ether.Implicit.State.Strict: state :: MonadState s m => (s -> (a, s)) -> m a
+ Control.Monad.Ether.Implicit.State.Strict: state :: forall s m a. MonadState s m => (s -> (a, s)) -> m a
- Control.Monad.Ether.Implicit.Writer: censor :: MonadWriter w m => (w -> w) -> m a -> m a
+ Control.Monad.Ether.Implicit.Writer: censor :: forall w m a. MonadWriter w m => (w -> w) -> m a -> m a
- Control.Monad.Ether.Implicit.Writer: listen :: MonadWriter w m => m a -> m (a, w)
+ Control.Monad.Ether.Implicit.Writer: listen :: forall w m a. MonadWriter w m => m a -> m (a, w)
- Control.Monad.Ether.Implicit.Writer: listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
+ Control.Monad.Ether.Implicit.Writer: listens :: forall w m a b. MonadWriter w m => (w -> b) -> m a -> m (a, b)
- Control.Monad.Ether.Implicit.Writer: pass :: MonadWriter w m => m (a, w -> w) -> m a
+ Control.Monad.Ether.Implicit.Writer: pass :: forall w m a. MonadWriter w m => m (a, w -> w) -> m a
- Control.Monad.Ether.Implicit.Writer: tell :: MonadWriter w m => w -> m ()
+ Control.Monad.Ether.Implicit.Writer: tell :: forall w m. MonadWriter w m => w -> m ()
- Control.Monad.Ether.Implicit.Writer: writer :: MonadWriter w m => (a, w) -> m a
+ Control.Monad.Ether.Implicit.Writer: writer :: forall w m a. MonadWriter w m => (a, w) -> m a
- Control.Monad.Trans.Ether.Writer: listen :: (Monad m, Monoid w) => proxy tag -> WriterT tag w m a -> WriterT tag w m (a, w)
+ Control.Monad.Trans.Ether.Writer: listen :: Monad m => proxy tag -> WriterT tag w m a -> WriterT tag w m (a, w)
- Control.Monad.Trans.Ether.Writer: pass :: (Monad m, Monoid w) => proxy tag -> WriterT tag w m (a, w -> w) -> WriterT tag w m a
+ Control.Monad.Trans.Ether.Writer: pass :: Monad m => proxy tag -> WriterT tag w m (a, w -> w) -> WriterT tag w m a
Files
- CHANGELOG.md +5/−0
- ether.cabal +1/−1
- src/Control/Monad/Trans/Ether/Dispatch.hs +1/−1
CHANGELOG.md view
@@ -1,3 +1,8 @@+0.4.1.0+-------++* Export DispatchT newtype constructor.+ 0.4.0.0 -------
ether.cabal view
@@ -1,5 +1,5 @@ name: ether-version: 0.4.0.2+version: 0.4.1.0 synopsis: Monad transformers and classes description: Ether is a Haskell library that extends @mtl@ and @transformers@ with
src/Control/Monad/Trans/Ether/Dispatch.hs view
@@ -49,7 +49,7 @@ module Control.Monad.Trans.Ether.Dispatch ( -- * The DispatchT monad transformer- DispatchT+ DispatchT(..) -- * Dispatch types and functions , K_TagAttach(..) , K_TagReplace(..)