| Safe Haskell | Safe |
|---|---|
| Language | Haskell98 |
Data.Key
Contents
- type family Key (f :: * -> *)
- class Functor f => Keyed f where
- (<#$>) :: 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
- class (Keyed f, Zip f) => ZipWithKey f where
- class Lookup f => Indexable f where
- (!) :: Indexable f => f a -> Key f -> a
- class Lookup f where
- lookupDefault :: Indexable f => Key f -> f a -> Maybe a
- class Functor f => Adjustable f where
- class Foldable t => FoldableWithKey t where
- 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
- 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
- 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
- foldMapWithKey1Default :: (TraversableWithKey1 t, Semigroup m) => (Key t -> a -> m) -> t a -> m
Keys
type family Key (f :: * -> *) #
Instances
| type Key [] # | |
| type Key Maybe # | |
| type Key Identity # | |
| type Key NonEmpty # | |
| type Key Tree # | |
| type Key Seq # | |
| type Key IntMap # | |
| type Key ((->) a) # | |
| type Key ((,) k) # | |
| type Key (Array i) # | |
| type Key (Map k) # | |
| type Key (Cofree f) # | |
| type Key (Free f) # | |
| type Key (HashMap k) # | |
| type Key (TracedT s w) # | |
| type Key (IdentityT * m) # | |
| type Key (Sum * f g) # | |
| type Key (Product * f g) # | |
| type Key (ReaderT * e m) # | |
| type Key (Compose * * f g) # | |
Keyed functors
class Functor f => Keyed f where #
Minimal complete definition
Methods
mapWithKey :: (Key f -> a -> b) -> f a -> f b #
Instances
| Keyed [] # | |
| Keyed Maybe # | |
| Keyed Identity # | |
| Keyed NonEmpty # | |
| Keyed Tree # | |
| Keyed Seq # | |
| Keyed IntMap # | |
| Keyed ((->) a) # | |
| Keyed ((,) k) # | |
| Ix i => Keyed (Array i) # | |
| Keyed (Map k) # | |
| Keyed f => Keyed (Cofree f) # | |
| Keyed f => Keyed (Free f) # | |
| Keyed (HashMap k) # | |
| Keyed w => Keyed (TracedT s w) # | |
| Keyed m => Keyed (IdentityT * m) # | |
| (Keyed f, Keyed g) => Keyed (Product * f g) # | |
| Keyed m => Keyed (ReaderT * e m) # | |
| (Keyed f, Keyed g) => Keyed (Compose * * f g) # | |
Zippable functors
class Functor f => Zip f where #
Instances
| Zip [] # | |
| Zip Maybe # | |
| Zip Identity # | |
| Zip NonEmpty # | |
| Zip Tree # | |
| Zip Seq # | |
| Zip IntMap # | |
| Zip ((->) a) # | |
| Ord k => Zip (Map k) # | |
| Zip f => Zip (Cofree f) # | |
| (Eq k, Hashable k) => Zip (HashMap k) # | |
| Zip w => Zip (TracedT s w) # | |
| Zip m => Zip (IdentityT * m) # | |
| (Zip f, Zip g) => Zip (Product * f g) # | |
| Zip m => Zip (ReaderT * e m) # | |
| (Zip f, Zip g) => Zip (Compose * * f g) # | |
Zipping keyed functors
class (Keyed f, Zip f) => ZipWithKey f where #
Methods
zipWithKey :: (Key f -> a -> b -> c) -> f a -> f b -> f c #
zapWithKey :: f (Key f -> a -> b) -> f a -> f b #
Instances
| ZipWithKey [] # | |
| ZipWithKey Maybe # | |
| ZipWithKey Identity # | |
| ZipWithKey NonEmpty # | |
| ZipWithKey Tree # | |
| ZipWithKey Seq # | |
| ZipWithKey IntMap # | |
| ZipWithKey ((->) a) # | |
| Ord k => ZipWithKey (Map k) # | |
| ZipWithKey f => ZipWithKey (Cofree f) # | |
| (Eq k, Hashable k) => ZipWithKey (HashMap k) # | |
| ZipWithKey w => ZipWithKey (TracedT s w) # | |
| ZipWithKey m => ZipWithKey (IdentityT * m) # | |
| (ZipWithKey f, ZipWithKey g) => ZipWithKey (Product * f g) # | |
| ZipWithKey m => ZipWithKey (ReaderT * e m) # | |
| (ZipWithKey f, ZipWithKey g) => ZipWithKey (Compose * * f g) # | |
Indexable functors
class Lookup f => Indexable f where #
Minimal complete definition
Instances
| Indexable [] # | |
| Indexable Maybe # | |
| Indexable Identity # | |
| Indexable NonEmpty # | |
| Indexable Tree # | |
| Indexable Seq # | |
| Indexable IntMap # | |
| Indexable ((->) a) # | |
| Ix i => Indexable (Array i) # | |
| Ord k => Indexable (Map k) # | |
| Indexable f => Indexable (Cofree f) # | |
| (Eq k, Hashable k) => Indexable (HashMap k) # | |
| Indexable w => Indexable (TracedT s w) # | |
| Indexable m => Indexable (IdentityT * m) # | |
| (Indexable f, Indexable g) => Indexable (Sum * f g) # | |
| (Indexable f, Indexable g) => Indexable (Product * f g) # | |
| Indexable m => Indexable (ReaderT * e m) # | |
| (Indexable f, Indexable g) => Indexable (Compose * * f g) # | |
Safe Lookup
Minimal complete definition
Instances
| Lookup [] # | |
| Lookup Maybe # | |
| Lookup Identity # | |
| Lookup NonEmpty # | |
| Lookup Tree # | |
| Lookup Seq # | |
| Lookup IntMap # | |
| Lookup ((->) a) # | |
| Ix i => Lookup (Array i) # | |
| Ord k => Lookup (Map k) # | |
| Lookup f => Lookup (Cofree f) # | |
| Lookup f => Lookup (Free f) # | |
| (Eq k, Hashable k) => Lookup (HashMap k) # | |
| Lookup w => Lookup (TracedT s w) # | |
| Lookup m => Lookup (IdentityT * m) # | |
| (Lookup f, Lookup g) => Lookup (Sum * f g) # | |
| (Lookup f, Lookup g) => Lookup (Product * f g) # | |
| Lookup m => Lookup (ReaderT * e m) # | |
| (Lookup f, Lookup g) => Lookup (Compose * * f g) # | |
lookupDefault :: Indexable f => Key f -> f a -> Maybe a #
Adjustable
class Functor f => Adjustable f where #
Minimal complete definition
Instances
| Adjustable [] # | |
| Adjustable Identity # | |
| Adjustable NonEmpty # | |
| Adjustable Tree # | |
| Adjustable Seq # | |
| Adjustable IntMap # | |
| Ix i => Adjustable (Array i) # | |
| Ord k => Adjustable (Map k) # | |
| Adjustable f => Adjustable (Cofree f) # | |
| Adjustable f => Adjustable (Free f) # | |
| (Adjustable f, Adjustable g) => Adjustable (Sum * f g) # | |
| (Adjustable f, Adjustable g) => Adjustable (Product * f g) # | |
FoldableWithKey
class Foldable t => FoldableWithKey t where #
Methods
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 #
Instances
| FoldableWithKey [] # | |
| FoldableWithKey Maybe # | |
| FoldableWithKey Identity # | |
| FoldableWithKey NonEmpty # | |
| FoldableWithKey Tree # | |
| FoldableWithKey Seq # | |
| FoldableWithKey IntMap # | |
| FoldableWithKey ((,) k) # | |
| Ix i => FoldableWithKey (Array i) # | |
| FoldableWithKey (Map k) # | |
| FoldableWithKey f => FoldableWithKey (Cofree f) # | |
| FoldableWithKey f => FoldableWithKey (Free f) # | |
| FoldableWithKey (HashMap k) # | |
| FoldableWithKey m => FoldableWithKey (IdentityT * m) # | |
| (FoldableWithKey f, FoldableWithKey g) => FoldableWithKey (Product * f g) # | |
| (FoldableWithKey f, FoldableWithKey m) => FoldableWithKey (Compose * * f 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 #
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 #
FoldableWithKey1
class (Foldable1 t, FoldableWithKey t) => FoldableWithKey1 t where #
Minimal complete definition
Methods
foldMapWithKey1 :: Semigroup m => (Key t -> a -> m) -> t a -> m #
Instances
| FoldableWithKey1 Identity # | |
| FoldableWithKey1 NonEmpty # | |
| FoldableWithKey1 Tree # | |
| FoldableWithKey1 ((,) k) # | |
| FoldableWithKey1 f => FoldableWithKey1 (Cofree f) # | |
| FoldableWithKey1 f => FoldableWithKey1 (Free f) # | |
| FoldableWithKey1 m => FoldableWithKey1 (IdentityT * m) # | |
| (FoldableWithKey1 f, FoldableWithKey1 g) => FoldableWithKey1 (Product * f g) # | |
| (FoldableWithKey1 f, FoldableWithKey1 m) => FoldableWithKey1 (Compose * * f 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 #
TraversableWithKey
class (Keyed t, FoldableWithKey t, Traversable t) => TraversableWithKey t where #
Minimal complete definition
Methods
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) #
Instances
| TraversableWithKey [] # | |
| TraversableWithKey Maybe # | |
| TraversableWithKey Identity # | |
| TraversableWithKey NonEmpty # | |
| TraversableWithKey Tree # | |
| TraversableWithKey Seq # | |
| TraversableWithKey IntMap # | |
| TraversableWithKey ((,) k) # | |
| Ix i => TraversableWithKey (Array i) # | |
| TraversableWithKey (Map k) # | |
| TraversableWithKey f => TraversableWithKey (Cofree f) # | |
| TraversableWithKey f => TraversableWithKey (Free f) # | |
| TraversableWithKey (HashMap k) # | |
| TraversableWithKey m => TraversableWithKey (IdentityT * m) # | |
| (TraversableWithKey f, TraversableWithKey g) => TraversableWithKey (Product * f g) # | |
| (TraversableWithKey f, TraversableWithKey m) => TraversableWithKey (Compose * * f m) # | |
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) #
The mapAccumWithKeyL function behaves like a combination of mapWithKey
and foldlWithKey; 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.
mapAccumWithKeyR :: TraversableWithKey t => (Key t -> a -> b -> (a, c)) -> a -> t b -> (a, t c) #
The mapAccumWithKeyR function behaves like a combination of mapWithKey
and foldrWithKey; 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.
mapWithKeyDefault :: TraversableWithKey t => (Key t -> a -> b) -> t a -> t b #
foldMapWithKeyDefault :: (TraversableWithKey t, Monoid m) => (Key t -> a -> m) -> t a -> m #
This function may be used as a value for foldMapWithKey
in a FoldableWithKey instance.
TraversableWithKey1
class (Traversable1 t, FoldableWithKey1 t, TraversableWithKey t) => TraversableWithKey1 t where #
Minimal complete definition
Methods
traverseWithKey1 :: Apply f => (Key t -> a -> f b) -> t a -> f (t b) #
Instances
| TraversableWithKey1 Identity # | |
| TraversableWithKey1 NonEmpty # | |
| TraversableWithKey1 Tree # | |
| TraversableWithKey1 ((,) k) # | |
| TraversableWithKey1 f => TraversableWithKey1 (Cofree f) # | |
| TraversableWithKey1 f => TraversableWithKey1 (Free f) # | |
| TraversableWithKey1 m => TraversableWithKey1 (IdentityT * m) # | |
| (TraversableWithKey1 f, TraversableWithKey1 g) => TraversableWithKey1 (Product * f g) # | |
| (TraversableWithKey1 f, TraversableWithKey1 m) => TraversableWithKey1 (Compose * * f m) # | |
foldMapWithKey1Default :: (TraversableWithKey1 t, Semigroup m) => (Key t -> a -> m) -> t a -> m #