semigroupoids 5.0.0.3 → 5.0.0.4

raw patch · 2 files changed

+6/−2 lines, 2 filesdep ~doctestPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: doctest

API changes (from Hackage documentation)

- Data.Functor.Alt: instance (Alt f, Alt g) => Alt (Product f g)

- Data.Functor.Alt: instance (Alt f, Functor g) => Alt (Compose f g)

- Data.Functor.Alt: instance (Bind f, Monad f) => Alt (ErrorT e f)

- Data.Functor.Alt: instance (Bind f, Monad f) => Alt (MaybeT f)

- Data.Functor.Alt: instance (Bind f, Monad f, Semigroup e) => Alt (ExceptT e f)

- Data.Functor.Alt: instance Alt (Either a)

- Data.Functor.Alt: instance Alt IO

- Data.Functor.Alt: instance Alt IntMap

- Data.Functor.Alt: instance Alt Maybe

- Data.Functor.Alt: instance Alt NonEmpty

- Data.Functor.Alt: instance Alt Option

- Data.Functor.Alt: instance Alt Seq

- Data.Functor.Alt: instance Alt []

- Data.Functor.Alt: instance Alt f => Alt (Backwards f)

- Data.Functor.Alt: instance Alt f => Alt (IdentityT f)

- Data.Functor.Alt: instance Alt f => Alt (Lift f)

- Data.Functor.Alt: instance Alt f => Alt (RWST r w s f)

- Data.Functor.Alt: instance Alt f => Alt (ReaderT e f)

- Data.Functor.Alt: instance Alt f => Alt (Reverse f)

- Data.Functor.Alt: instance Alt f => Alt (StateT e f)

- Data.Functor.Alt: instance Alt f => Alt (WriterT w f)

- Data.Functor.Alt: instance Alternative f => Alt (WrappedApplicative f)

- Data.Functor.Alt: instance Apply f => Alt (ListT f)

- Data.Functor.Alt: instance ArrowPlus a => Alt (WrappedArrow a b)

- Data.Functor.Alt: instance MonadPlus m => Alt (WrappedMonad m)

- Data.Functor.Alt: instance Ord k => Alt (Map k)

- Data.Functor.Apply: runMaybeApply :: MaybeApply f a -> Either (f a) a

- Data.Functor.Apply: unwrapApplicative :: WrappedApplicative f a -> f a

- Data.Functor.Bind: runMaybeApply :: MaybeApply f a -> Either (f a) a

- Data.Functor.Bind: unwrapApplicative :: WrappedApplicative f a -> f a

- Data.Functor.Bind.Class: instance (Apply f, Apply g) => Apply (Compose f g)

- Data.Functor.Bind.Class: instance (Apply f, Apply g) => Apply (Product f g)

- Data.Functor.Bind.Class: instance (Apply f, Biapply p) => Biapply (Tannen f p)

- Data.Functor.Bind.Class: instance (Apply m, Monad m) => Bind (ListT m)

- Data.Functor.Bind.Class: instance (Apply m, Semigroup w) => Apply (WriterT w m)

- Data.Functor.Bind.Class: instance (Apply w, Semigroup s) => Apply (StoreT s w)

- Data.Functor.Bind.Class: instance (Biapply p, Apply f, Apply g) => Biapply (Biff p f g)

- Data.Functor.Bind.Class: instance (Biapply p, Biapply q) => Biapply (Product p q)

- Data.Functor.Bind.Class: instance (Bind f, Bind g) => Bind (Product f g)

- Data.Functor.Bind.Class: instance (Bind m, Semigroup w) => Apply (RWST r w s m)

- Data.Functor.Bind.Class: instance (Bind m, Semigroup w) => Bind (RWST r w s m)

