keys 3.10.2 → 3.11

raw patch · 5 files changed

+28/−24 lines, 5 filesdep +transformers-compatdep ~comonaddep ~semigroupoidsdep ~transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: transformers-compat

Dependency ranges changed: comonad, semigroupoids, transformers, unordered-containers

API changes (from Hackage documentation)

- Data.Key: instance (Adjustable f, Adjustable g) => Adjustable (Coproduct f g)

- Data.Key: instance (Adjustable f, Adjustable g) => Adjustable (Product f g)

- Data.Key: instance (Eq k, Hashable k) => Indexable (HashMap k)

- Data.Key: instance (Eq k, Hashable k) => Lookup (HashMap k)

- Data.Key: instance (Eq k, Hashable k) => Zip (HashMap k)

- Data.Key: instance (Eq k, Hashable k) => ZipWithKey (HashMap k)

- Data.Key: instance (FoldableWithKey f, FoldableWithKey g) => FoldableWithKey (Product f g)

- Data.Key: instance (FoldableWithKey f, FoldableWithKey m) => FoldableWithKey (Compose f m)

- Data.Key: instance (FoldableWithKey1 f, FoldableWithKey1 g) => FoldableWithKey1 (Product f g)

- Data.Key: instance (FoldableWithKey1 f, FoldableWithKey1 m) => FoldableWithKey1 (Compose f m)

- Data.Key: instance (Indexable f, Indexable g) => Indexable (Compose f g)

- Data.Key: instance (Indexable f, Indexable g) => Indexable (Coproduct f g)

- Data.Key: instance (Indexable f, Indexable g) => Indexable (Product f g)

- Data.Key: instance (Keyed f, Keyed g) => Keyed (Compose f g)

- Data.Key: instance (Keyed f, Keyed g) => Keyed (Product f g)

- Data.Key: instance (Lookup f, Lookup g) => Lookup (Compose f g)

- Data.Key: instance (Lookup f, Lookup g) => Lookup (Coproduct f g)

- Data.Key: instance (Lookup f, Lookup g) => Lookup (Product f g)

- Data.Key: instance (TraversableWithKey f, TraversableWithKey g) => TraversableWithKey (Product f g)

- Data.Key: instance (TraversableWithKey f, TraversableWithKey m) => TraversableWithKey (Compose f m)

- Data.Key: instance (TraversableWithKey1 f, TraversableWithKey1 g) => TraversableWithKey1 (Product f g)

- Data.Key: instance (TraversableWithKey1 f, TraversableWithKey1 m) => TraversableWithKey1 (Compose f m)

- Data.Key: instance (Zip f, Zip g) => Zip (Compose f g)

- Data.Key: instance (Zip f, Zip g) => Zip (Product f g)

- Data.Key: instance (ZipWithKey f, ZipWithKey g) => ZipWithKey (Compose f g)

- Data.Key: instance (ZipWithKey f, ZipWithKey g) => ZipWithKey (Product f g)

- Data.Key: instance Adjustable Identity

- Data.Key: instance Adjustable IntMap

- Data.Key: instance Adjustable NonEmpty

- Data.Key: instance Adjustable Seq

- Data.Key: instance Adjustable Tree

- Data.Key: instance Adjustable []

- Data.Key: instance Adjustable f => Adjustable (Cofree f)

- Data.Key: instance Adjustable f => Adjustable (Free f)

- Data.Key: instance Applicative (StateL s)

- Data.Key: instance Applicative (StateR s)

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

- Data.Key: instance FoldableWithKey ((,) k)

- Data.Key: instance FoldableWithKey (HashMap k)

- Data.Key: instance FoldableWithKey (Map k)

- Data.Key: instance FoldableWithKey Identity

- Data.Key: instance FoldableWithKey IntMap

- Data.Key: instance FoldableWithKey Maybe

- Data.Key: instance FoldableWithKey NonEmpty

