-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Keyed functors and containers
--   
--   Keyed functors and containers
@package keys
@version 2.0

module Data.Key
class Functor f => Keyed f
mapWithKey :: Keyed f => (Key f -> a -> b) -> f a -> f b
(<#$>) :: Keyed f => (Key f -> a -> b) -> f a -> f b
keyed :: Keyed f => f a -> f (Key f, a)
class Functor f => Zip f
zipWith :: Zip f => (a -> b -> c) -> f a -> f b -> f c
zip :: Zip f => f a -> f b -> f (a, b)
zap :: Zip f => f (a -> b) -> f a -> f b
class (Keyed f, Zip f) => ZipWithKey f
zipWithKey :: ZipWithKey f => (Key f -> a -> b -> c) -> f a -> f b -> f c
zapWithKey :: ZipWithKey f => f (Key f -> a -> b) -> f a -> f b
class Lookup f => Indexable f
index :: Indexable f => f a -> Key f -> a
(!) :: Indexable f => f a -> Key f -> a
class Lookup f
lookup :: Lookup f => Key f -> f a -> Maybe a
lookupDefault :: Indexable f => Key f -> f a -> Maybe a
class Functor f => Adjustable f
adjust :: Adjustable f => (a -> a) -> Key f -> f a -> f a
replace :: Adjustable f => Key f -> a -> f a -> f a
class Foldable t => FoldableWithKey t
toKeyedList :: FoldableWithKey t => t a -> [(Key t, a)]
foldMapWithKey :: (FoldableWithKey t, Monoid m) => (Key t -> a -> m) -> t a -> m
foldrWithKey :: FoldableWithKey t => (Key t -> a -> b -> b) -> b -> t a -> b
foldlWithKey :: FoldableWithKey t => (b -> Key t -> a -> b) -> b -> t a -> b
foldrWithKey' :: FoldableWithKey t => (Key t -> a -> b -> b) -> b -> t a -> b
foldlWithKey' :: FoldableWithKey t => (b -> Key t -> a -> b) -> b -> t a -> b
foldrWithKeyM :: (FoldableWithKey t, Monad m) => (Key t -> a -> b -> m b) -> b -> t a -> m b
foldlWithKeyM :: (FoldableWithKey t, Monad m) => (b -> Key t -> a -> m b) -> b -> t a -> m b
traverseWithKey_ :: (FoldableWithKey t, Applicative f) => (Key t -> a -> f b) -> t a -> f ()
forWithKey_ :: (FoldableWithKey t, Applicative f) => t a -> (Key t -> a -> f b) -> f ()
mapWithKeyM_ :: (FoldableWithKey t, Monad m) => (Key t -> a -> m b) -> t a -> m ()
forWithKeyM_ :: (FoldableWithKey t, Monad m) => t a -> (Key t -> a -> m b) -> m ()
concatMapWithKey :: FoldableWithKey t => (Key t -> a -> [b]) -> t a -> [b]
anyWithKey :: FoldableWithKey t => (Key t -> a -> Bool) -> t a -> Bool
allWithKey :: FoldableWithKey t => (Key t -> a -> Bool) -> t a -> Bool
findWithKey :: FoldableWithKey t => (Key t -> a -> Bool) -> t a -> Maybe a
class (Foldable1 t, FoldableWithKey t) => FoldableWithKey1 t
foldMapWithKey1 :: (FoldableWithKey1 t, Semigroup m) => (Key t -> a -> m) -> t a -> m
traverseWithKey1_ :: (FoldableWithKey1 t, Apply f) => (Key t -> a -> f b) -> t a -> f ()
forWithKey1_ :: (FoldableWithKey1 t, Apply f) => t a -> (Key t -> a -> f b) -> f ()
foldMapWithKeyDefault1 :: (FoldableWithKey1 t, Monoid m) => (Key t -> a -> m) -> t a -> m
class (Keyed t, FoldableWithKey t, Traversable t) => TraversableWithKey t
traverseWithKey :: (TraversableWithKey t, Applicative f) => (Key t -> a -> f b) -> t a -> f (t b)
mapWithKeyM :: (TraversableWithKey t, Monad m) => (Key t -> a -> m b) -> t a -> m (t b)
forWithKey :: (TraversableWithKey t, Applicative f) => t a -> (Key t -> a -> f b) -> f (t b)
forWithKeyM :: (TraversableWithKey t, Monad m) => t a -> (Key t -> a -> m b) -> m (t b)

-- | The <a>mapAccumWithKeyL</a> function behaves like a combination of
--   <a>mapWithKey</a> and <a>foldlWithKey</a>; it applies a function to
--   each element of a structure, passing an accumulating parameter from
--   left to right, and returning a final value of this accumulator
--   together with the new structure.
mapAccumWithKeyL :: TraversableWithKey t => (Key t -> a -> b -> (a, c)) -> a -> t b -> (a, t c)

-- | The <a>mapAccumWithKeyR</a> function behaves like a combination of
--   <a>mapWithKey</a> and <a>foldrWithKey</a>; it applies a function to
--   each element of a structure, passing an accumulating parameter from
--   right to left, and returning a final value of this accumulator
--   together with the new structure.
mapAccumWithKeyR :: TraversableWithKey t => (Key t -> a -> b -> (a, c)) -> a -> t b -> (a, t c)
mapWithKeyDefault :: TraversableWithKey t => (Key t -> a -> b) -> t a -> t b

-- | This function may be used as a value for
--   <tt>Data.Foldable.foldMapWithKey</tt> in a <a>FoldableWithKey</a>
--   instance.
foldMapWithKeyDefault :: (TraversableWithKey t, Monoid m) => (Key t -> a -> m) -> t a -> m
class (Traversable1 t, FoldableWithKey1 t, TraversableWithKey t) => TraversableWithKey1 t
traverseWithKey1 :: (TraversableWithKey1 t, Apply f) => (Key t -> a -> f b) -> t a -> f (t b)
foldMapWithKey1Default :: (TraversableWithKey1 t, Semigroup m) => (Key t -> a -> m) -> t a -> m
instance (Adjustable f, Adjustable g) => Adjustable (Product f g)
instance (TraversableWithKey1 f, TraversableWithKey1 g) => TraversableWithKey1 (Product f g)
instance (TraversableWithKey f, TraversableWithKey g) => TraversableWithKey (Product f g)
instance (FoldableWithKey1 f, FoldableWithKey1 g) => FoldableWithKey1 (Product f g)
instance (FoldableWithKey f, FoldableWithKey g) => FoldableWithKey (Product f g)
instance (ZipWithKey f, ZipWithKey g) => ZipWithKey (Product f g)
instance (Zip f, Zip g) => Zip (Product f g)
instance (Lookup f, Lookup g) => Lookup (Product f g)
instance (Indexable f, Indexable g) => Indexable (Product f g)
instance (Keyed f, Keyed g) => Keyed (Product f g)
instance (Adjustable f, Adjustable g) => Adjustable (Coproduct f g)
instance (Lookup f, Lookup g) => Lookup (Coproduct f g)
instance (Indexable f, Indexable g) => Indexable (Coproduct f g)
instance Ix i => Adjustable (Array i)
instance Ix i => TraversableWithKey (Array i)
instance Ix i => FoldableWithKey (Array i)
instance Ix i => Lookup (Array i)
instance Ix i => Indexable (Array i)
instance Ix i => Keyed (Array i)
instance Ord k => Adjustable (Map k)
instance TraversableWithKey (Map k)
instance FoldableWithKey (Map k)
instance Ord k => Lookup (Map k)
instance Ord k => Indexable (Map k)
instance Keyed (Map k)
instance Ord k => ZipWithKey (Map k)
instance Ord k => Zip (Map k)
instance TraversableWithKey Seq
instance FoldableWithKey Seq
instance Keyed Seq
instance Adjustable Seq
instance ZipWithKey Seq
instance Zip Seq
instance Lookup Seq
instance Indexable Seq
instance Adjustable []
instance Lookup []
instance Indexable []
instance TraversableWithKey []
instance FoldableWithKey []
instance Keyed []
instance ZipWithKey []
instance Zip []
instance (TraversableWithKey1 f, TraversableWithKey1 m) => TraversableWithKey1 (Compose f m)
instance (TraversableWithKey f, TraversableWithKey m) => TraversableWithKey (Compose f m)
instance (FoldableWithKey1 f, FoldableWithKey1 m) => FoldableWithKey1 (Compose f m)
instance (FoldableWithKey f, FoldableWithKey m) => FoldableWithKey (Compose f m)
instance (Lookup f, Lookup g) => Lookup (Compose f g)
instance (Indexable f, Indexable g) => Indexable (Compose f g)
instance (Keyed f, Keyed g) => Keyed (Compose f g)
instance (ZipWithKey f, ZipWithKey g) => ZipWithKey (Compose f g)
instance (Zip f, Zip g) => Zip (Compose f g)
instance Adjustable IntMap
instance Lookup IntMap
instance Indexable IntMap
instance TraversableWithKey IntMap
instance FoldableWithKey IntMap
instance Keyed IntMap
instance ZipWithKey IntMap
instance Zip IntMap
instance Lookup w => Lookup (TracedT s w)
instance Indexable w => Indexable (TracedT s w)
instance Keyed w => Keyed (TracedT s w)
instance ZipWithKey w => ZipWithKey (TracedT s w)
instance Zip w => Zip (TracedT s w)
instance Lookup m => Lookup (ReaderT e m)
instance Indexable m => Indexable (ReaderT e m)
instance Keyed m => Keyed (ReaderT e m)
instance ZipWithKey m => ZipWithKey (ReaderT e m)
instance Zip m => Zip (ReaderT e m)
instance Lookup ((->) a)
instance Indexable ((->) a)
instance ZipWithKey ((->) a)
instance Zip ((->) a)
instance Keyed ((->) a)
instance TraversableWithKey1 m => TraversableWithKey1 (IdentityT m)
instance TraversableWithKey m => TraversableWithKey (IdentityT m)
instance FoldableWithKey1 m => FoldableWithKey1 (IdentityT m)
instance FoldableWithKey m => FoldableWithKey (IdentityT m)
instance Keyed m => Keyed (IdentityT m)
instance ZipWithKey m => ZipWithKey (IdentityT m)
instance Zip m => Zip (IdentityT m)
instance Lookup m => Lookup (IdentityT m)
instance Indexable m => Indexable (IdentityT m)
instance TraversableWithKey1 Identity
instance TraversableWithKey Identity
instance FoldableWithKey1 Identity
instance FoldableWithKey Identity
instance Keyed Identity
instance ZipWithKey Identity
instance Zip Identity
instance Adjustable Identity
instance Lookup Identity
instance Indexable Identity
instance TraversableWithKey1 f => TraversableWithKey1 (Free f)
instance TraversableWithKey1 f => TraversableWithKey1 (Cofree f)
instance Applicative (StateR s)
instance Functor (StateR s)
instance Applicative (StateL s)
instance Functor (StateL s)
instance TraversableWithKey f => TraversableWithKey (Free f)
instance TraversableWithKey f => TraversableWithKey (Cofree f)
instance Functor f => Functor (Act f)
instance Apply f => Semigroup (Act f a)
instance FoldableWithKey1 f => FoldableWithKey1 (Free f)
instance FoldableWithKey1 f => FoldableWithKey1 (Cofree f)
instance FoldableWithKey f => FoldableWithKey (Cofree f)
instance FoldableWithKey f => FoldableWithKey (Free f)
instance Adjustable f => Adjustable (Cofree f)
instance Adjustable f => Adjustable (Free f)
instance Lookup f => Lookup (Free f)
instance Lookup f => Lookup (Cofree f)
instance Indexable f => Indexable (Cofree f)
instance ZipWithKey f => ZipWithKey (Cofree f)
instance Zip f => Zip (Cofree f)
instance Keyed f => Keyed (Cofree f)
instance Keyed f => Keyed (Free f)