- Data.Functor.Bind.Class: instance (Bind m, Semigroup w) => Bind (WriterT w m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Apply (ErrorT e m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Apply (ExceptT e m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Apply (MaybeT m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Bind (ErrorT e m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Bind (ExceptT e m)

- Data.Functor.Bind.Class: instance (Functor m, Monad m) => Bind (MaybeT m)

- Data.Functor.Bind.Class: instance (Semigroup e, Apply w) => Apply (EnvT e w)

- Data.Functor.Bind.Class: instance (Semigroup x, Semigroup y) => Biapply ((,,,) x y)

- Data.Functor.Bind.Class: instance (Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z)

- Data.Functor.Bind.Class: instance Alternative f => Alternative (WrappedApplicative f)

- Data.Functor.Bind.Class: instance Applicative f => Applicative (WrappedApplicative f)

- Data.Functor.Bind.Class: instance Applicative f => Apply (WrappedApplicative f)

- Data.Functor.Bind.Class: instance Apply ((->) m)

- Data.Functor.Bind.Class: instance Apply (Cokleisli w a)

- Data.Functor.Bind.Class: instance Apply (ContT r m)

- Data.Functor.Bind.Class: instance Apply (Either a)

- Data.Functor.Bind.Class: instance Apply IO

- Data.Functor.Bind.Class: instance Apply Identity

- Data.Functor.Bind.Class: instance Apply IntMap

- Data.Functor.Bind.Class: instance Apply Maybe

- Data.Functor.Bind.Class: instance Apply NonEmpty

- Data.Functor.Bind.Class: instance Apply Option

- Data.Functor.Bind.Class: instance Apply Seq

- Data.Functor.Bind.Class: instance Apply Tree

- Data.Functor.Bind.Class: instance Apply ZipList

- Data.Functor.Bind.Class: instance Apply []

- Data.Functor.Bind.Class: instance Apply f => Applicative (MaybeApply f)

- Data.Functor.Bind.Class: instance Apply f => Apply (Backwards f)

- Data.Functor.Bind.Class: instance Apply f => Apply (Lift f)

- Data.Functor.Bind.Class: instance Apply f => Apply (MaybeApply f)

- Data.Functor.Bind.Class: instance Apply f => Apply (Reverse f)

- Data.Functor.Bind.Class: instance Apply f => Biapply (Clown f)

- Data.Functor.Bind.Class: instance Apply g => Biapply (Joker g)

- Data.Functor.Bind.Class: instance Apply m => Apply (ListT m)

- Data.Functor.Bind.Class: instance Apply m => Apply (ReaderT e m)

- Data.Functor.Bind.Class: instance Apply w => Apply (IdentityT w)

- Data.Functor.Bind.Class: instance Apply w => Apply (TracedT m w)

- Data.Functor.Bind.Class: instance Arrow a => Apply (WrappedArrow a b)

- Data.Functor.Bind.Class: instance Biapply (,)

- Data.Functor.Bind.Class: instance Biapply Arg

- Data.Functor.Bind.Class: instance Biapply Const

- Data.Functor.Bind.Class: instance Biapply Tagged

- Data.Functor.Bind.Class: instance Biapply p => Apply (Join p)

- Data.Functor.Bind.Class: instance Biapply p => Biapply (Flip p)

- Data.Functor.Bind.Class: instance Biapply p => Biapply (WrappedBifunctor p)

- Data.Functor.Bind.Class: instance Bind ((->) m)

- Data.Functor.Bind.Class: instance Bind (ContT r m)

- Data.Functor.Bind.Class: instance Bind (Either a)

- Data.Functor.Bind.Class: instance Bind IO

- Data.Functor.Bind.Class: instance Bind Identity

- Data.Functor.Bind.Class: instance Bind IntMap

- Data.Functor.Bind.Class: instance Bind Maybe

- Data.Functor.Bind.Class: instance Bind NonEmpty

- Data.Functor.Bind.Class: instance Bind Option

- Data.Functor.Bind.Class: instance Bind Seq

- Data.Functor.Bind.Class: instance Bind Tree

- Data.Functor.Bind.Class: instance Bind []

- Data.Functor.Bind.Class: instance Bind m => Apply (StateT s m)

- Data.Functor.Bind.Class: instance Bind m => Bind (IdentityT m)

- Data.Functor.Bind.Class: instance Bind m => Bind (ReaderT e m)

- Data.Functor.Bind.Class: instance Bind m => Bind (StateT s m)

- Data.Functor.Bind.Class: instance Comonad f => Comonad (MaybeApply f)

- Data.Functor.Bind.Class: instance Extend f => Extend (MaybeApply f)

- Data.Functor.Bind.Class: instance Functor f => Functor (MaybeApply f)

- Data.Functor.Bind.Class: instance Functor f => Functor (WrappedApplicative f)

- Data.Functor.Bind.Class: instance Monad m => Apply (WrappedMonad m)

- Data.Functor.Bind.Class: instance Monad m => Bind (WrappedMonad m)

- Data.Functor.Bind.Class: instance Ord k => Apply (Map k)

- Data.Functor.Bind.Class: instance Ord k => Bind (Map k)

- Data.Functor.Bind.Class: instance Semigroup f => Apply (Constant f)

- Data.Functor.Bind.Class: instance Semigroup m => Apply ((,) m)

- Data.Functor.Bind.Class: instance Semigroup m => Apply (Const m)

- Data.Functor.Bind.Class: instance Semigroup m => Bind ((,) m)

- Data.Functor.Bind.Class: instance Semigroup x => Biapply ((,,) x)

- Data.Functor.Bind.Class: runMaybeApply :: MaybeApply f a -> Either (f a) a

- Data.Functor.Bind.Class: unwrapApplicative :: WrappedApplicative f a -> f a

- Data.Functor.Bind.Trans: instance (Semigroup w, Monoid w) => BindTrans (RWST r w s)

- Data.Functor.Bind.Trans: instance (Semigroup w, Monoid w) => BindTrans (WriterT w)

- Data.Functor.Bind.Trans: instance BindTrans (ContT r)

- Data.Functor.Bind.Trans: instance BindTrans (ReaderT e)

- Data.Functor.Bind.Trans: instance BindTrans (StateT s)

- Data.Functor.Bind.Trans: instance BindTrans IdentityT

- Data.Functor.Extend: instance (Extend f, Extend g) => Extend (Coproduct f g)

- Data.Functor.Extend: instance (Extend w, Semigroup m) => Extend (TracedT m w)

- Data.Functor.Extend: instance Extend ((,) e)

- Data.Functor.Extend: instance Extend (Either a)

- Data.Functor.Extend: instance Extend Identity

- Data.Functor.Extend: instance Extend Maybe

- Data.Functor.Extend: instance Extend NonEmpty

- Data.Functor.Extend: instance Extend Seq

- Data.Functor.Extend: instance Extend Tree

- Data.Functor.Extend: instance Extend []

- Data.Functor.Extend: instance Extend w => Extend (EnvT e w)

- Data.Functor.Extend: instance Extend w => Extend (IdentityT w)

- Data.Functor.Extend: instance Extend w => Extend (StoreT s w)

- Data.Functor.Extend: instance Semigroup m => Extend ((->) m)

- Data.Functor.Plus: instance (Apply f, Applicative f) => Plus (ListT f)

- Data.Functor.Plus: instance (Bind f, Monad f) => Plus (MaybeT f)

- Data.Functor.Plus: instance (Bind f, Monad f, Error e) => Plus (ErrorT e f)

- Data.Functor.Plus: instance (Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)

- Data.Functor.Plus: instance (Plus f, Functor g) => Plus (Compose f g)

- Data.Functor.Plus: instance (Plus f, Plus g) => Plus (Product f g)

- Data.Functor.Plus: instance Alternative f => Plus (WrappedApplicative f)

- Data.Functor.Plus: instance ArrowPlus a => Plus (WrappedArrow a b)

- Data.Functor.Plus: instance MonadPlus m => Plus (WrappedMonad m)

- Data.Functor.Plus: instance Ord k => Plus (Map k)

- Data.Functor.Plus: instance Plus IO

- Data.Functor.Plus: instance Plus IntMap

- Data.Functor.Plus: instance Plus Maybe

- Data.Functor.Plus: instance Plus Option

- Data.Functor.Plus: instance Plus Seq

- Data.Functor.Plus: instance Plus []

- Data.Functor.Plus: instance Plus f => Plus (Backwards f)

- Data.Functor.Plus: instance Plus f => Plus (IdentityT f)

- Data.Functor.Plus: instance Plus f => Plus (Lift f)

- Data.Functor.Plus: instance Plus f => Plus (RWST r w s f)

- Data.Functor.Plus: instance Plus f => Plus (ReaderT e f)

- Data.Functor.Plus: instance Plus f => Plus (Reverse f)

- Data.Functor.Plus: instance Plus f => Plus (StateT e f)

- Data.Functor.Plus: instance Plus f => Plus (WriterT w f)

- Data.Groupoid: instance Groupoid k1 => Groupoid (Dual k1)

- Data.Isomorphism: embed :: Iso k a b -> k a b

- Data.Isomorphism: instance Category k1 => Category (Iso k1)

- Data.Isomorphism: instance Semigroupoid k1 => Groupoid (Iso k1)

- Data.Isomorphism: instance Semigroupoid k1 => Semigroupoid (Iso k1)

- Data.Isomorphism: project :: Iso k a b -> k b a

- Data.Semigroup.Bifoldable: instance Apply f => Semigroup (Act f a)

- Data.Semigroup.Bifoldable: instance Functor f => Functor (Act f)

- Data.Semigroup.Foldable: instance Alt f => Semigroup (Alt_ f a)

- Data.Semigroup.Foldable: instance Apply f => Semigroup (Act f a)

- Data.Semigroup.Foldable: instance Functor f => Functor (Act f)

- Data.Semigroup.Foldable: instance Semigroup a => Semigroup (JoinWith a)

- Data.Semigroup.Foldable.Class: instance (Bifoldable1 f, Bifoldable1 g) => Bifoldable1 (Product f g)

- Data.Semigroup.Foldable.Class: instance (Bifoldable1 p, Foldable1 f, Foldable1 g) => Bifoldable1 (Biff p f g)

- Data.Semigroup.Foldable.Class: instance (Foldable1 f, Bifoldable1 p) => Bifoldable1 (Tannen f p)

- Data.Semigroup.Foldable.Class: instance (Foldable1 f, Foldable1 g) => Foldable1 (Compose f g)

- Data.Semigroup.Foldable.Class: instance (Foldable1 f, Foldable1 g) => Foldable1 (Coproduct f g)

- Data.Semigroup.Foldable.Class: instance (Foldable1 f, Foldable1 g) => Foldable1 (Product f g)

- Data.Semigroup.Foldable.Class: instance (Foldable1 f, Foldable1 g) => Foldable1 (Sum f g)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 ((,,) x)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 ((,,,) x y)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 ((,,,,) x y z)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 (,)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 Arg

- Data.Semigroup.Foldable.Class: instance Bifoldable1 Const

- Data.Semigroup.Foldable.Class: instance Bifoldable1 Either

- Data.Semigroup.Foldable.Class: instance Bifoldable1 Tagged

- Data.Semigroup.Foldable.Class: instance Bifoldable1 p => Bifoldable1 (Flip p)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 p => Bifoldable1 (WrappedBifunctor p)

- Data.Semigroup.Foldable.Class: instance Bifoldable1 p => Foldable1 (Join p)

- Data.Semigroup.Foldable.Class: instance Foldable1 ((,) a)

- Data.Semigroup.Foldable.Class: instance Foldable1 Identity

- Data.Semigroup.Foldable.Class: instance Foldable1 NonEmpty

- Data.Semigroup.Foldable.Class: instance Foldable1 Tree

- Data.Semigroup.Foldable.Class: instance Foldable1 f => Bifoldable1 (Clown f)

- Data.Semigroup.Foldable.Class: instance Foldable1 f => Foldable1 (Backwards f)

- Data.Semigroup.Foldable.Class: instance Foldable1 f => Foldable1 (Lift f)

- Data.Semigroup.Foldable.Class: instance Foldable1 f => Foldable1 (Reverse f)

- Data.Semigroup.Foldable.Class: instance Foldable1 g => Bifoldable1 (Joker g)

- Data.Semigroup.Foldable.Class: instance Foldable1 g => Foldable1 (Joker g a)

- Data.Semigroup.Foldable.Class: instance Foldable1 m => Foldable1 (IdentityT m)

- Data.Semigroup.Traversable.Class: instance (Bitraversable1 f, Bitraversable1 g) => Bitraversable1 (Product f g)

- Data.Semigroup.Traversable.Class: instance (Bitraversable1 p, Traversable1 f, Traversable1 g) => Bitraversable1 (Biff p f g)

- Data.Semigroup.Traversable.Class: instance (Traversable1 f, Bitraversable1 p) => Bitraversable1 (Tannen f p)

- Data.Semigroup.Traversable.Class: instance (Traversable1 f, Traversable1 g) => Traversable1 (Compose f g)

- Data.Semigroup.Traversable.Class: instance (Traversable1 f, Traversable1 g) => Traversable1 (Coproduct f g)

- Data.Semigroup.Traversable.Class: instance (Traversable1 f, Traversable1 g) => Traversable1 (Product f g)

- Data.Semigroup.Traversable.Class: instance (Traversable1 f, Traversable1 g) => Traversable1 (Sum f g)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 ((,,) x)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 ((,,,) x y)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 ((,,,,) x y z)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 (,)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 Arg

- Data.Semigroup.Traversable.Class: instance Bitraversable1 Const

- Data.Semigroup.Traversable.Class: instance Bitraversable1 Either

- Data.Semigroup.Traversable.Class: instance Bitraversable1 Tagged

- Data.Semigroup.Traversable.Class: instance Bitraversable1 p => Bitraversable1 (Flip p)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 p => Bitraversable1 (WrappedBifunctor p)

- Data.Semigroup.Traversable.Class: instance Bitraversable1 p => Traversable1 (Join p)

- Data.Semigroup.Traversable.Class: instance Traversable1 ((,) a)

- Data.Semigroup.Traversable.Class: instance Traversable1 Identity

- Data.Semigroup.Traversable.Class: instance Traversable1 NonEmpty

- Data.Semigroup.Traversable.Class: instance Traversable1 Tree

- Data.Semigroup.Traversable.Class: instance Traversable1 f => Bitraversable1 (Clown f)

- Data.Semigroup.Traversable.Class: instance Traversable1 f => Traversable1 (Backwards f)

- Data.Semigroup.Traversable.Class: instance Traversable1 f => Traversable1 (IdentityT f)

- Data.Semigroup.Traversable.Class: instance Traversable1 f => Traversable1 (Lift f)

- Data.Semigroup.Traversable.Class: instance Traversable1 f => Traversable1 (Reverse f)

- Data.Semigroup.Traversable.Class: instance Traversable1 g => Bitraversable1 (Joker g)

- Data.Semigroup.Traversable.Class: instance Traversable1 g => Traversable1 (Joker g a)

- Data.Semigroupoid: getSemi :: Semi m a b -> m

- Data.Semigroupoid: instance Bind m => Semigroupoid (Kleisli m)

- Data.Semigroupoid: instance Category k1 => Category (WrappedCategory k1)

- Data.Semigroupoid: instance Category k1 => Semigroupoid (WrappedCategory k1)

- Data.Semigroupoid: instance Extend w => Semigroupoid (Cokleisli w)

- Data.Semigroupoid: instance Monoid m => Category (Semi m)

- Data.Semigroupoid: instance Semigroup m => Semigroupoid (Semi m)

- Data.Semigroupoid: instance Semigroupoid (,)

- Data.Semigroupoid: instance Semigroupoid (->)

- Data.Semigroupoid: instance Semigroupoid Op

- Data.Semigroupoid: unwrapCategory :: WrappedCategory k a b -> k a b

- Data.Semigroupoid.Dual: getDual :: Dual k a b -> k b a

- Data.Semigroupoid.Dual: instance Category k1 => Category (Dual k1)

- Data.Semigroupoid.Dual: instance Semigroupoid k1 => Semigroupoid (Dual k1)

- Data.Semigroupoid.Ob: instance (Bind m, Monad m) => Ob (Kleisli m) a

- Data.Semigroupoid.Ob: instance (Extend w, Comonad w) => Ob (Cokleisli w) a

- Data.Semigroupoid.Ob: instance Ob (->) a

- Data.Semigroupoid.Static: instance (Comonad f, Monoid a) => Comonad (Static f a)

- Data.Semigroupoid.Static: instance (Extend f, Semigroup a) => Extend (Static f a)

- Data.Semigroupoid.Static: instance Alt f => Alt (Static f a)

- Data.Semigroupoid.Static: instance Alternative f => ArrowPlus (Static f)

- Data.Semigroupoid.Static: instance Alternative f => ArrowZero (Static f)

- Data.Semigroupoid.Static: instance Applicative f => Applicative (Static f a)

- Data.Semigroupoid.Static: instance Applicative f => Arrow (Static f)

- Data.Semigroupoid.Static: instance Applicative f => ArrowChoice (Static f)

- Data.Semigroupoid.Static: instance Applicative f => Category (Static f)

- Data.Semigroupoid.Static: instance Apply f => Apply (Static f a)

- Data.Semigroupoid.Static: instance Apply f => Semigroupoid (Static f)

- Data.Semigroupoid.Static: instance Functor f => Functor (Static f a)

- Data.Semigroupoid.Static: instance Plus f => Plus (Static f a)

- Data.Semigroupoid.Static: runStatic :: Static f a b -> f (a -> b)

+ Data.Functor.Alt: instance (Data.Functor.Alt.Alt f, Data.Functor.Alt.Alt g) => Data.Functor.Alt.Alt (Data.Functor.Product.Product f g)

+ Data.Functor.Alt: instance (Data.Functor.Alt.Alt f, GHC.Base.Functor g) => Data.Functor.Alt.Alt (Data.Functor.Compose.Compose f g)

+ Data.Functor.Alt: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f) => Data.Functor.Alt.Alt (Control.Monad.Trans.Error.ErrorT e f)

+ Data.Functor.Alt: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f) => Data.Functor.Alt.Alt (Control.Monad.Trans.Maybe.MaybeT f)

+ Data.Functor.Alt: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f, Data.Semigroup.Semigroup e) => Data.Functor.Alt.Alt (Control.Monad.Trans.Except.ExceptT e f)

+ Data.Functor.Alt: instance Control.Arrow.ArrowPlus a => Data.Functor.Alt.Alt (Control.Applicative.WrappedArrow a b)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt (Data.Either.Either a)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt Data.IntMap.Base.IntMap

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt Data.List.NonEmpty.NonEmpty

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt Data.Semigroup.Option

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt Data.Sequence.Seq

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt GHC.Base.Maybe

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt GHC.Types.IO

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt []

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Applicative.Backwards.Backwards f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Applicative.Lift.Lift f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.Identity.IdentityT f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.RWS.Lazy.RWST r w s f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.RWS.Strict.RWST r w s f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.Reader.ReaderT e f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.State.Lazy.StateT e f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.State.Strict.StateT e f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.Writer.Lazy.WriterT w f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Control.Monad.Trans.Writer.Strict.WriterT w f)

+ Data.Functor.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Data.Functor.Reverse.Reverse f)

