Data.ListTrie.Base.Map

Documentation

class Foldable (m k) => Map m k where

Minimal complete implementation:

• eqCmp
• null
• lookup
• alter
• unionWithKey, differenceWithKey, intersectionWithKey
• toListKV
• empty or fromList or fromListWith
• isSubmapOfBy

For decent performance, supplying at least mapAccumWithKey and filter as well is probably a good idea.

Minimal complete definition

eqCmp, null, lookup, alter, unionWithKey, differenceWithKey, intersectionWithKey, toListKV, isSubmapOfBy

Methods

eqCmp :: m k a -> k -> k -> Bool

Like an Eq instance over k, but should compare on the same type as m does. In most cases this can be defined just as const (==).

empty :: m k a

singleton :: k -> a -> m k a

doubleton :: k -> a -> k -> a -> m k a

Precondition: the two keys differ

null :: m k a -> Bool

lookup :: k -> m k a -> Maybe a

insertWith :: (a -> a -> a) -> k -> a -> m k a -> m k a

Strictness can be whatever is more optimal for the map type, shouldn't matter

insert :: k -> a -> m k a -> m k a

update :: (a -> Maybe a) -> k -> m k a -> m k a

adjust :: (a -> a) -> k -> m k a -> m k a

delete :: k -> m k a -> m k a

alter :: (Maybe a -> Maybe a) -> k -> m k a -> m k a

unionWith :: (a -> a -> a) -> m k a -> m k a -> m k a

differenceWith :: (a -> b -> Maybe a) -> m k a -> m k b -> m k a

intersectionWith :: (a -> b -> c) -> m k a -> m k b -> m k c

unionWithKey :: (k -> a -> a -> a) -> m k a -> m k a -> m k a

differenceWithKey :: (k -> a -> b -> Maybe a) -> m k a -> m k b -> m k a

intersectionWithKey :: (k -> a -> b -> c) -> m k a -> m k b -> m k c

map :: (a -> b) -> m k a -> m k b

mapWithKey :: (k -> a -> b) -> m k a -> m k b

mapAccum :: (a -> b -> (a, c)) -> a -> m k b -> (a, m k c)

mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> m k b -> (a, m k c)

filter :: (a -> Bool) -> m k a -> m k a

toListKV :: m k a -> [(k, a)]

fromListKV :: [(k, a)] -> m k a

fromListKVWith :: (a -> a -> a) -> [(k, a)] -> m k a

serializeToList :: m k a -> [(k, a)]

deserializeFromList :: [(k, a)] -> m k a

isSubmapOfBy :: (a -> b -> Bool) -> m k a -> m k b -> Bool

singletonView :: m k a -> Maybe (k, a)

Instances

Ord k => Map Map k

Enum k => Map WrappedIntMap k

Eq k => Map AList k

class Map m k => OrdMap m k where

Minimal complete definition:

• ordCmp
• toAscList or toDescList
• splitLookup

For decent performance, supplying at least the following is probably a good idea:

• minViewWithKey, maxViewWithKey
• mapAccumAscWithKey, mapAccumDescWithKey

Minimal complete definition

ordCmp, splitLookup

Methods

ordCmp :: m k a -> k -> k -> Ordering

Like an Ord instance over k, but should compare on the same type as m does. In most cases this can be defined just as const compare.

toAscList :: m k a -> [(k, a)]

toDescList :: m k a -> [(k, a)]

splitLookup :: k -> m k a -> (m k a, Maybe a, m k a)

split :: k -> m k a -> (m k a, m k a)

minViewWithKey :: m k a -> (Maybe (k, a), m k a)

maxViewWithKey :: m k a -> (Maybe (k, a), m k a)

findPredecessor :: k -> m k a -> Maybe (k, a)

findSuccessor :: k -> m k a -> Maybe (k, a)

mapAccumAsc :: (a -> b -> (a, c)) -> a -> m k b -> (a, m k c)

mapAccumAscWithKey :: (a -> k -> b -> (a, c)) -> a -> m k b -> (a, m k c)

mapAccumDesc :: (a -> b -> (a, c)) -> a -> m k b -> (a, m k c)

mapAccumDescWithKey :: (a -> k -> b -> (a, c)) -> a -> m k b -> (a, m k c)

Instances

Ord k => OrdMap Map k

Enum k => OrdMap WrappedIntMap k

Ord k => OrdMap AList k

data AList k v

Instances

Ord k => OrdMap AList k

Eq k => Map AList k

Functor (AList k)

Foldable (AList k)

Traversable (AList k)

(Eq k, Eq v) => Eq (AList k v)

(Ord k, Ord v) => Ord (AList k v)

data WrappedIntMap k v

Instances

Enum k => OrdMap WrappedIntMap k

Enum k => Map WrappedIntMap k

Functor (WrappedIntMap k)

Foldable (WrappedIntMap k)

Traversable (WrappedIntMap k)

Eq v => Eq (WrappedIntMap k v)

Ord v => Ord (WrappedIntMap k v)