- Data.Key: instance FoldableWithKey Seq

- Data.Key: instance FoldableWithKey Tree

- Data.Key: instance FoldableWithKey []

- Data.Key: instance FoldableWithKey f => FoldableWithKey (Cofree f)

- Data.Key: instance FoldableWithKey f => FoldableWithKey (Free f)

- Data.Key: instance FoldableWithKey m => FoldableWithKey (IdentityT m)

- Data.Key: instance FoldableWithKey1 ((,) k)

- Data.Key: instance FoldableWithKey1 Identity

- Data.Key: instance FoldableWithKey1 NonEmpty

- Data.Key: instance FoldableWithKey1 Tree

- Data.Key: instance FoldableWithKey1 f => FoldableWithKey1 (Cofree f)

- Data.Key: instance FoldableWithKey1 f => FoldableWithKey1 (Free f)

- Data.Key: instance FoldableWithKey1 m => FoldableWithKey1 (IdentityT m)

- Data.Key: instance Functor (StateL s)

- Data.Key: instance Functor (StateR s)

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

- Data.Key: instance Indexable ((->) a)

- Data.Key: instance Indexable Identity

- Data.Key: instance Indexable IntMap

- Data.Key: instance Indexable Maybe

- Data.Key: instance Indexable NonEmpty

- Data.Key: instance Indexable Seq

- Data.Key: instance Indexable Tree

- Data.Key: instance Indexable []

- Data.Key: instance Indexable f => Indexable (Cofree f)

- Data.Key: instance Indexable m => Indexable (IdentityT m)

- Data.Key: instance Indexable m => Indexable (ReaderT e m)

- Data.Key: instance Indexable w => Indexable (TracedT s w)

- Data.Key: instance Ix i => Adjustable (Array i)

- Data.Key: instance Ix i => FoldableWithKey (Array i)

- Data.Key: instance Ix i => Indexable (Array i)

- Data.Key: instance Ix i => Keyed (Array i)

- Data.Key: instance Ix i => Lookup (Array i)

- Data.Key: instance Ix i => TraversableWithKey (Array i)

- Data.Key: instance Keyed ((,) k)

- Data.Key: instance Keyed ((->) a)

- Data.Key: instance Keyed (HashMap k)

- Data.Key: instance Keyed (Map k)

- Data.Key: instance Keyed Identity

- Data.Key: instance Keyed IntMap

- Data.Key: instance Keyed Maybe

- Data.Key: instance Keyed NonEmpty

- Data.Key: instance Keyed Seq

- Data.Key: instance Keyed Tree

- Data.Key: instance Keyed []

- Data.Key: instance Keyed f => Keyed (Cofree f)

- Data.Key: instance Keyed f => Keyed (Free f)

- Data.Key: instance Keyed m => Keyed (IdentityT m)

- Data.Key: instance Keyed m => Keyed (ReaderT e m)

- Data.Key: instance Keyed w => Keyed (TracedT s w)

- Data.Key: instance Lookup ((->) a)

- Data.Key: instance Lookup Identity

- Data.Key: instance Lookup IntMap

- Data.Key: instance Lookup Maybe

- Data.Key: instance Lookup NonEmpty

- Data.Key: instance Lookup Seq

- Data.Key: instance Lookup Tree

- Data.Key: instance Lookup []

- Data.Key: instance Lookup f => Lookup (Cofree f)

- Data.Key: instance Lookup f => Lookup (Free f)

- Data.Key: instance Lookup m => Lookup (IdentityT m)

- Data.Key: instance Lookup m => Lookup (ReaderT e m)

- Data.Key: instance Lookup w => Lookup (TracedT s w)

- Data.Key: instance Ord k => Adjustable (Map k)

- Data.Key: instance Ord k => Indexable (Map k)

- Data.Key: instance Ord k => Lookup (Map k)

- Data.Key: instance Ord k => Zip (Map k)