+ Data.Functor.Alt: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Alt.Alt (Control.Monad.Trans.List.ListT f)

+ Data.Functor.Alt: instance GHC.Base.Alternative f => Data.Functor.Alt.Alt (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Alt: instance GHC.Base.MonadPlus m => Data.Functor.Alt.Alt (Control.Applicative.WrappedMonad m)

+ Data.Functor.Alt: instance GHC.Classes.Ord k => Data.Functor.Alt.Alt (Data.Map.Base.Map k)

+ Data.Functor.Apply: [runMaybeApply] :: MaybeApply f a -> Either (f a) a

+ Data.Functor.Apply: [unwrapApplicative] :: WrappedApplicative f a -> f a

+ Data.Functor.Bind: [runMaybeApply] :: MaybeApply f a -> Either (f a) a

+ Data.Functor.Bind: [unwrapApplicative] :: WrappedApplicative f a -> f a

+ Data.Functor.Bind.Class: [runMaybeApply] :: MaybeApply f a -> Either (f a) a

+ Data.Functor.Bind.Class: [unwrapApplicative] :: WrappedApplicative f a -> f a

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply f, Data.Functor.Bind.Class.Apply g) => Data.Functor.Bind.Class.Apply (Data.Functor.Compose.Compose f g)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply f, Data.Functor.Bind.Class.Apply g) => Data.Functor.Bind.Class.Apply (Data.Functor.Product.Product f g)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply f, Data.Functor.Bind.Class.Biapply p) => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Tannen.Tannen f p)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Writer.Lazy.WriterT w m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Writer.Strict.WriterT w m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.List.ListT m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Apply w, Data.Semigroup.Semigroup s) => Data.Functor.Bind.Class.Apply (Control.Comonad.Trans.Store.StoreT s w)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Biapply p, Data.Functor.Bind.Class.Apply f, Data.Functor.Bind.Class.Apply g) => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Biff.Biff p f g)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Biapply p, Data.Functor.Bind.Class.Biapply q) => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Product.Product p q)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind f, Data.Functor.Bind.Class.Bind g) => Data.Functor.Bind.Class.Bind (Data.Functor.Product.Product f g)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.RWS.Lazy.RWST r w s m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.RWS.Strict.RWST r w s m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.RWS.Lazy.RWST r w s m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.RWS.Strict.RWST r w s m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Writer.Lazy.WriterT w m)

