Data.Key

Contents

• Keys
• Keyed functors
• Zippable functors
• Zipping keyed functors
• Indexable functors
• Safe Lookup
• Adjustable
• FoldableWithKey
• FoldableWithKey1
• TraversableWithKey
• TraversableWithKey1

Synopsis

• type family Key f
• class Functor f => Keyed f where
  • mapWithKey :: (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 where
  • zipWith :: (a -> b -> c) -> f a -> f b -> f c
  • zip :: f a -> f b -> f (a, b)
  • zap :: f (a -> b) -> f a -> f b
• class (Keyed f, Zip f) => ZipWithKey f where
  • zipWithKey :: (Key f -> a -> b -> c) -> f a -> f b -> f c
  • zapWithKey :: f (Key f -> a -> b) -> f a -> f b
• class Lookup f => Indexable f where
  • index :: f a -> Key f -> a
• (!) :: Indexable f => f a -> Key f -> a
• class Lookup f where
  • lookup :: Key f -> f a -> Maybe a
• lookupDefault :: Indexable f => Key f -> f a -> Maybe a
• class Functor f => Adjustable f where
  • adjust :: (a -> a) -> Key f -> f a -> f a
  • replace :: Key f -> a -> f a -> f a
• class Foldable t => FoldableWithKey t where
  • toKeyedList :: t a -> [(Key t, a)]
  • foldMapWithKey :: Monoid m => (Key t -> a -> m) -> t a -> m
  • foldrWithKey :: (Key t -> a -> b -> b) -> b -> t a -> b
  • foldlWithKey :: (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 where
  • foldMapWithKey1 :: 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 where
  • traverseWithKey :: Applicative f => (Key t -> a -> f b) -> t a -> f (t b)
  • mapWithKeyM :: 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)
• mapAccumWithKeyL :: TraversableWithKey t => (Key t -> a -> b -> (a, c)) -> a -> t b -> (a, t c)
• 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
• foldMapWithKeyDefault :: (TraversableWithKey t, Monoid m) => (Key t -> a -> m) -> t a -> m
• class (Traversable1 t, FoldableWithKey1 t, TraversableWithKey t) => TraversableWithKey1 t where
  • traverseWithKey1 :: Apply f => (Key t -> a -> f b) -> t a -> f (t b)
• foldMapWithKey1Default :: (TraversableWithKey1 t, Semigroup m) => (Key t -> a -> m) -> t a -> m

Keys

Keyed functors

Zippable functors

Zipping keyed functors

Indexable functors

Safe Lookup

Adjustable

FoldableWithKey

FoldableWithKey1

TraversableWithKey

TraversableWithKey1