- Data.Key: instance Ord k => ZipWithKey (Map k)

- Data.Key: instance TraversableWithKey ((,) k)

- Data.Key: instance TraversableWithKey (HashMap k)

- Data.Key: instance TraversableWithKey (Map k)

- Data.Key: instance TraversableWithKey Identity

- Data.Key: instance TraversableWithKey IntMap

- Data.Key: instance TraversableWithKey Maybe

- Data.Key: instance TraversableWithKey NonEmpty

- Data.Key: instance TraversableWithKey Seq

- Data.Key: instance TraversableWithKey Tree

- Data.Key: instance TraversableWithKey []

- Data.Key: instance TraversableWithKey f => TraversableWithKey (Cofree f)

- Data.Key: instance TraversableWithKey f => TraversableWithKey (Free f)

- Data.Key: instance TraversableWithKey m => TraversableWithKey (IdentityT m)

- Data.Key: instance TraversableWithKey1 ((,) k)

- Data.Key: instance TraversableWithKey1 Identity

- Data.Key: instance TraversableWithKey1 NonEmpty

- Data.Key: instance TraversableWithKey1 Tree

- Data.Key: instance TraversableWithKey1 f => TraversableWithKey1 (Cofree f)

- Data.Key: instance TraversableWithKey1 f => TraversableWithKey1 (Free f)

- Data.Key: instance TraversableWithKey1 m => TraversableWithKey1 (IdentityT m)

- Data.Key: instance Zip ((->) a)

- Data.Key: instance Zip Identity

- Data.Key: instance Zip IntMap

- Data.Key: instance Zip Maybe

- Data.Key: instance Zip NonEmpty

- Data.Key: instance Zip Seq

- Data.Key: instance Zip Tree

- Data.Key: instance Zip []

- Data.Key: instance Zip f => Zip (Cofree f)

- Data.Key: instance Zip m => Zip (IdentityT m)

- Data.Key: instance Zip m => Zip (ReaderT e m)

- Data.Key: instance Zip w => Zip (TracedT s w)

- Data.Key: instance ZipWithKey ((->) a)

- Data.Key: instance ZipWithKey Identity

- Data.Key: instance ZipWithKey IntMap

- Data.Key: instance ZipWithKey Maybe

- Data.Key: instance ZipWithKey NonEmpty

- Data.Key: instance ZipWithKey Seq

- Data.Key: instance ZipWithKey Tree

- Data.Key: instance ZipWithKey []

- Data.Key: instance ZipWithKey f => ZipWithKey (Cofree f)

- Data.Key: instance ZipWithKey m => ZipWithKey (IdentityT m)

- Data.Key: instance ZipWithKey m => ZipWithKey (ReaderT e m)

- Data.Key: instance ZipWithKey w => ZipWithKey (TracedT s w)

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

+ Data.Key: instance (Data.Key.Adjustable f, Data.Key.Adjustable g) => Data.Key.Adjustable (Data.Functor.Sum.Sum f g)

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

+ Data.Key: instance (Data.Key.FoldableWithKey f, Data.Key.FoldableWithKey m) => Data.Key.FoldableWithKey (Data.Functor.Compose.Compose f m)

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

+ Data.Key: instance (Data.Key.FoldableWithKey1 f, Data.Key.FoldableWithKey1 m) => Data.Key.FoldableWithKey1 (Data.Functor.Compose.Compose f m)

+ Data.Key: instance (Data.Key.Indexable f, Data.Key.Indexable g) => Data.Key.Indexable (Data.Functor.Compose.Compose f g)

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

+ Data.Key: instance (Data.Key.Indexable f, Data.Key.Indexable g) => Data.Key.Indexable (Data.Functor.Sum.Sum f g)

+ Data.Key: instance (Data.Key.Keyed f, Data.Key.Keyed g) => Data.Key.Keyed (Data.Functor.Compose.Compose f g)

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