+ Data.Functor.Bind.Class: instance (Data.Functor.Bind.Class.Bind m, Data.Semigroup.Semigroup w) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Writer.Strict.WriterT w m)

+ Data.Functor.Bind.Class: instance (Data.Semigroup.Semigroup e, Data.Functor.Bind.Class.Apply w) => Data.Functor.Bind.Class.Apply (Control.Comonad.Trans.Env.EnvT e w)

+ Data.Functor.Bind.Class: instance (Data.Semigroup.Semigroup x, Data.Semigroup.Semigroup y) => Data.Functor.Bind.Class.Biapply ((,,,) x y)

+ Data.Functor.Bind.Class: instance (Data.Semigroup.Semigroup x, Data.Semigroup.Semigroup y, Data.Semigroup.Semigroup z) => Data.Functor.Bind.Class.Biapply ((,,,,) x y z)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Error.ErrorT e m)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Except.ExceptT e m)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Maybe.MaybeT m)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Error.ErrorT e m)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Except.ExceptT e m)

+ Data.Functor.Bind.Class: instance (GHC.Base.Functor m, GHC.Base.Monad m) => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Maybe.MaybeT m)

+ Data.Functor.Bind.Class: instance Control.Arrow.Arrow a => Data.Functor.Bind.Class.Apply (Control.Applicative.WrappedArrow a b)

