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 #