+ Data.Key: instance (Data.Key.Lookup f, Data.Key.Lookup g) => Data.Key.Lookup (Data.Functor.Compose.Compose f g)

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

+ Data.Key: instance (Data.Key.Lookup f, Data.Key.Lookup g) => Data.Key.Lookup (Data.Functor.Sum.Sum f g)

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

+ Data.Key: instance (Data.Key.TraversableWithKey f, Data.Key.TraversableWithKey m) => Data.Key.TraversableWithKey (Data.Functor.Compose.Compose f m)

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

+ Data.Key: instance (Data.Key.TraversableWithKey1 f, Data.Key.TraversableWithKey1 m) => Data.Key.TraversableWithKey1 (Data.Functor.Compose.Compose f m)

+ Data.Key: instance (Data.Key.Zip f, Data.Key.Zip g) => Data.Key.Zip (Data.Functor.Compose.Compose f g)

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

+ Data.Key: instance (Data.Key.ZipWithKey f, Data.Key.ZipWithKey g) => Data.Key.ZipWithKey (Data.Functor.Compose.Compose f g)

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

+ Data.Key: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Key.Indexable (Data.HashMap.Base.HashMap k)

+ Data.Key: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Key.Lookup (Data.HashMap.Base.HashMap k)

+ Data.Key: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Key.Zip (Data.HashMap.Base.HashMap k)

+ Data.Key: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Key.ZipWithKey (Data.HashMap.Base.HashMap k)

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

+ Data.Key: instance Data.Key.Adjustable Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.Adjustable Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.Adjustable Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.Adjustable Data.Sequence.Seq

+ Data.Key: instance Data.Key.Adjustable Data.Tree.Tree

+ Data.Key: instance Data.Key.Adjustable []