+ Data.Functor.Bind.Class: instance Control.Comonad.Comonad f => Control.Comonad.Comonad (Data.Functor.Bind.Class.MaybeApply f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply ((->) m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply (Control.Comonad.Cokleisli w a)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Cont.ContT r m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply (Data.Either.Either a)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Control.Applicative.ZipList

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.Functor.Identity.Identity

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.IntMap.Base.IntMap

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.List.NonEmpty.NonEmpty

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.Semigroup.Option

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.Sequence.Seq

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply Data.Tree.Tree

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply GHC.Base.Maybe

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply GHC.Types.IO

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply []

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Control.Applicative.Backwards.Backwards f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Control.Applicative.Lift.Lift f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Functor.Bind.Class.MaybeApply f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Functor.Reverse.Reverse f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Clown.Clown f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply f => GHC.Base.Applicative (Data.Functor.Bind.Class.MaybeApply f)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply g => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Joker.Joker g)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply m => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.List.ListT m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply m => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply w => Data.Functor.Bind.Class.Apply (Control.Comonad.Trans.Traced.TracedT m w)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Apply w => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Identity.IdentityT w)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply (,)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply Control.Applicative.Const

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply Data.Semigroup.Arg

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply Data.Tagged.Tagged

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply p => Data.Functor.Bind.Class.Apply (Data.Bifunctor.Join.Join p)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply p => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Flip.Flip p)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Biapply p => Data.Functor.Bind.Class.Biapply (Data.Bifunctor.Wrapped.WrappedBifunctor p)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind ((->) m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Cont.ContT r m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind (Data.Either.Either a)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.Functor.Identity.Identity

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.IntMap.Base.IntMap

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.List.NonEmpty.NonEmpty

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.Semigroup.Option

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.Sequence.Seq

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind Data.Tree.Tree

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind GHC.Base.Maybe

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind GHC.Types.IO

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind []

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.State.Lazy.StateT s m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.State.Strict.StateT s m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.State.Lazy.StateT s m)

+ Data.Functor.Bind.Class: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.State.Strict.StateT s m)

+ Data.Functor.Bind.Class: instance Data.Functor.Extend.Extend f => Data.Functor.Extend.Extend (Data.Functor.Bind.Class.MaybeApply f)

+ Data.Functor.Bind.Class: instance Data.Semigroup.Semigroup f => Data.Functor.Bind.Class.Apply (Data.Functor.Constant.Constant f)

