semigroupoids 5.0.0.2 → 5.0.0.3
raw patch · 13 files changed
+61/−58 lines, 13 filesdep ~basePVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: base
API changes (from Hackage documentation)
- Data.Functor.Alt: instance [safe] (Alt f, Alt g) => Alt (Product f g)
- Data.Functor.Alt: instance [safe] (Alt f, Functor g) => Alt (Compose f g)
- Data.Functor.Alt: instance [safe] (Bind f, Monad f) => Alt (ErrorT e f)
- Data.Functor.Alt: instance [safe] (Bind f, Monad f) => Alt (MaybeT f)
- Data.Functor.Alt: instance [safe] (Bind f, Monad f, Semigroup e) => Alt (ExceptT e f)
- Data.Functor.Alt: instance [safe] Alt (Either a)
- Data.Functor.Alt: instance [safe] Alt IO
- Data.Functor.Alt: instance [safe] Alt IntMap
- Data.Functor.Alt: instance [safe] Alt Maybe
- Data.Functor.Alt: instance [safe] Alt NonEmpty
- Data.Functor.Alt: instance [safe] Alt Option
- Data.Functor.Alt: instance [safe] Alt Seq
- Data.Functor.Alt: instance [safe] Alt []
- Data.Functor.Alt: instance [safe] Alt f => Alt (Backwards f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (IdentityT f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (Lift f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (RWST r w s f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (ReaderT e f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (Reverse f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (StateT e f)
- Data.Functor.Alt: instance [safe] Alt f => Alt (WriterT w f)
- Data.Functor.Alt: instance [safe] Alternative f => Alt (WrappedApplicative f)
- Data.Functor.Alt: instance [safe] Apply f => Alt (ListT f)
- Data.Functor.Alt: instance [safe] ArrowPlus a => Alt (WrappedArrow a b)
- Data.Functor.Alt: instance [safe] MonadPlus m => Alt (WrappedMonad m)
- Data.Functor.Alt: instance [safe] Ord k => Alt (Map k)
- Data.Functor.Bind.Class: instance [safe] (Apply f, Apply g) => Apply (Compose f g)
- Data.Functor.Bind.Class: instance [safe] (Apply f, Apply g) => Apply (Product f g)
- Data.Functor.Bind.Class: instance [safe] (Apply f, Biapply p) => Biapply (Tannen f p)
- Data.Functor.Bind.Class: instance [safe] (Apply m, Monad m) => Bind (ListT m)
- Data.Functor.Bind.Class: instance [safe] (Apply m, Semigroup w) => Apply (WriterT w m)
- Data.Functor.Bind.Class: instance [safe] (Apply w, Semigroup s) => Apply (StoreT s w)
- Data.Functor.Bind.Class: instance [safe] (Biapply p, Apply f, Apply g) => Biapply (Biff p f g)
- Data.Functor.Bind.Class: instance [safe] (Biapply p, Biapply q) => Biapply (Product p q)
- Data.Functor.Bind.Class: instance [safe] (Bind f, Bind g) => Bind (Product f g)
- Data.Functor.Bind.Class: instance [safe] (Bind m, Semigroup w) => Apply (RWST r w s m)
- Data.Functor.Bind.Class: instance [safe] (Bind m, Semigroup w) => Bind (RWST r w s m)
- Data.Functor.Bind.Class: instance [safe] (Bind m, Semigroup w) => Bind (WriterT w m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Apply (ErrorT e m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Apply (ExceptT e m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Apply (MaybeT m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Bind (ErrorT e m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Bind (ExceptT e m)
- Data.Functor.Bind.Class: instance [safe] (Functor m, Monad m) => Bind (MaybeT m)
- Data.Functor.Bind.Class: instance [safe] (Semigroup e, Apply w) => Apply (EnvT e w)
- Data.Functor.Bind.Class: instance [safe] (Semigroup x, Semigroup y) => Biapply ((,,,) x y)
- Data.Functor.Bind.Class: instance [safe] (Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z)
- Data.Functor.Bind.Class: instance [safe] Alternative f => Alternative (WrappedApplicative f)
- Data.Functor.Bind.Class: instance [safe] Applicative f => Applicative (WrappedApplicative f)
- Data.Functor.Bind.Class: instance [safe] Applicative f => Apply (WrappedApplicative f)
- Data.Functor.Bind.Class: instance [safe] Apply ((->) m)
- Data.Functor.Bind.Class: instance [safe] Apply (Cokleisli w a)
- Data.Functor.Bind.Class: instance [safe] Apply (ContT r m)
- Data.Functor.Bind.Class: instance [safe] Apply (Either a)
- Data.Functor.Bind.Class: instance [safe] Apply IO
- Data.Functor.Bind.Class: instance [safe] Apply Identity
- Data.Functor.Bind.Class: instance [safe] Apply IntMap
- Data.Functor.Bind.Class: instance [safe] Apply Maybe
- Data.Functor.Bind.Class: instance [safe] Apply NonEmpty
- Data.Functor.Bind.Class: instance [safe] Apply Option
- Data.Functor.Bind.Class: instance [safe] Apply Seq
- Data.Functor.Bind.Class: instance [safe] Apply Tree
- Data.Functor.Bind.Class: instance [safe] Apply ZipList
- Data.Functor.Bind.Class: instance [safe] Apply []
- Data.Functor.Bind.Class: instance [safe] Apply f => Applicative (MaybeApply f)
- Data.Functor.Bind.Class: instance [safe] Apply f => Apply (Backwards f)
- Data.Functor.Bind.Class: instance [safe] Apply f => Apply (Lift f)
- Data.Functor.Bind.Class: instance [safe] Apply f => Apply (MaybeApply f)
- Data.Functor.Bind.Class: instance [safe] Apply f => Apply (Reverse f)
- Data.Functor.Bind.Class: instance [safe] Apply f => Biapply (Clown f)
- Data.Functor.Bind.Class: instance [safe] Apply g => Biapply (Joker g)
- Data.Functor.Bind.Class: instance [safe] Apply m => Apply (ListT m)
- Data.Functor.Bind.Class: instance [safe] Apply m => Apply (ReaderT e m)
- Data.Functor.Bind.Class: instance [safe] Apply w => Apply (IdentityT w)
- Data.Functor.Bind.Class: instance [safe] Apply w => Apply (TracedT m w)
- Data.Functor.Bind.Class: instance [safe] Arrow a => Apply (WrappedArrow a b)
- Data.Functor.Bind.Class: instance [safe] Biapply (,)
- Data.Functor.Bind.Class: instance [safe] Biapply Arg
- Data.Functor.Bind.Class: instance [safe] Biapply Const
- Data.Functor.Bind.Class: instance [safe] Biapply Tagged
- Data.Functor.Bind.Class: instance [safe] Biapply p => Apply (Join p)
- Data.Functor.Bind.Class: instance [safe] Biapply p => Biapply (Flip p)
- Data.Functor.Bind.Class: instance [safe] Biapply p => Biapply (WrappedBifunctor p)
- Data.Functor.Bind.Class: instance [safe] Bind ((->) m)
- Data.Functor.Bind.Class: instance [safe] Bind (ContT r m)
- Data.Functor.Bind.Class: instance [safe] Bind (Either a)
- Data.Functor.Bind.Class: instance [safe] Bind IO
- Data.Functor.Bind.Class: instance [safe] Bind Identity
- Data.Functor.Bind.Class: instance [safe] Bind IntMap
- Data.Functor.Bind.Class: instance [safe] Bind Maybe
- Data.Functor.Bind.Class: instance [safe] Bind NonEmpty
- Data.Functor.Bind.Class: instance [safe] Bind Option
- Data.Functor.Bind.Class: instance [safe] Bind Seq
- Data.Functor.Bind.Class: instance [safe] Bind Tree
- Data.Functor.Bind.Class: instance [safe] Bind []
- Data.Functor.Bind.Class: instance [safe] Bind m => Apply (StateT s m)
- Data.Functor.Bind.Class: instance [safe] Bind m => Bind (IdentityT m)
- Data.Functor.Bind.Class: instance [safe] Bind m => Bind (ReaderT e m)
- Data.Functor.Bind.Class: instance [safe] Bind m => Bind (StateT s m)
- Data.Functor.Bind.Class: instance [safe] Comonad f => Comonad (MaybeApply f)
- Data.Functor.Bind.Class: instance [safe] Extend f => Extend (MaybeApply f)
- Data.Functor.Bind.Class: instance [safe] Functor f => Functor (MaybeApply f)
- Data.Functor.Bind.Class: instance [safe] Functor f => Functor (WrappedApplicative f)
- Data.Functor.Bind.Class: instance [safe] Monad m => Apply (WrappedMonad m)
- Data.Functor.Bind.Class: instance [safe] Monad m => Bind (WrappedMonad m)
- Data.Functor.Bind.Class: instance [safe] Ord k => Apply (Map k)
- Data.Functor.Bind.Class: instance [safe] Ord k => Bind (Map k)
- Data.Functor.Bind.Class: instance [safe] Semigroup f => Apply (Constant f)
- Data.Functor.Bind.Class: instance [safe] Semigroup m => Apply ((,) m)
- Data.Functor.Bind.Class: instance [safe] Semigroup m => Apply (Const m)
- Data.Functor.Bind.Class: instance [safe] Semigroup m => Bind ((,) m)
- Data.Functor.Bind.Class: instance [safe] Semigroup x => Biapply ((,,) x)
- Data.Functor.Extend: instance [safe] (Extend f, Extend g) => Extend (Coproduct f g)
- Data.Functor.Extend: instance [safe] (Extend w, Semigroup m) => Extend (TracedT m w)
- Data.Functor.Extend: instance [safe] Extend ((,) e)
- Data.Functor.Extend: instance [safe] Extend (Either a)
- Data.Functor.Extend: instance [safe] Extend Identity
- Data.Functor.Extend: instance [safe] Extend Maybe
- Data.Functor.Extend: instance [safe] Extend NonEmpty
- Data.Functor.Extend: instance [safe] Extend Seq
- Data.Functor.Extend: instance [safe] Extend Tree
- Data.Functor.Extend: instance [safe] Extend []
- Data.Functor.Extend: instance [safe] Extend w => Extend (EnvT e w)
- Data.Functor.Extend: instance [safe] Extend w => Extend (IdentityT w)
- Data.Functor.Extend: instance [safe] Extend w => Extend (StoreT s w)
- Data.Functor.Extend: instance [safe] Semigroup m => Extend ((->) m)
- Data.Functor.Plus: instance [safe] (Apply f, Applicative f) => Plus (ListT f)
- Data.Functor.Plus: instance [safe] (Bind f, Monad f) => Plus (MaybeT f)
- Data.Functor.Plus: instance [safe] (Bind f, Monad f, Error e) => Plus (ErrorT e f)
- Data.Functor.Plus: instance [safe] (Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)
- Data.Functor.Plus: instance [safe] (Plus f, Functor g) => Plus (Compose f g)
- Data.Functor.Plus: instance [safe] (Plus f, Plus g) => Plus (Product f g)
- Data.Functor.Plus: instance [safe] Alternative f => Plus (WrappedApplicative f)
- Data.Functor.Plus: instance [safe] ArrowPlus a => Plus (WrappedArrow a b)
- Data.Functor.Plus: instance [safe] MonadPlus m => Plus (WrappedMonad m)
- Data.Functor.Plus: instance [safe] Ord k => Plus (Map k)
- Data.Functor.Plus: instance [safe] Plus IO
- Data.Functor.Plus: instance [safe] Plus IntMap
- Data.Functor.Plus: instance [safe] Plus Maybe
- Data.Functor.Plus: instance [safe] Plus Option
- Data.Functor.Plus: instance [safe] Plus Seq
- Data.Functor.Plus: instance [safe] Plus []
- Data.Functor.Plus: instance [safe] Plus f => Plus (Backwards f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (IdentityT f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (Lift f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (RWST r w s f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (ReaderT e f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (Reverse f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (StateT e f)
- Data.Functor.Plus: instance [safe] Plus f => Plus (WriterT w f)
- Data.Semigroupoid: instance [safe] Bind m => Semigroupoid (Kleisli m)
- Data.Semigroupoid: instance [safe] Category k1 => Category (WrappedCategory k1)
- Data.Semigroupoid: instance [safe] Category k1 => Semigroupoid (WrappedCategory k1)
- Data.Semigroupoid: instance [safe] Extend w => Semigroupoid (Cokleisli w)
- Data.Semigroupoid: instance [safe] Monoid m => Category (Semi m)
- Data.Semigroupoid: instance [safe] Semigroup m => Semigroupoid (Semi m)
- Data.Semigroupoid: instance [safe] Semigroupoid (,)
- Data.Semigroupoid: instance [safe] Semigroupoid (->)
- Data.Semigroupoid: instance [safe] Semigroupoid Op
- Data.Semigroupoid.Static: instance [safe] (Comonad f, Monoid a) => Comonad (Static f a)
- Data.Semigroupoid.Static: instance [safe] (Extend f, Semigroup a) => Extend (Static f a)
- Data.Semigroupoid.Static: instance [safe] Alt f => Alt (Static f a)
- Data.Semigroupoid.Static: instance [safe] Alternative f => ArrowPlus (Static f)
- Data.Semigroupoid.Static: instance [safe] Alternative f => ArrowZero (Static f)
- Data.Semigroupoid.Static: instance [safe] Applicative f => Applicative (Static f a)
- Data.Semigroupoid.Static: instance [safe] Applicative f => Arrow (Static f)
- Data.Semigroupoid.Static: instance [safe] Applicative f => ArrowChoice (Static f)
- Data.Semigroupoid.Static: instance [safe] Applicative f => Category (Static f)
- Data.Semigroupoid.Static: instance [safe] Apply f => Apply (Static f a)
- Data.Semigroupoid.Static: instance [safe] Apply f => Semigroupoid (Static f)
- Data.Semigroupoid.Static: instance [safe] Functor f => Functor (Static f a)
- Data.Semigroupoid.Static: instance [safe] Plus f => Plus (Static f a)
+ 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.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.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.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.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)
Files
- .travis.yml +26/−28
- README.markdown +1/−1
- semigroupoids.cabal +3/−3
- src/Data/Functor/Alt.hs +5/−1
- src/Data/Functor/Apply.hs +4/−1
- src/Data/Functor/Bind.hs +1/−7
- src/Data/Functor/Bind/Class.hs +1/−7
- src/Data/Functor/Extend.hs +4/−1
- src/Data/Functor/Plus.hs +4/−1
- src/Data/Semigroup/Traversable/Class.hs +2/−0
- src/Data/Semigroupoid.hs +6/−1
- src/Data/Semigroupoid/Static.hs +2/−7
- test/doctests.hsc +2/−0
.travis.yml view
@@ -1,43 +1,41 @@-env:- - GHCVER=7.0.1 CABALVER=1.16- - GHCVER=7.0.4 CABALVER=1.16- - GHCVER=7.2.2 CABALVER=1.16- - GHCVER=7.4.2 CABALVER=1.16- - GHCVER=7.6.3 CABALVER=1.16- - GHCVER=7.8.4 CABALVER=1.18- - GHCVER=7.10.1 CABALVER=1.22- - GHCVER=head CABALVER=1.22+language: c+sudo: false matrix:+ include:+ - env: CABALVER=1.16 GHCVER=7.4.2+ addons: {apt: {packages: [cabal-install-1.16,ghc-7.4.2], sources: [hvr-ghc]}}+ - env: CABALVER=1.16 GHCVER=7.6.3+ addons: {apt: {packages: [cabal-install-1.16,ghc-7.6.3], sources: [hvr-ghc]}}+ - env: CABALVER=1.18 GHCVER=7.8.4+ addons: {apt: {packages: [cabal-install-1.18,ghc-7.8.4], sources: [hvr-ghc]}}+ - env: CABALVER=1.22 GHCVER=7.10.1+ addons: {apt: {packages: [cabal-install-1.22,ghc-7.10.1],sources: [hvr-ghc]}}+ - env: CABALVER=head GHCVER=head+ addons: {apt: {packages: [cabal-install-head,ghc-head], sources: [hvr-ghc]}}+ allow_failures:- - env: GHCVER=7.0.1 CABALVER=1.16- - env: GHCVER=7.0.4 CABALVER=1.16- - env: GHCVER=7.2.2 CABALVER=1.16- - env: GHCVER=head CABALVER=1.22+ - env: CABALVER=head GHCVER=head before_install:- - travis_retry sudo add-apt-repository -y ppa:hvr/ghc- - travis_retry sudo apt-get update- - travis_retry sudo apt-get install cabal-install-$CABALVER ghc-$GHCVER- - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH- - cabal --version+ - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH+ - export CABAL=cabal-$CABALVER+ - travis_retry $CABAL update+ - if [ "$CABALVER" = "1.22" ]; then $CABAL install Cabal-1.22.4.0; fi+ - $CABAL --version install:- - travis_retry cabal update- - git clone https://github.com/ekmett/bifunctors.git- - cd bifunctors- - cabal install- - cd ..- - cabal install --enable-tests --only-dependencies+ - $CABAL install --enable-tests --only-dependencies script:- - cabal configure -v2 --enable-tests- - cabal build- - cabal sdist+ - $CABAL configure -v2 --enable-tests+ - $CABAL build+ - $CABAL test+ - $CABAL sdist - export SRC_TGZ=$(cabal info . | awk '{print $2 ".tar.gz";exit}') ; cd dist/; if [ -f "$SRC_TGZ" ]; then- cabal install "$SRC_TGZ";+ $CABAL install "$SRC_TGZ"; else echo "expected '$SRC_TGZ' not found"; exit 1;
README.markdown view
@@ -1,7 +1,7 @@ semigroupoids ========== -[](http://travis-ci.org/ekmett/semigroupoids)+[](https://hackage.haskell.org/package/semigroupoids) [](http://travis-ci.org/ekmett/semigroupoids) A semigroupoid is a `Category` without `id`.
semigroupoids.cabal view
@@ -1,6 +1,6 @@ name: semigroupoids category: Control, Comonads-version: 5.0.0.2+version: 5.0.0.3 license: BSD3 cabal-version: >= 1.8 license-file: LICENSE@@ -173,8 +173,8 @@ buildable: False else build-depends:- base >= 4.4 && < 5,- doctest >= 0.9.1 && < 0.10,+ base >= 4 && < 5,+ doctest >= 0.9.1 && < 0.10, directory >= 1.0, filepath
src/Data/Functor/Alt.hs view
@@ -1,5 +1,9 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE Safe #-}++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3))+{-# LANGUAGE Trustworthy #-}+#endif+ #if __GLASGOW_HASKELL__ >= 711 {-# LANGUAGE ConstrainedClassMethods #-} #endif
src/Data/Functor/Apply.hs view
@@ -1,5 +1,8 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE Safe #-}++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3))+{-# LANGUAGE Trustworthy #-}+#endif ----------------------------------------------------------------------------- -- | -- Copyright : (C) 2011-2015 Edward Kmett
src/Data/Functor/Bind.hs view
@@ -1,12 +1,6 @@ {-# LANGUAGE CPP #-} -#ifdef MIN_VERSION_comonad-#if __GLASGOW_HASKELL__ >= 707 && (MIN_VERSION_comonad(3,0,3))-{-# LANGUAGE Safe #-}-#else-{-# LANGUAGE Trustworthy #-}-#endif-#else+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3)) {-# LANGUAGE Trustworthy #-} #endif
src/Data/Functor/Bind/Class.hs view
@@ -4,13 +4,7 @@ #define MIN_VERSION_semigroups(x,y,z) 1 #endif -#ifdef MIN_VERSION_comonad-#if __GLASGOW_HASKELL__ >= 707 && (MIN_VERSION_comonad(3,0,3))-{-# LANGUAGE Safe #-}-#else-{-# LANGUAGE Trustworthy #-}-#endif-#else+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3)) {-# LANGUAGE Trustworthy #-} #endif
src/Data/Functor/Extend.hs view
@@ -1,5 +1,8 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE Safe #-}++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3))+{-# LANGUAGE Trustworthy #-}+#endif ----------------------------------------------------------------------------- -- | -- Module : Data.Functor.Extend
src/Data/Functor/Plus.hs view
@@ -1,5 +1,8 @@ {-# LANGUAGE CPP #-}-{-# LANGUAGE Safe #-}++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3))+{-# LANGUAGE Trustworthy #-}+#endif ----------------------------------------------------------------------------- -- | -- Copyright : (C) 2011-2015 Edward Kmett
src/Data/Semigroup/Traversable/Class.hs view
@@ -44,7 +44,9 @@ import Data.Semigroup.Foldable import Data.Semigroup.Bifoldable import Data.Tagged+#if __GLASGOW_HASKELL__ < 710 import Data.Traversable+#endif import Data.Traversable.Instances () #ifdef MIN_VERSION_containers
src/Data/Semigroupoid.hs view
@@ -1,8 +1,13 @@ {-# LANGUAGE CPP #-}+ #if __GLASGOW_HASKELL__ >= 706 {-# LANGUAGE PolyKinds #-} #endif-{-# LANGUAGE Safe #-}++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3))+{-# LANGUAGE Trustworthy #-}+#endif+ ----------------------------------------------------------------------------- -- | -- Module : Data.Semigroupoid
src/Data/Semigroupoid/Static.hs view
@@ -1,11 +1,6 @@ {-# LANGUAGE CPP #-}-#ifdef MIN_VERSION_comonad-#if __GLASGOW_HASKELL__ >= 707 && (MIN_VERSION_comonad(3,0,3))-{-# LANGUAGE Safe #-}-#else-{-# LANGUAGE Trustworthy #-}-#endif-#else++#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL <= 706 && defined(MIN_VERSION_comonad) && !(MIN_VERSION_comonad(3,0,3)) {-# LANGUAGE Trustworthy #-} #endif
test/doctests.hsc view
@@ -16,7 +16,9 @@ module Main where import Build_doctests (deps)+#if __GLASGOW_HASKELL__ < 710 import Control.Applicative+#endif import Control.Monad import Data.List import System.Directory