+ Data.Key: instance Data.Key.Adjustable f => Data.Key.Adjustable (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.Adjustable f => Data.Key.Adjustable (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.FoldableWithKey ((,) k)

+ Data.Key: instance Data.Key.FoldableWithKey (Data.HashMap.Base.HashMap k)

+ Data.Key: instance Data.Key.FoldableWithKey (Data.Map.Base.Map k)

+ Data.Key: instance Data.Key.FoldableWithKey Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.FoldableWithKey Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.FoldableWithKey Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.FoldableWithKey Data.Sequence.Seq

+ Data.Key: instance Data.Key.FoldableWithKey Data.Tree.Tree

+ Data.Key: instance Data.Key.FoldableWithKey GHC.Base.Maybe

+ Data.Key: instance Data.Key.FoldableWithKey []

+ Data.Key: instance Data.Key.FoldableWithKey f => Data.Key.FoldableWithKey (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.FoldableWithKey f => Data.Key.FoldableWithKey (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.FoldableWithKey m => Data.Key.FoldableWithKey (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.FoldableWithKey1 ((,) k)

+ Data.Key: instance Data.Key.FoldableWithKey1 Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.FoldableWithKey1 Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.FoldableWithKey1 Data.Tree.Tree

+ Data.Key: instance Data.Key.FoldableWithKey1 f => Data.Key.FoldableWithKey1 (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.FoldableWithKey1 f => Data.Key.FoldableWithKey1 (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.FoldableWithKey1 m => Data.Key.FoldableWithKey1 (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Indexable ((->) a)

+ Data.Key: instance Data.Key.Indexable Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.Indexable Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.Indexable Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.Indexable Data.Sequence.Seq

+ Data.Key: instance Data.Key.Indexable Data.Tree.Tree

+ Data.Key: instance Data.Key.Indexable GHC.Base.Maybe

+ Data.Key: instance Data.Key.Indexable []

+ Data.Key: instance Data.Key.Indexable f => Data.Key.Indexable (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.Indexable m => Data.Key.Indexable (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Indexable m => Data.Key.Indexable (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Key: instance Data.Key.Indexable w => Data.Key.Indexable (Control.Comonad.Trans.Traced.TracedT s w)

+ Data.Key: instance Data.Key.Keyed ((,) k)

+ Data.Key: instance Data.Key.Keyed ((->) a)

+ Data.Key: instance Data.Key.Keyed (Data.HashMap.Base.HashMap k)

+ Data.Key: instance Data.Key.Keyed (Data.Map.Base.Map k)

+ Data.Key: instance Data.Key.Keyed Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.Keyed Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.Keyed Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.Keyed Data.Sequence.Seq

+ Data.Key: instance Data.Key.Keyed Data.Tree.Tree

+ Data.Key: instance Data.Key.Keyed GHC.Base.Maybe

+ Data.Key: instance Data.Key.Keyed []

+ Data.Key: instance Data.Key.Keyed f => Data.Key.Keyed (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.Keyed f => Data.Key.Keyed (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.Keyed m => Data.Key.Keyed (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Keyed m => Data.Key.Keyed (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Key: instance Data.Key.Keyed w => Data.Key.Keyed (Control.Comonad.Trans.Traced.TracedT s w)

+ Data.Key: instance Data.Key.Lookup ((->) a)

+ Data.Key: instance Data.Key.Lookup Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.Lookup Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.Lookup Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.Lookup Data.Sequence.Seq

+ Data.Key: instance Data.Key.Lookup Data.Tree.Tree

+ Data.Key: instance Data.Key.Lookup GHC.Base.Maybe

+ Data.Key: instance Data.Key.Lookup []

+ Data.Key: instance Data.Key.Lookup f => Data.Key.Lookup (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.Lookup f => Data.Key.Lookup (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.Lookup m => Data.Key.Lookup (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Lookup m => Data.Key.Lookup (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Key: instance Data.Key.Lookup w => Data.Key.Lookup (Control.Comonad.Trans.Traced.TracedT s w)

+ Data.Key: instance Data.Key.TraversableWithKey ((,) k)

+ Data.Key: instance Data.Key.TraversableWithKey (Data.HashMap.Base.HashMap k)

+ Data.Key: instance Data.Key.TraversableWithKey (Data.Map.Base.Map k)

+ Data.Key: instance Data.Key.TraversableWithKey Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.TraversableWithKey Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.TraversableWithKey Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.TraversableWithKey Data.Sequence.Seq

+ Data.Key: instance Data.Key.TraversableWithKey Data.Tree.Tree

+ Data.Key: instance Data.Key.TraversableWithKey GHC.Base.Maybe

+ Data.Key: instance Data.Key.TraversableWithKey []

+ Data.Key: instance Data.Key.TraversableWithKey f => Data.Key.TraversableWithKey (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.TraversableWithKey f => Data.Key.TraversableWithKey (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.TraversableWithKey m => Data.Key.TraversableWithKey (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.TraversableWithKey1 ((,) k)

+ Data.Key: instance Data.Key.TraversableWithKey1 Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.TraversableWithKey1 Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.TraversableWithKey1 Data.Tree.Tree

+ Data.Key: instance Data.Key.TraversableWithKey1 f => Data.Key.TraversableWithKey1 (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.TraversableWithKey1 f => Data.Key.TraversableWithKey1 (Control.Monad.Free.Free f)

+ Data.Key: instance Data.Key.TraversableWithKey1 m => Data.Key.TraversableWithKey1 (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Zip ((->) a)

+ Data.Key: instance Data.Key.Zip Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.Zip Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.Zip Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.Zip Data.Sequence.Seq

+ Data.Key: instance Data.Key.Zip Data.Tree.Tree

+ Data.Key: instance Data.Key.Zip GHC.Base.Maybe

+ Data.Key: instance Data.Key.Zip []

+ Data.Key: instance Data.Key.Zip f => Data.Key.Zip (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.Zip m => Data.Key.Zip (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.Zip m => Data.Key.Zip (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Key: instance Data.Key.Zip w => Data.Key.Zip (Control.Comonad.Trans.Traced.TracedT s w)

+ Data.Key: instance Data.Key.ZipWithKey ((->) a)

+ Data.Key: instance Data.Key.ZipWithKey Data.Functor.Identity.Identity

+ Data.Key: instance Data.Key.ZipWithKey Data.IntMap.Base.IntMap

+ Data.Key: instance Data.Key.ZipWithKey Data.List.NonEmpty.NonEmpty

+ Data.Key: instance Data.Key.ZipWithKey Data.Sequence.Seq

+ Data.Key: instance Data.Key.ZipWithKey Data.Tree.Tree

+ Data.Key: instance Data.Key.ZipWithKey GHC.Base.Maybe

+ Data.Key: instance Data.Key.ZipWithKey []

+ Data.Key: instance Data.Key.ZipWithKey f => Data.Key.ZipWithKey (Control.Comonad.Cofree.Cofree f)

+ Data.Key: instance Data.Key.ZipWithKey m => Data.Key.ZipWithKey (Control.Monad.Trans.Identity.IdentityT m)

+ Data.Key: instance Data.Key.ZipWithKey m => Data.Key.ZipWithKey (Control.Monad.Trans.Reader.ReaderT e m)

+ Data.Key: instance Data.Key.ZipWithKey w => Data.Key.ZipWithKey (Control.Comonad.Trans.Traced.TracedT s w)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.Adjustable (GHC.Arr.Array i)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.FoldableWithKey (GHC.Arr.Array i)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.Indexable (GHC.Arr.Array i)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.Keyed (GHC.Arr.Array i)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.Lookup (GHC.Arr.Array i)

+ Data.Key: instance GHC.Arr.Ix i => Data.Key.TraversableWithKey (GHC.Arr.Array i)

+ Data.Key: instance GHC.Base.Applicative (Data.Key.StateL s)

+ Data.Key: instance GHC.Base.Applicative (Data.Key.StateR s)

+ Data.Key: instance GHC.Base.Functor (Data.Key.StateL s)

+ Data.Key: instance GHC.Base.Functor (Data.Key.StateR s)

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

+ Data.Key: instance GHC.Classes.Ord k => Data.Key.Adjustable (Data.Map.Base.Map k)

+ Data.Key: instance GHC.Classes.Ord k => Data.Key.Indexable (Data.Map.Base.Map k)

+ Data.Key: instance GHC.Classes.Ord k => Data.Key.Lookup (Data.Map.Base.Map k)

+ Data.Key: instance GHC.Classes.Ord k => Data.Key.Zip (Data.Map.Base.Map k)

+ Data.Key: instance GHC.Classes.Ord k => Data.Key.ZipWithKey (Data.Map.Base.Map k)

Files

CHANGELOG.markdown +8/−2
LICENSE +1/−1
README.markdown +1/−1
keys.cabal +6/−5
src/Data/Key.hs +12/−15

CHANGELOG.markdown view

@@ -1,10 +1,16 @@+3.11+--------+* Support for `comonad` 5+* Support for GHC 8+* Support for `transformers` 0.5+ 3.10.2 -------* Support for `semigroupoids` 5.+* Support for `semigroupoids` 5  3.10.1 -------* Support for `transformers` 0.4.+* Support for `transformers` 0.4  3.10 ----

LICENSE view

@@ -1,4 +1,4 @@-Copyright 2011 Edward Kmett+Copyright 2011-2016 Edward Kmett  All rights reserved.

README.markdown view

@@ -1,7 +1,7 @@ keys ==== -[![Build Status](https://secure.travis-ci.org/ekmett/keys.png?branch=master)](http://travis-ci.org/ekmett/keys)+[![Hackage](https://img.shields.io/hackage/v/keys.svg)](https://hackage.haskell.org/package/keys) [![Build Status](https://secure.travis-ci.org/ekmett/keys.png?branch=master)](http://travis-ci.org/ekmett/keys)  This package provides a bunch of ad hoc classes for accessing parts of a container.

keys.cabal view

@@ -1,6 +1,6 @@ name:          keys category:      Data Structures, Containers-version:       3.10.2+version:       3.11 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -9,7 +9,7 @@ stability:     provisional homepage:      http://github.com/ekmett/keys/ bug-reports:   http://github.com/ekmett/keys/issues-copyright:     Copyright (C) 2011 Edward A. Kmett+copyright:     Copyright (C) 2011-2016 Edward A. Kmett synopsis:      Keyed functors and containers description:   Keyed functors and containers build-type:    Simple@@ -23,14 +23,15 @@   build-depends:     array                >= 0.3.0.2 && < 0.6,     base                 >= 4       && < 5,-    comonad              >= 4       && < 5,+    comonad              >= 4       && < 6,     containers           >= 0.3     && < 0.6,     free                 >= 4       && < 5,     hashable             >= 1.1.2.3 && < 1.3,     semigroupoids        >= 4       && < 6,     semigroups           >= 0.8.3.1 && < 1,-    transformers         >= 0.2     && < 0.5,-    unordered-containers >= 0.2     && < 0.3+    transformers         >= 0.2     && < 0.6,+    transformers-compat  >= 0.3     && < 1,+    unordered-containers >= 0.2.4   && < 0.3    exposed-modules:     Data.Key

src/Data/Key.hs view

@@ -1,8 +1,5 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif module Data.Key (   -- * Keys     Key@@ -76,7 +73,7 @@ import Data.Functor.Bind import Data.Functor.Compose import Data.Functor.Product-import Data.Functor.Coproduct+import qualified Data.Functor.Sum as Functor import Data.Foldable import Data.Hashable import Data.HashMap.Lazy (HashMap)@@ -100,7 +97,7 @@ import qualified Data.List as List import Prelude hiding (lookup, zip, zipWith) --- TODO: half of the functions manipulating Cofree and Free buil the keys in the wrong order+-- TODO: half of the functions manipulating Cofree and Free build the keys in the wrong order  type family Key (f :: * -> *) type instance Key (Cofree f) = Seq (Key f)@@ -781,19 +778,19 @@   adjust f i arr  = arr Array.// [(i, f (arr Array.! i))]   replace i b arr = arr Array.// [(i, b)] -type instance Key (Coproduct f g) = (Key f, Key g)+type instance Key (Functor.Sum f g) = (Key f, Key g) -instance (Indexable f, Indexable g) => Indexable (Coproduct f g) where-  index (Coproduct (Left a)) (x,_) = index a x-  index (Coproduct (Right b)) (_,y) = index b y+instance (Indexable f, Indexable g) => Indexable (Functor.Sum f g) where+  index (Functor.InL a) (x,_) = index a x+  index (Functor.InR b) (_,y) = index b y -instance (Lookup f, Lookup g) => Lookup (Coproduct f g) where-  lookup (x, _) (Coproduct (Left a)) = lookup x a-  lookup (_, y) (Coproduct (Right b)) = lookup y b+instance (Lookup f, Lookup g) => Lookup (Functor.Sum f g) where+  lookup (x, _) (Functor.InL a) = lookup x a+  lookup (_, y) (Functor.InR b) = lookup y b -instance (Adjustable f, Adjustable g) => Adjustable (Coproduct f g) where-  adjust f (x,_) (Coproduct (Left a)) = Coproduct (Left (adjust f x a))-  adjust f (_,y) (Coproduct (Right b)) = Coproduct (Right (adjust f y b))+instance (Adjustable f, Adjustable g) => Adjustable (Functor.Sum f g) where+  adjust f (x,_) (Functor.InL a) = Functor.InL (adjust f x a)+  adjust f (_,y) (Functor.InR b) = Functor.InR (adjust f y b)  type instance Key (Product f g) = Either (Key f) (Key g)