+ Data.Functor.Bind.Class: instance Data.Semigroup.Semigroup m => Data.Functor.Bind.Class.Apply ((,) m)

+ Data.Functor.Bind.Class: instance Data.Semigroup.Semigroup m => Data.Functor.Bind.Class.Apply (Control.Applicative.Const m)

+ Data.Functor.Bind.Class: instance Data.Semigroup.Semigroup m => Data.Functor.Bind.Class.Bind ((,) m)

+ Data.Functor.Bind.Class: instance Data.Semigroup.Semigroup x => Data.Functor.Bind.Class.Biapply ((,,) x)

+ Data.Functor.Bind.Class: instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Bind.Class: instance GHC.Base.Applicative f => Data.Functor.Bind.Class.Apply (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Bind.Class: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Bind.Class: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Bind.Class.MaybeApply f)

+ Data.Functor.Bind.Class: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Bind.Class: instance GHC.Base.Monad m => Data.Functor.Bind.Class.Apply (Control.Applicative.WrappedMonad m)

+ Data.Functor.Bind.Class: instance GHC.Base.Monad m => Data.Functor.Bind.Class.Bind (Control.Applicative.WrappedMonad m)

+ Data.Functor.Bind.Class: instance GHC.Classes.Ord k => Data.Functor.Bind.Class.Apply (Data.Map.Base.Map k)

+ Data.Functor.Bind.Class: instance GHC.Classes.Ord k => Data.Functor.Bind.Class.Bind (Data.Map.Base.Map k)

+ Data.Functor.Bind.Trans: instance (Data.Semigroup.Semigroup w, GHC.Base.Monoid w) => Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.RWS.Lazy.RWST r w s)

+ Data.Functor.Bind.Trans: instance (Data.Semigroup.Semigroup w, GHC.Base.Monoid w) => Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.RWS.Strict.RWST r w s)

+ Data.Functor.Bind.Trans: instance (Data.Semigroup.Semigroup w, GHC.Base.Monoid w) => Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.Writer.Lazy.WriterT w)

+ Data.Functor.Bind.Trans: instance (Data.Semigroup.Semigroup w, GHC.Base.Monoid w) => Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.Writer.Strict.WriterT w)

+ Data.Functor.Bind.Trans: instance Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.Cont.ContT r)

+ Data.Functor.Bind.Trans: instance Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.Reader.ReaderT e)

+ Data.Functor.Bind.Trans: instance Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.State.Lazy.StateT s)

+ Data.Functor.Bind.Trans: instance Data.Functor.Bind.Trans.BindTrans (Control.Monad.Trans.State.Strict.StateT s)

+ Data.Functor.Bind.Trans: instance Data.Functor.Bind.Trans.BindTrans Control.Monad.Trans.Identity.IdentityT

+ Data.Functor.Extend: instance (Data.Functor.Extend.Extend f, Data.Functor.Extend.Extend g) => Data.Functor.Extend.Extend (Data.Functor.Coproduct.Coproduct f g)

+ Data.Functor.Extend: instance (Data.Functor.Extend.Extend w, Data.Semigroup.Semigroup m) => Data.Functor.Extend.Extend (Control.Comonad.Trans.Traced.TracedT m w)

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend ((,) e)

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend (Data.Either.Either a)

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend Data.Functor.Identity.Identity

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend Data.List.NonEmpty.NonEmpty

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend Data.Sequence.Seq

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend Data.Tree.Tree

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend GHC.Base.Maybe

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend []

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend w => Data.Functor.Extend.Extend (Control.Comonad.Trans.Env.EnvT e w)

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend w => Data.Functor.Extend.Extend (Control.Comonad.Trans.Store.StoreT s w)

+ Data.Functor.Extend: instance Data.Functor.Extend.Extend w => Data.Functor.Extend.Extend (Control.Monad.Trans.Identity.IdentityT w)

+ Data.Functor.Extend: instance Data.Semigroup.Semigroup m => Data.Functor.Extend.Extend ((->) m)

+ Data.Functor.Plus: instance (Data.Functor.Bind.Class.Apply f, GHC.Base.Applicative f) => Data.Functor.Plus.Plus (Control.Monad.Trans.List.ListT f)

+ Data.Functor.Plus: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f) => Data.Functor.Plus.Plus (Control.Monad.Trans.Maybe.MaybeT f)

+ Data.Functor.Plus: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f, Control.Monad.Trans.Error.Error e) => Data.Functor.Plus.Plus (Control.Monad.Trans.Error.ErrorT e f)

+ Data.Functor.Plus: instance (Data.Functor.Bind.Class.Bind f, GHC.Base.Monad f, Data.Semigroup.Semigroup e, GHC.Base.Monoid e) => Data.Functor.Plus.Plus (Control.Monad.Trans.Except.ExceptT e f)

+ Data.Functor.Plus: instance (Data.Functor.Plus.Plus f, Data.Functor.Plus.Plus g) => Data.Functor.Plus.Plus (Data.Functor.Product.Product f g)

+ Data.Functor.Plus: instance (Data.Functor.Plus.Plus f, GHC.Base.Functor g) => Data.Functor.Plus.Plus (Data.Functor.Compose.Compose f g)

+ Data.Functor.Plus: instance Control.Arrow.ArrowPlus a => Data.Functor.Plus.Plus (Control.Applicative.WrappedArrow a b)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus Data.IntMap.Base.IntMap

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus Data.Semigroup.Option

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus Data.Sequence.Seq

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus GHC.Base.Maybe

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus GHC.Types.IO

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus []

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Applicative.Backwards.Backwards f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Applicative.Lift.Lift f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.Identity.IdentityT f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.RWS.Lazy.RWST r w s f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.RWS.Strict.RWST r w s f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.Reader.ReaderT e f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.State.Lazy.StateT e f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.State.Strict.StateT e f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.Writer.Lazy.WriterT w f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Control.Monad.Trans.Writer.Strict.WriterT w f)

