packages feed

kan-extensions 4.2.2 → 4.2.3

raw patch · 12 files changed

+124/−23 lines, 12 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Control.Comonad.Density: instance Applicative f => Applicative (Density f)
- Control.Comonad.Density: instance Apply f => Apply (Density f)
- Control.Comonad.Density: instance Comonad (Density f)
- Control.Comonad.Density: instance ComonadTrans Density
- Control.Comonad.Density: instance Extend (Density f)
- Control.Comonad.Density: instance Functor (Density f)
- Control.Monad.Co: instance (Comonad w, MonadError e m) => MonadError e (CoT w m)
- Control.Monad.Co: instance (Comonad w, MonadIO m) => MonadIO (CoT w m)
- Control.Monad.Co: instance (Comonad w, MonadReader e m) => MonadReader e (CoT w m)
- Control.Monad.Co: instance (Comonad w, MonadState s m) => MonadState s (CoT w m)
- Control.Monad.Co: instance (Comonad w, MonadWriter e m) => MonadWriter e (CoT w m)
- Control.Monad.Co: instance Comonad w => Applicative (CoT w m)
- Control.Monad.Co: instance Comonad w => Monad (CoT w m)
- Control.Monad.Co: instance Comonad w => MonadTrans (CoT w)
- Control.Monad.Co: instance Extend w => Apply (CoT w m)
- Control.Monad.Co: instance Extend w => Bind (CoT w m)
- Control.Monad.Co: instance Functor w => Functor (CoT w m)
- Control.Monad.Co: runCoT :: CoT w m a -> forall r. w (a -> m r) -> m r
- Control.Monad.Codensity: instance (Functor f, MonadFree f m) => MonadFree f (Codensity m)
- Control.Monad.Codensity: instance Alt v => Alt (Codensity v)
- Control.Monad.Codensity: instance Alternative v => Alternative (Codensity v)
- Control.Monad.Codensity: instance Applicative (Codensity f)
- Control.Monad.Codensity: instance Apply (Codensity f)
- Control.Monad.Codensity: instance Functor (Codensity k)
- Control.Monad.Codensity: instance Monad (Codensity f)
- Control.Monad.Codensity: instance MonadIO m => MonadIO (Codensity m)
- Control.Monad.Codensity: instance MonadPlus v => MonadPlus (Codensity v)
- Control.Monad.Codensity: instance MonadReader r m => MonadReader r (Codensity m)
- Control.Monad.Codensity: instance MonadReader r m => MonadState r (Codensity m)
- Control.Monad.Codensity: instance MonadTrans Codensity
- Control.Monad.Codensity: instance Plus v => Plus (Codensity v)
- Control.Monad.Codensity: instance Typeable Codensity
- Control.Monad.Codensity: runCodensity :: Codensity m a -> forall b. (a -> m b) -> m b
- Data.Functor.Contravariant.Coyoneda: instance Adjunction f g => Adjunction (Coyoneda f) (Coyoneda g)
- Data.Functor.Contravariant.Coyoneda: instance Contravariant (Coyoneda f)
- Data.Functor.Contravariant.Coyoneda: instance Representable f => Representable (Coyoneda f)
- Data.Functor.Contravariant.Day: instance (Representable f, Representable g) => Representable (Day f g)
- Data.Functor.Contravariant.Day: instance Contravariant (Day f g)
- Data.Functor.Contravariant.Day: instance Typeable Day
- Data.Functor.Contravariant.Yoneda: instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g)
- Data.Functor.Contravariant.Yoneda: instance Contravariant (Yoneda f)
- Data.Functor.Contravariant.Yoneda: instance Representable f => Representable (Yoneda f)
- Data.Functor.Contravariant.Yoneda: runYoneda :: Yoneda f a -> forall r. (r -> a) -> f r
- Data.Functor.Coyoneda: instance (Functor f, Eq (f a)) => Eq (Coyoneda f a)
- Data.Functor.Coyoneda: instance (Functor f, Ord (f a)) => Ord (Coyoneda f a)
- Data.Functor.Coyoneda: instance (Functor f, Read (f a)) => Read (Coyoneda f a)
- Data.Functor.Coyoneda: instance (Functor f, Show (f a)) => Show (Coyoneda f a)
- Data.Functor.Coyoneda: instance Adjunction f g => Adjunction (Coyoneda f) (Coyoneda g)
- Data.Functor.Coyoneda: instance Alt f => Alt (Coyoneda f)
- Data.Functor.Coyoneda: instance Alternative f => Alternative (Coyoneda f)
- Data.Functor.Coyoneda: instance Applicative f => Applicative (Coyoneda f)
- Data.Functor.Coyoneda: instance Apply f => Apply (Coyoneda f)
- Data.Functor.Coyoneda: instance Bind m => Bind (Coyoneda m)
- Data.Functor.Coyoneda: instance Comonad w => Comonad (Coyoneda w)
- Data.Functor.Coyoneda: instance ComonadTrans Coyoneda
- Data.Functor.Coyoneda: instance Distributive f => Distributive (Coyoneda f)
- Data.Functor.Coyoneda: instance Extend w => Extend (Coyoneda w)
- Data.Functor.Coyoneda: instance Foldable f => Foldable (Coyoneda f)
- Data.Functor.Coyoneda: instance Foldable1 f => Foldable1 (Coyoneda f)
- Data.Functor.Coyoneda: instance Functor (Coyoneda f)
- Data.Functor.Coyoneda: instance Monad m => Monad (Coyoneda m)
- Data.Functor.Coyoneda: instance MonadFix f => MonadFix (Coyoneda f)
- Data.Functor.Coyoneda: instance MonadPlus f => MonadPlus (Coyoneda f)
- Data.Functor.Coyoneda: instance MonadTrans Coyoneda
- Data.Functor.Coyoneda: instance Plus f => Plus (Coyoneda f)
- Data.Functor.Coyoneda: instance Representable f => Representable (Coyoneda f)
- Data.Functor.Coyoneda: instance Traversable f => Traversable (Coyoneda f)
- Data.Functor.Coyoneda: instance Traversable1 f => Traversable1 (Coyoneda f)
- Data.Functor.Day: instance (Applicative f, Applicative g) => Applicative (Day f g)
- Data.Functor.Day: instance (Representable f, Representable g) => Distributive (Day f g)
- Data.Functor.Day: instance (Representable f, Representable g) => Representable (Day f g)
- Data.Functor.Day: instance Functor (Day f g)
- Data.Functor.Day: instance Typeable Day
- Data.Functor.Kan.Lan: instance (Functor g, Applicative h) => Applicative (Lan g h)
- Data.Functor.Kan.Lan: instance (Functor g, Apply h) => Apply (Lan g h)
- Data.Functor.Kan.Lan: instance Functor (Lan f g)
- Data.Functor.Kan.Lift: instance Functor (Lift g h)
- Data.Functor.Kan.Lift: runLift :: Lift g f a -> forall z. Functor z => (forall x. f x -> g (z x)) -> z a
- Data.Functor.Kan.Ran: instance Functor (Ran g h)
- Data.Functor.Kan.Ran: runRan :: Ran g h a -> forall b. (a -> g b) -> h b
- Data.Functor.Kan.Rift: instance (Functor g, g ~ h) => Applicative (Rift g h)
- Data.Functor.Kan.Rift: instance Functor g => Functor (Rift g h)
- Data.Functor.Kan.Rift: runRift :: Rift g h a -> forall r. g (a -> r) -> h r
- Data.Functor.Yoneda: instance (Functor f, MonadFree f m) => MonadFree f (Yoneda m)
- Data.Functor.Yoneda: instance (Functor f, Read (f a)) => Read (Yoneda f a)
- Data.Functor.Yoneda: instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g)
- Data.Functor.Yoneda: instance Alt f => Alt (Yoneda f)
- Data.Functor.Yoneda: instance Alternative f => Alternative (Yoneda f)
- Data.Functor.Yoneda: instance Applicative f => Applicative (Yoneda f)
- Data.Functor.Yoneda: instance Apply f => Apply (Yoneda f)
- Data.Functor.Yoneda: instance Bind m => Bind (Yoneda m)
- Data.Functor.Yoneda: instance Comonad w => Comonad (Yoneda w)
- Data.Functor.Yoneda: instance ComonadTrans Yoneda
- Data.Functor.Yoneda: instance Distributive f => Distributive (Yoneda f)
- Data.Functor.Yoneda: instance Eq (f a) => Eq (Yoneda f a)
- Data.Functor.Yoneda: instance Extend w => Extend (Yoneda w)
- Data.Functor.Yoneda: instance Foldable f => Foldable (Yoneda f)
- Data.Functor.Yoneda: instance Foldable1 f => Foldable1 (Yoneda f)
- Data.Functor.Yoneda: instance Functor (Yoneda f)
- Data.Functor.Yoneda: instance Monad m => Monad (Yoneda m)
- Data.Functor.Yoneda: instance MonadFix m => MonadFix (Yoneda m)
- Data.Functor.Yoneda: instance MonadPlus m => MonadPlus (Yoneda m)
- Data.Functor.Yoneda: instance MonadTrans Yoneda
- Data.Functor.Yoneda: instance Ord (f a) => Ord (Yoneda f a)
- Data.Functor.Yoneda: instance Plus f => Plus (Yoneda f)
- Data.Functor.Yoneda: instance Representable g => Representable (Yoneda g)
- Data.Functor.Yoneda: instance Show (f a) => Show (Yoneda f a)
- Data.Functor.Yoneda: instance Traversable f => Traversable (Yoneda f)
- Data.Functor.Yoneda: instance Traversable1 f => Traversable1 (Yoneda f)
- Data.Functor.Yoneda: runYoneda :: Yoneda f a -> forall b. (a -> b) -> f b
+ Control.Comonad.Density: instance Control.Comonad.Comonad (Control.Comonad.Density.Density f)
+ Control.Comonad.Density: instance Control.Comonad.Trans.Class.ComonadTrans Control.Comonad.Density.Density
+ Control.Comonad.Density: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Control.Comonad.Density.Density f)
+ Control.Comonad.Density: instance Data.Functor.Extend.Extend (Control.Comonad.Density.Density f)
+ Control.Comonad.Density: instance GHC.Base.Applicative f => GHC.Base.Applicative (Control.Comonad.Density.Density f)
+ Control.Comonad.Density: instance GHC.Base.Functor (Control.Comonad.Density.Density f)
+ Control.Monad.Co: [runCoT] :: CoT w m a -> forall r. w (a -> m r) -> m r
+ Control.Monad.Co: instance (Control.Comonad.Comonad w, Control.Monad.Error.Class.MonadError e m) => Control.Monad.Error.Class.MonadError e (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance (Control.Comonad.Comonad w, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance (Control.Comonad.Comonad w, Control.Monad.Reader.Class.MonadReader e m) => Control.Monad.Reader.Class.MonadReader e (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance (Control.Comonad.Comonad w, Control.Monad.State.Class.MonadState s m) => Control.Monad.State.Class.MonadState s (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance (Control.Comonad.Comonad w, Control.Monad.Writer.Class.MonadWriter e m) => Control.Monad.Writer.Class.MonadWriter e (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance Control.Comonad.Comonad w => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Co.CoT w)
+ Control.Monad.Co: instance Control.Comonad.Comonad w => GHC.Base.Applicative (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance Control.Comonad.Comonad w => GHC.Base.Monad (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance Data.Functor.Extend.Extend w => Data.Functor.Bind.Class.Apply (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance Data.Functor.Extend.Extend w => Data.Functor.Bind.Class.Bind (Control.Monad.Co.CoT w m)
+ Control.Monad.Co: instance GHC.Base.Functor w => GHC.Base.Functor (Control.Monad.Co.CoT w m)
+ Control.Monad.Codensity: [runCodensity] :: Codensity m a -> forall b. (a -> m b) -> m b
+ Control.Monad.Codensity: instance (GHC.Base.Functor f, Control.Monad.Free.Class.MonadFree f m) => Control.Monad.Free.Class.MonadFree f (Control.Monad.Codensity.Codensity m)
+ Control.Monad.Codensity: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Codensity.Codensity m)
+ Control.Monad.Codensity: instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Codensity.Codensity m)
+ Control.Monad.Codensity: instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.State.Class.MonadState r (Control.Monad.Codensity.Codensity m)
+ Control.Monad.Codensity: instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Codensity.Codensity
+ Control.Monad.Codensity: instance Data.Functor.Alt.Alt v => Data.Functor.Alt.Alt (Control.Monad.Codensity.Codensity v)
+ Control.Monad.Codensity: instance Data.Functor.Bind.Class.Apply (Control.Monad.Codensity.Codensity f)
+ Control.Monad.Codensity: instance Data.Functor.Plus.Plus v => Data.Functor.Plus.Plus (Control.Monad.Codensity.Codensity v)
+ Control.Monad.Codensity: instance GHC.Base.Alternative v => GHC.Base.Alternative (Control.Monad.Codensity.Codensity v)
+ Control.Monad.Codensity: instance GHC.Base.Applicative (Control.Monad.Codensity.Codensity f)
+ Control.Monad.Codensity: instance GHC.Base.Functor (Control.Monad.Codensity.Codensity k)
+ Control.Monad.Codensity: instance GHC.Base.Monad (Control.Monad.Codensity.Codensity f)
+ Control.Monad.Codensity: instance GHC.Base.MonadPlus v => GHC.Base.MonadPlus (Control.Monad.Codensity.Codensity v)
+ Data.Functor.Contravariant.Coyoneda: instance Data.Functor.Contravariant.Adjunction.Adjunction f g => Data.Functor.Contravariant.Adjunction.Adjunction (Data.Functor.Contravariant.Coyoneda.Coyoneda f) (Data.Functor.Contravariant.Coyoneda.Coyoneda g)
+ Data.Functor.Contravariant.Coyoneda: instance Data.Functor.Contravariant.Contravariant (Data.Functor.Contravariant.Coyoneda.Coyoneda f)
+ Data.Functor.Contravariant.Coyoneda: instance Data.Functor.Contravariant.Rep.Representable f => Data.Functor.Contravariant.Rep.Representable (Data.Functor.Contravariant.Coyoneda.Coyoneda f)
+ Data.Functor.Contravariant.Day: instance (Data.Functor.Contravariant.Rep.Representable f, Data.Functor.Contravariant.Rep.Representable g) => Data.Functor.Contravariant.Rep.Representable (Data.Functor.Contravariant.Day.Day f g)
+ Data.Functor.Contravariant.Day: instance Data.Functor.Contravariant.Contravariant (Data.Functor.Contravariant.Day.Day f g)
+ Data.Functor.Contravariant.Yoneda: [runYoneda] :: Yoneda f a -> forall r. (r -> a) -> f r
+ Data.Functor.Contravariant.Yoneda: instance Data.Functor.Contravariant.Adjunction.Adjunction f g => Data.Functor.Contravariant.Adjunction.Adjunction (Data.Functor.Contravariant.Yoneda.Yoneda f) (Data.Functor.Contravariant.Yoneda.Yoneda g)
+ Data.Functor.Contravariant.Yoneda: instance Data.Functor.Contravariant.Contravariant (Data.Functor.Contravariant.Yoneda.Yoneda f)
+ Data.Functor.Contravariant.Yoneda: instance Data.Functor.Contravariant.Rep.Representable f => Data.Functor.Contravariant.Rep.Representable (Data.Functor.Contravariant.Yoneda.Yoneda f)
+ Data.Functor.Coyoneda: instance (GHC.Base.Functor f, GHC.Classes.Eq (f a)) => GHC.Classes.Eq (Data.Functor.Coyoneda.Coyoneda f a)
+ Data.Functor.Coyoneda: instance (GHC.Base.Functor f, GHC.Classes.Ord (f a)) => GHC.Classes.Ord (Data.Functor.Coyoneda.Coyoneda f a)
+ Data.Functor.Coyoneda: instance (GHC.Base.Functor f, GHC.Read.Read (f a)) => GHC.Read.Read (Data.Functor.Coyoneda.Coyoneda f a)
+ Data.Functor.Coyoneda: instance (GHC.Base.Functor f, GHC.Show.Show (f a)) => GHC.Show.Show (Data.Functor.Coyoneda.Coyoneda f a)
+ Data.Functor.Coyoneda: instance Control.Comonad.Comonad w => Control.Comonad.Comonad (Data.Functor.Coyoneda.Coyoneda w)
+ Data.Functor.Coyoneda: instance Control.Comonad.Trans.Class.ComonadTrans Data.Functor.Coyoneda.Coyoneda
+ Data.Functor.Coyoneda: instance Control.Monad.Fix.MonadFix f => Control.Monad.Fix.MonadFix (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Control.Monad.Trans.Class.MonadTrans Data.Functor.Coyoneda.Coyoneda
+ Data.Functor.Coyoneda: instance Data.Distributive.Distributive f => Data.Distributive.Distributive (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Functor.Adjunction.Adjunction f g => Data.Functor.Adjunction.Adjunction (Data.Functor.Coyoneda.Coyoneda f) (Data.Functor.Coyoneda.Coyoneda g)
+ Data.Functor.Coyoneda: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Data.Functor.Coyoneda.Coyoneda m)
+ Data.Functor.Coyoneda: instance Data.Functor.Extend.Extend w => Data.Functor.Extend.Extend (Data.Functor.Coyoneda.Coyoneda w)
+ Data.Functor.Coyoneda: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Functor.Rep.Representable f => Data.Functor.Rep.Representable (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Foldable1 (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance GHC.Base.Functor (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Coyoneda: instance GHC.Base.Monad m => GHC.Base.Monad (Data.Functor.Coyoneda.Coyoneda m)
+ Data.Functor.Coyoneda: instance GHC.Base.MonadPlus f => GHC.Base.MonadPlus (Data.Functor.Coyoneda.Coyoneda f)
+ Data.Functor.Day: instance (Data.Functor.Rep.Representable f, Data.Functor.Rep.Representable g) => Data.Distributive.Distributive (Data.Functor.Day.Day f g)
+ Data.Functor.Day: instance (Data.Functor.Rep.Representable f, Data.Functor.Rep.Representable g) => Data.Functor.Rep.Representable (Data.Functor.Day.Day f g)
+ Data.Functor.Day: instance (GHC.Base.Applicative f, GHC.Base.Applicative g) => GHC.Base.Applicative (Data.Functor.Day.Day f g)
+ Data.Functor.Day: instance GHC.Base.Functor (Data.Functor.Day.Day f g)
+ Data.Functor.Kan.Lan: instance (GHC.Base.Functor g, Data.Functor.Bind.Class.Apply h) => Data.Functor.Bind.Class.Apply (Data.Functor.Kan.Lan.Lan g h)
+ Data.Functor.Kan.Lan: instance (GHC.Base.Functor g, GHC.Base.Applicative h) => GHC.Base.Applicative (Data.Functor.Kan.Lan.Lan g h)
+ Data.Functor.Kan.Lan: instance GHC.Base.Functor (Data.Functor.Kan.Lan.Lan f g)
+ Data.Functor.Kan.Lift: [runLift] :: Lift g f a -> forall z. Functor z => (forall x. f x -> g (z x)) -> z a
+ Data.Functor.Kan.Lift: instance GHC.Base.Functor (Data.Functor.Kan.Lift.Lift g h)
+ Data.Functor.Kan.Ran: [runRan] :: Ran g h a -> forall b. (a -> g b) -> h b
+ Data.Functor.Kan.Ran: instance GHC.Base.Functor (Data.Functor.Kan.Ran.Ran g h)
+ Data.Functor.Kan.Rift: [runRift] :: Rift g h a -> forall r. g (a -> r) -> h r
+ Data.Functor.Kan.Rift: instance (GHC.Base.Functor g, g ~ h) => GHC.Base.Applicative (Data.Functor.Kan.Rift.Rift g h)
+ Data.Functor.Kan.Rift: instance GHC.Base.Functor g => GHC.Base.Functor (Data.Functor.Kan.Rift.Rift g h)
+ Data.Functor.Yoneda: [runYoneda] :: Yoneda f a -> forall b. (a -> b) -> f b
+ Data.Functor.Yoneda: instance (GHC.Base.Functor f, Control.Monad.Free.Class.MonadFree f m) => Control.Monad.Free.Class.MonadFree f (Data.Functor.Yoneda.Yoneda m)
+ Data.Functor.Yoneda: instance (GHC.Base.Functor f, GHC.Read.Read (f a)) => GHC.Read.Read (Data.Functor.Yoneda.Yoneda f a)
+ Data.Functor.Yoneda: instance Control.Comonad.Comonad w => Control.Comonad.Comonad (Data.Functor.Yoneda.Yoneda w)
+ Data.Functor.Yoneda: instance Control.Comonad.Trans.Class.ComonadTrans Data.Functor.Yoneda.Yoneda
+ Data.Functor.Yoneda: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Data.Functor.Yoneda.Yoneda m)
+ Data.Functor.Yoneda: instance Control.Monad.Trans.Class.MonadTrans Data.Functor.Yoneda.Yoneda
+ Data.Functor.Yoneda: instance Data.Distributive.Distributive f => Data.Distributive.Distributive (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Functor.Adjunction.Adjunction f g => Data.Functor.Adjunction.Adjunction (Data.Functor.Yoneda.Yoneda f) (Data.Functor.Yoneda.Yoneda g)
+ Data.Functor.Yoneda: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Functor.Bind.Class.Bind m => Data.Functor.Bind.Class.Bind (Data.Functor.Yoneda.Yoneda m)
+ Data.Functor.Yoneda: instance Data.Functor.Extend.Extend w => Data.Functor.Extend.Extend (Data.Functor.Yoneda.Yoneda w)
+ Data.Functor.Yoneda: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Functor.Rep.Representable g => Data.Functor.Rep.Representable (Data.Functor.Yoneda.Yoneda g)
+ Data.Functor.Yoneda: instance Data.Semigroup.Foldable.Class.Foldable1 f => Data.Semigroup.Foldable.Class.Foldable1 (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Semigroup.Traversable.Class.Traversable1 f => Data.Semigroup.Traversable.Class.Traversable1 (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance GHC.Base.Functor (Data.Functor.Yoneda.Yoneda f)
+ Data.Functor.Yoneda: instance GHC.Base.Monad m => GHC.Base.Monad (Data.Functor.Yoneda.Yoneda m)
+ Data.Functor.Yoneda: instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Data.Functor.Yoneda.Yoneda m)
+ Data.Functor.Yoneda: instance GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Functor.Yoneda.Yoneda f a)
+ Data.Functor.Yoneda: instance GHC.Classes.Ord (f a) => GHC.Classes.Ord (Data.Functor.Yoneda.Yoneda f a)
+ Data.Functor.Yoneda: instance GHC.Show.Show (f a) => GHC.Show.Show (Data.Functor.Yoneda.Yoneda f a)

Files

.travis.yml view
@@ -1,8 +1,97 @@-language: haskell+# This file has been generated -- see https://github.com/hvr/multi-ghc-travis+language: c+sudo: false++cache:+  directories:+    - $HOME/.cabsnap+    - $HOME/.cabal/packages++before_cache:+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar++matrix:+  include:+    - env: CABALVER=1.16 GHCVER=7.4.2+      compiler: ": #GHC 7.4.2"+      addons: {apt: {packages: [cabal-install-1.16,ghc-7.4.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+    - env: CABALVER=1.16 GHCVER=7.6.3+      compiler: ": #GHC 7.6.3"+      addons: {apt: {packages: [cabal-install-1.16,ghc-7.6.3,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+    - env: CABALVER=1.18 GHCVER=7.8.4+      compiler: ": #GHC 7.8.4"+      addons: {apt: {packages: [cabal-install-1.18,ghc-7.8.4,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+    - env: CABALVER=1.22 GHCVER=7.10.1+      compiler: ": #GHC 7.10.1"+      addons: {apt: {packages: [cabal-install-1.22,ghc-7.10.1,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+    - env: CABALVER=1.22 GHCVER=7.10.2+      compiler: ": #GHC 7.10.2"+      addons: {apt: {packages: [cabal-install-1.22,ghc-7.10.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}++before_install:+ - unset CC+ - export HAPPYVER=1.19.5+ - export ALEXVER=3.1.4+ - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:/opt/happy/$HAPPYVER/bin:/opt/alex/$ALEXVER/bin:$PATH++install:+ - cabal --version+ - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"+ - if [ -f $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz ];+   then+     zcat $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz >+          $HOME/.cabal/packages/hackage.haskell.org/00-index.tar;+   fi+ - travis_retry cabal update+ - "sed -i  's/^jobs:.*$/jobs: 2/' $HOME/.cabal/config"+ - cabal install --only-dependencies --enable-tests --enable-benchmarks --dry -v > installplan.txt+ - sed -i -e '1,/^Resolving /d' installplan.txt; cat installplan.txt++# check whether current requested install-plan matches cached package-db snapshot+ - if diff -u installplan.txt $HOME/.cabsnap/installplan.txt;+   then+     echo "cabal build-cache HIT";+     rm -rfv .ghc;+     cp -a $HOME/.cabsnap/ghc $HOME/.ghc;+     cp -a $HOME/.cabsnap/lib $HOME/.cabsnap/share $HOME/.cabsnap/bin $HOME/.cabal/;+   else+     echo "cabal build-cache MISS";+     rm -rf $HOME/.cabsnap;+     mkdir -p $HOME/.ghc $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin;+     cabal install --only-dependencies --enable-tests --enable-benchmarks;+     if [ "$GHCVER" = "7.10.1" ]; then cabal install Cabal-1.22.4.0; fi;+   fi++# snapshot package-db on cache miss+ - if [ ! -d $HOME/.cabsnap ];+   then+      echo "snapshotting package-db to build-cache";+      mkdir $HOME/.cabsnap;+      cp -a $HOME/.ghc $HOME/.cabsnap/ghc;+      cp -a $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin installplan.txt $HOME/.cabsnap/;+   fi++# Here starts the actual work to be performed for the package under test;+# any command which exits with a non-zero exit code causes the build to fail.+script:+ - cabal configure --enable-tests -v2  # -v2 provides useful information for debugging+ - cabal build   # this builds all libraries and executables (including tests)+ - cabal test+ - cabal bench || true  # expected result: these will crash+ - cabal sdist || true  # tests that a source-distribution can be generated++# Check that the resulting source distribution can be built & installed.+# If there are no other `.tar.gz` files in `dist`, this can be even simpler:+# `cabal install --force-reinstalls dist/*-*.tar.gz`+ - SRC_TGZ=$(cabal info . | awk '{print $2;exit}').tar.gz &&+   (cd dist && cabal install --force-reinstalls "$SRC_TGZ")+ notifications:   irc:     channels:       - "irc.freenode.org#haskell-lens"     skip_join: true     template:-      - "\x0313kan-extensions\x03/\x0306%{branch}\x03 \x0314%{commit}\x03 %{build_url} %{message}"+      - "\x0313kan-extensions\x0f/\x0306%{branch}\x0f \x0314%{commit}\x0f %{message} \x0302\x1f%{build_url}\x0f"+# EOF
CHANGELOG.markdown view
@@ -1,3 +1,7 @@+4.2.3+-----+* Builds clean on GHC 7.10+ 4.2.2 ----- * `semigroupoids` 5 support
README.markdown view
@@ -1,7 +1,7 @@ kan-extensions ============== -[![Build Status](https://secure.travis-ci.org/ekmett/kan-extensions.png?branch=master)](http://travis-ci.org/ekmett/kan-extensions)+[![Hackage](https://img.shields.io/hackage/v/kan-extensions.svg)](https://hackage.haskell.org/package/kan-extensions) [![Build Status](https://secure.travis-ci.org/ekmett/kan-extensions.png?branch=master)](http://travis-ci.org/ekmett/kan-extensions)  This package provides tools for working with various Kan extensions and Kan lifts in Haskell. 
kan-extensions.cabal view
@@ -1,6 +1,6 @@ name:          kan-extensions category:      Data Structures, Monads, Comonads, Functors-version:       4.2.2+version:       4.2.3 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE
src/Control/Comonad/Density.hs view
@@ -1,6 +1,7 @@-{-# LANGUAGE MultiParamTypeClasses, GADTs #-} {-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710 {-# LANGUAGE Trustworthy #-} #endif -----------------------------------------------------------------------------
src/Control/Monad/Co.hs view
@@ -1,10 +1,10 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710 {-# LANGUAGE Trustworthy #-} #endif -----------------------------------------------------------------------------@@ -54,7 +54,9 @@   , askW, asksW, traceW   )where +#if __GLASGOW_HASKELL__ < 710 import Control.Applicative+#endif import Control.Comonad import Control.Comonad.Cofree import Control.Comonad.Density
src/Data/Functor/Contravariant/Day.hs view
@@ -8,7 +8,7 @@ #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ <= 707 {-# LANGUAGE KindSignatures #-} #endif-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710 {-# LANGUAGE Trustworthy #-} #endif -----------------------------------------------------------------------------@@ -38,7 +38,9 @@   , trans1, trans2   ) where +#if __GLASGOW_HASKELL__ < 710 import Control.Applicative+#endif import Data.Functor.Contravariant import Data.Functor.Contravariant.Rep import Data.Proxy
src/Data/Functor/Coyoneda.hs view
@@ -70,8 +70,8 @@ lanToCoyoneda :: Lan Identity f a -> Coyoneda f a lanToCoyoneda (Lan iba fb) = Coyoneda (iba . Identity) fb -{-# RULES "coyonedaToLan/lanToCoyoneda=id" coyonedaToLan . lanToCoyoneda = id #-}-{-# RULES "lanToCoyoneda/coyonedaToLan=id" lanToCoyoneda . coyonedaToLan = id #-}+-- {-# RULES "coyonedaToLan/lanToCoyoneda=id" coyonedaToLan . lanToCoyoneda = id #-}+-- {-# RULES "lanToCoyoneda/coyonedaToLan=id" lanToCoyoneda . coyonedaToLan = id #-}  -- | @'Coyoneda' f@ is the left Kan lift of @f@ along the 'Identity' functor. --@@ -85,8 +85,8 @@ liftToCoyoneda :: Functor f => Lift Identity f a -> Coyoneda f a liftToCoyoneda (Lift m) = Coyoneda id (m Identity) -{-# RULES "coyonedaToLift/liftToCoyoneda=id" coyonedaToLift . liftToCoyoneda = id #-}-{-# RULES "liftToCoyoneda/coyonedaToLift=id" liftToCoyoneda . coyonedaToLift = id #-}+-- {-# RULES "coyonedaToLift/liftToCoyoneda=id" coyonedaToLift . liftToCoyoneda = id #-}+-- {-# RULES "liftToCoyoneda/coyonedaToLift=id" liftToCoyoneda . coyonedaToLift = id #-}  instance Functor (Coyoneda f) where   fmap f (Coyoneda g v) = Coyoneda (f . g) v
src/Data/Functor/Kan/Lan.hs view
@@ -1,6 +1,7 @@-{-# LANGUAGE Rank2Types, GADTs #-} {-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702+{-# LANGUAGE GADTs #-}+{-# LANGUAGE Rank2Types #-}+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710 {-# LANGUAGE Trustworthy #-} #endif -------------------------------------------------------------------------------------------
src/Data/Functor/Kan/Ran.hs view
@@ -37,7 +37,7 @@ -- the definition in of a right Kan extension in terms of an End, but we can derive an equivalent definition -- from the universal property. ----- Given a 'Functor' @h : C -> D@ and a 'Functor' @g : C -> C'@, we want to find extend @h@ /back/ along @g@+-- Given a 'Functor' @h : C -> D@ and a 'Functor' @g : C -> C'@, we want to extend @h@ /back/ along @g@ -- to give @Ran g h : C' -> C@, such that the natural transformation @'gran' :: Ran g h (g a) -> h a@ exists. -- -- In some sense this is trying to approximate the inverse of @g@ by using one of
src/Data/Functor/Kan/Rift.hs view
@@ -2,7 +2,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE GADTs #-} -#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702+#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710 {-# LANGUAGE Trustworthy #-} #endif -------------------------------------------------------------------------------------------@@ -29,7 +29,9 @@   , liftRift, lowerRift, rap   ) where +#if __GLASGOW_HASKELL__ < 710 import Control.Applicative+#endif import Data.Functor.Adjunction import Data.Functor.Composition import Data.Functor.Identity
src/Data/Functor/Yoneda.hs view
@@ -89,8 +89,8 @@ lowerYoneda :: Yoneda f a -> f a lowerYoneda (Yoneda f) = f id -{-# RULES "lower/lift=id" liftYoneda . lowerYoneda = id #-}-{-# RULES "lift/lower=id" lowerYoneda . liftYoneda = id #-}+-- {-# RULES "lower/lift=id" liftYoneda . lowerYoneda = id #-}+--{-# RULES "lift/lower=id" lowerYoneda . liftYoneda = id #-}  -- | @Yoneda f@ can be viewed as the right Kan extension of @f@ along the 'Identity' functor. --@@ -104,8 +104,8 @@ ranToYoneda :: Ran Identity f a -> Yoneda f a ranToYoneda (Ran m) = Yoneda (m . fmap Identity) -{-# RULES "yonedaToRan/ranToYoneda=id" yonedaToRan . ranToYoneda = id #-}-{-# RULES "ranToYoneda/yonedaToRan=id" ranToYoneda . yonedaToRan = id #-}+-- {-# RULES "yonedaToRan/ranToYoneda=id" yonedaToRan . ranToYoneda = id #-}+-- {-# RULES "ranToYoneda/yonedaToRan=id" ranToYoneda . yonedaToRan = id #-}  -- | @Yoneda f@ can be viewed as the right Kan lift of @f@ along the 'Identity' functor. --@@ -121,8 +121,8 @@ riftToYoneda m = Yoneda (runRift m . Identity) {-# INLINE riftToYoneda #-} -{-# RULES "yonedaToRift/riftToYoneda=id" yonedaToRift . riftToYoneda = id #-}-{-# RULES "riftToYoneda/yonedaToRift=id" riftToYoneda . yonedaToRift = id #-}+-- {-# RULES "yonedaToRift/riftToYoneda=id" yonedaToRift . riftToYoneda = id #-}+-- {-# RULES "riftToYoneda/yonedaToRift=id" riftToYoneda . yonedaToRift = id #-}  instance Functor (Yoneda f) where   fmap f m = Yoneda (\k -> runYoneda m (k . f))