+ Data.Functor.Plus: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Data.Functor.Reverse.Reverse f)

+ Data.Functor.Plus: instance GHC.Base.Alternative f => Data.Functor.Plus.Plus (Data.Functor.Bind.Class.WrappedApplicative f)

+ Data.Functor.Plus: instance GHC.Base.MonadPlus m => Data.Functor.Plus.Plus (Control.Applicative.WrappedMonad m)

+ Data.Functor.Plus: instance GHC.Classes.Ord k => Data.Functor.Plus.Plus (Data.Map.Base.Map k)

+ Data.Groupoid: instance forall (k :: BOX) (k1 :: k -> k -> *). Data.Groupoid.Groupoid k1 => Data.Groupoid.Groupoid (Data.Semigroupoid.Dual.Dual k1)

+ Data.Isomorphism: [embed] :: Iso k a b -> k a b

+ Data.Isomorphism: [project] :: Iso k a b -> k b a

+ Data.Isomorphism: instance forall (k :: BOX) (k1 :: k -> k -> *). Control.Category.Category k1 => Control.Category.Category (Data.Isomorphism.Iso k1)

+ Data.Isomorphism: instance forall (k :: BOX) (k1 :: k -> k -> *). Data.Semigroupoid.Semigroupoid k1 => Data.Groupoid.Groupoid (Data.Isomorphism.Iso k1)

+ Data.Isomorphism: instance forall (k :: BOX) (k1 :: k -> k -> *). Data.Semigroupoid.Semigroupoid k1 => Data.Semigroupoid.Semigroupoid (Data.Isomorphism.Iso k1)

+ Data.Semigroup.Bifoldable: instance Data.Functor.Bind.Class.Apply f => Data.Semigroup.Semigroup (Data.Semigroup.Bifoldable.Act f a)

+ Data.Semigroup.Bifoldable: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Bifoldable.Act f)

+ Data.Semigroup.Foldable: instance Data.Functor.Alt.Alt f => Data.Semigroup.Semigroup (Data.Semigroup.Foldable.Alt_ f a)

+ Data.Semigroup.Foldable: instance Data.Functor.Bind.Class.Apply f => Data.Semigroup.Semigroup (Data.Semigroup.Foldable.Act f a)

+ Data.Semigroup.Foldable: instance Data.Semigroup.Semigroup a => Data.Semigroup.Semigroup (Data.Semigroup.Foldable.JoinWith a)

+ Data.Semigroup.Foldable: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Foldable.Act f)

+ Data.Semigroup.Foldable.Class: instance (Data.Semigroup.Foldable.Class.Bifoldable1 f, Data.Semigroup.Foldable.Class.Bifoldable1 g) => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Product.Product f g)

+ Data.Semigroup.Foldable.Class: instance (Data.Semigroup.Foldable.Class.Bifoldable1 p, Data.Semigroup.Foldable.Class.Foldable1 f, Data.Semigroup.Foldable.Class.Foldable1 g) => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Biff.Biff p f g)

+ Data.Semigroup.Foldable.Class: instance (Data.Semigroup.Foldable.Class.Foldable1 f, Data.Semigroup.Foldable.Class.Bifoldable1 p) => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Tannen.Tannen f p)

+ Data.Semigroup.Foldable.Class: instance (Data.Semigroup.Foldable.Class.Foldable1 f, Data.Semigroup.Foldable.Class.Foldable1 g) => Data.Semigroup.Foldable.Class.Foldable1 (Data.Functor.Compose.Compose f g)

+ Data.Semigroup.Foldable.Class: instance (Data.Semigroup.Foldable.Class.Foldable1 f, Data.Semigroup.Foldable.Class.Foldable1 g) => Data.Semigroup.Foldable.Class.Foldable1 (Data.Functor.Sum.Sum f g)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 ((,,) x)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 ((,,,) x y)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 ((,,,,) x y z)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 (,)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 Control.Applicative.Const

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 Data.Either.Either

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 Data.Semigroup.Arg

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 Data.Tagged.Tagged

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 p => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Flip.Flip p)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 p => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Wrapped.WrappedBifunctor p)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Bifoldable1 p => Data.Semigroup.Foldable.Class.Foldable1 (Data.Bifunctor.Join.Join p)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 ((,) a)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 Data.Functor.Identity.Identity

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 Data.List.NonEmpty.NonEmpty

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 Data.Tree.Tree

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Clown.Clown f)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Foldable1 (Control.Applicative.Backwards.Backwards f)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Foldable1 (Control.Applicative.Lift.Lift f)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Foldable1 (Data.Functor.Reverse.Reverse f)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 g => Data.Semigroup.Foldable.Class.Bifoldable1 (Data.Bifunctor.Joker.Joker g)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 g => Data.Semigroup.Foldable.Class.Foldable1 (Data.Bifunctor.Joker.Joker g a)

+ Data.Semigroup.Foldable.Class: instance Data.Semigroup.Foldable.Class.Foldable1 m => Data.Semigroup.Foldable.Class.Foldable1 (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Semigroup.Traversable.Class: instance (Data.Semigroup.Traversable.Class.Bitraversable1 f, Data.Semigroup.Traversable.Class.Bitraversable1 g) => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Product.Product f g)

+ Data.Semigroup.Traversable.Class: instance (Data.Semigroup.Traversable.Class.Bitraversable1 p, Data.Semigroup.Traversable.Class.Traversable1 f, Data.Semigroup.Traversable.Class.Traversable1 g) => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Biff.Biff p f g)

+ Data.Semigroup.Traversable.Class: instance (Data.Semigroup.Traversable.Class.Traversable1 f, Data.Semigroup.Traversable.Class.Bitraversable1 p) => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Tannen.Tannen f p)

+ Data.Semigroup.Traversable.Class: instance (Data.Semigroup.Traversable.Class.Traversable1 f, Data.Semigroup.Traversable.Class.Traversable1 g) => Data.Semigroup.Traversable.Class.Traversable1 (Data.Functor.Compose.Compose f g)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 ((,,) x)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 ((,,,) x y)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 ((,,,,) x y z)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 (,)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 Control.Applicative.Const

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 Data.Either.Either

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 Data.Semigroup.Arg

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 Data.Tagged.Tagged

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 p => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Flip.Flip p)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 p => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Wrapped.WrappedBifunctor p)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Bitraversable1 p => Data.Semigroup.Traversable.Class.Traversable1 (Data.Bifunctor.Join.Join p)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 ((,) a)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 Data.Functor.Identity.Identity

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 Data.List.NonEmpty.NonEmpty

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 Data.Tree.Tree

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Clown.Clown f)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Control.Applicative.Backwards.Backwards f)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Control.Applicative.Lift.Lift f)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Control.Monad.Trans.Identity.IdentityT f)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Data.Functor.Reverse.Reverse f)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 g => Data.Semigroup.Traversable.Class.Bitraversable1 (Data.Bifunctor.Joker.Joker g)

+ Data.Semigroup.Traversable.Class: instance Data.Semigroup.Traversable.Class.Traversable1 g => Data.Semigroup.Traversable.Class.Traversable1 (Data.Bifunctor.Joker.Joker g a)

+ Data.Semigroupoid: [getSemi] :: Semi m a b -> m

+ Data.Semigroupoid: [unwrapCategory] :: WrappedCategory k a b -> k a b

+ Data.Semigroupoid: instance Data.Functor.Bind.Class.Bind m => Data.Semigroupoid.Semigroupoid (Control.Arrow.Kleisli m)

+ Data.Semigroupoid: instance Data.Functor.Extend.Extend w => Data.Semigroupoid.Semigroupoid (Control.Comonad.Cokleisli w)

+ Data.Semigroupoid: instance Data.Semigroup.Semigroup m => Data.Semigroupoid.Semigroupoid (Data.Semigroupoid.Semi m)

+ Data.Semigroupoid: instance Data.Semigroupoid.Semigroupoid (,)

+ Data.Semigroupoid: instance Data.Semigroupoid.Semigroupoid (->)

+ Data.Semigroupoid: instance Data.Semigroupoid.Semigroupoid Data.Functor.Contravariant.Op

+ Data.Semigroupoid: instance GHC.Base.Monoid m => Control.Category.Category (Data.Semigroupoid.Semi m)

+ Data.Semigroupoid: instance forall (k :: BOX) (k1 :: k -> k -> *). Control.Category.Category k1 => Control.Category.Category (Data.Semigroupoid.WrappedCategory k1)

+ Data.Semigroupoid: instance forall (k :: BOX) (k1 :: k -> k -> *). Control.Category.Category k1 => Data.Semigroupoid.Semigroupoid (Data.Semigroupoid.WrappedCategory k1)

+ Data.Semigroupoid.Dual: [getDual] :: Dual k a b -> k b a

+ Data.Semigroupoid.Dual: instance forall (k :: BOX) (k1 :: k -> k -> *). Control.Category.Category k1 => Control.Category.Category (Data.Semigroupoid.Dual.Dual k1)

+ Data.Semigroupoid.Dual: instance forall (k :: BOX) (k1 :: k -> k -> *). Data.Semigroupoid.Semigroupoid k1 => Data.Semigroupoid.Semigroupoid (Data.Semigroupoid.Dual.Dual k1)

+ Data.Semigroupoid.Ob: instance (Data.Functor.Bind.Class.Bind m, GHC.Base.Monad m) => Data.Semigroupoid.Ob.Ob (Control.Arrow.Kleisli m) a

+ Data.Semigroupoid.Ob: instance (Data.Functor.Extend.Extend w, Control.Comonad.Comonad w) => Data.Semigroupoid.Ob.Ob (Control.Comonad.Cokleisli w) a

+ Data.Semigroupoid.Ob: instance Data.Semigroupoid.Ob.Ob (->) a

+ Data.Semigroupoid.Static: [runStatic] :: Static f a b -> f (a -> b)

+ Data.Semigroupoid.Static: instance (Control.Comonad.Comonad f, GHC.Base.Monoid a) => Control.Comonad.Comonad (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance (Data.Functor.Extend.Extend f, Data.Semigroup.Semigroup a) => Data.Functor.Extend.Extend (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance Data.Functor.Bind.Class.Apply f => Data.Semigroupoid.Semigroupoid (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance GHC.Base.Alternative f => Control.Arrow.ArrowPlus (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance GHC.Base.Alternative f => Control.Arrow.ArrowZero (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance GHC.Base.Applicative f => Control.Arrow.Arrow (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance GHC.Base.Applicative f => Control.Arrow.ArrowChoice (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance GHC.Base.Applicative f => Control.Category.Category (Data.Semigroupoid.Static.Static f)

+ Data.Semigroupoid.Static: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Semigroupoid.Static.Static f a)

+ Data.Semigroupoid.Static: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroupoid.Static.Static f a)

Files

CHANGELOG.markdown +4/−0
semigroupoids.cabal +2/−2

CHANGELOG.markdown view

@@ -1,3 +1,7 @@+5.0.0.4+-------+* `doctest` 0.10 support+ 5.0.0.2 ------- * Bugfix for GHC 7.4. PolyKinds on 7.4 cause all sorts of haskell interface file errors. One of the #if guards that turned it off on 7.4 was missing and has been fixed.

semigroupoids.cabal view

@@ -1,6 +1,6 @@ name:          semigroupoids category:      Control, Comonads-version:       5.0.0.3+version:       5.0.0.4 license:       BSD3 cabal-version: >= 1.8 license-file:  LICENSE@@ -174,7 +174,7 @@   else     build-depends:       base      >= 4     && < 5,-      doctest   >= 0.9.1 && < 0.10,+      doctest   >= 0.9.1 && < 0.11,       directory >= 1.0,       filepath