Portability	Uses GHC extensions
Maintainer	Stability : experimental
Safe Haskell	None

Data.EnumMapMap.Strict

Contents

Key types
Map Type
Query
Construction
Insertion
Delete/Update
Combine
Traversal
- Map
Folds
Lists
Split/Join Keys

Description

Synopsis

emptySubTrees :: IsEmm k => EnumMapMap k v -> Bool
data k :& t = !k :& !t
data K k = K !k
d1 :: Z
d2 :: N Z
d3 :: N (N Z)
d4 :: N (N (N Z))
d5 :: N (N (N (N Z)))
d6 :: N (N (N (N (N Z))))
d7 :: N (N (N (N (N (N Z)))))
d8 :: N (N (N (N (N (N (N Z))))))
d9 :: N (N (N (N (N (N (N (N Z)))))))
d10 :: N (N (N (N (N (N (N (N (N Z))))))))
size :: IsEmm k => EnumMapMap k v -> Int
null :: IsEmm k => EnumMapMap k v -> Bool
member :: IsEmm k => k -> EnumMapMap k v -> Bool
lookup :: IsEmm k => k -> EnumMapMap k v -> Maybe v
empty :: IsEmm k => EnumMapMap k v
singleton :: IsEmm k => k -> v -> EnumMapMap k v
insert :: IsEmm k => k -> v -> EnumMapMap k v -> EnumMapMap k v
insertWith :: IsEmm k => (v -> v -> v) -> k -> v -> EnumMapMap k v -> EnumMapMap k v
insertWithKey :: IsEmm k => (k -> v -> v -> v) -> k -> v -> EnumMapMap k v -> EnumMapMap k v
delete :: IsEmm k => k -> EnumMapMap k v -> EnumMapMap k v
alter :: IsEmm k => (Maybe v -> Maybe v) -> k -> EnumMapMap k v -> EnumMapMap k v
union :: IsEmm k => EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
unionWith :: IsEmm k => (v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
unionWithKey :: IsEmm k => (k -> v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
unions :: IsEmm k => [EnumMapMap k v] -> EnumMapMap k v
difference :: IsEmm k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
differenceWith :: IsEmm k => (v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
differenceWithKey :: IsEmm k => (k -> v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
intersection :: IsEmm k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
intersectionWith :: IsEmm k => (v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3
intersectionWithKey :: IsEmm k => (k -> v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3
map :: IsEmm k => (v -> t) -> EnumMapMap k v -> EnumMapMap k t
mapWithKey :: IsEmm k => (k -> v -> t) -> EnumMapMap k v -> EnumMapMap k t
foldr :: IsEmm k => (v -> t -> t) -> t -> EnumMapMap k v -> t
foldrWithKey :: IsEmm k => (k -> v -> t -> t) -> t -> EnumMapMap k v -> t
toList :: IsEmm k => EnumMapMap k v -> [(k, v)]
fromList :: IsEmm k => [(k, v)] -> EnumMapMap k v
splitKey :: IsSplit k z => z -> EnumMapMap k v -> EnumMapMap (Head k z) (EnumMapMap (Tail k z) v)
joinKey :: (IsEmm k, IsEmm (Plus k k2)) => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v
unsafeJoinKey :: IsEmm k => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v

Documentation

emptySubTrees :: IsEmm k => EnumMapMap k v -> Bool Source

No subtrees should be empty. Returns True if one is.

Key types

data k :& t Source

Multiple keys are joined by the (:&) constructor and terminated with K.

 multiKey :: Int :& Int :& K Int
 multiKey = 5 :& 6 :& K 5

Constructors

!k :& !t

Instances

(Eq k, Eq t) => Eq (:& k t)
(Show v, Show (EnumMapMap t v)) => Show (EnumMapMap (:& k t) v)
(Show k, Show t) => Show (:& k t)
(NFData v, NFData (EnumMapMap t v)) => NFData (EnumMapMap (:& k t) v)
(Enum k, IsEmm t) => IsEmm (:& k t)
IsSplit (:& k t) Z
IsSplit (:& k t) Z
(IsSplit t n, Enum k) => IsSplit (:& k t) (N n)

data K k Source

Keys are terminated with the K type

 singleKey :: K Int
 singleKey = K 5

Constructors

K !k

Instances

Eq k => Eq (K k)
Show k => Show (K k)
Enum k => IsEmm (K k)
Enum k => IsEmm (K k)
Enum k => IsEmm (K k)
Show v => Show (EnumMapMap (K k) v)
Show v => Show (EnumMapMap (K k) v)
NFData v => NFData (EnumMapMap (K k) v)
NFData v => NFData (EnumMapMap (K k) v)

d1 :: ZSource

Split after 1 key.

 emm :: EnumMapMap (T1 :& T2 :& K T3) v
 splitKey d1 emm :: EnumMapMap (T1 :& K T2) (EnumMapMap (K T3) v)

d2 :: N ZSource

Split after 2 keys.

 emm :: EnumMapMap (T1 :& T2 :& K T3) v
 splitKey d1 emm :: EnumMapMap (K T1) (EnumMapMap (T2 :& K T3) v)

d3 :: N (N Z)Source

d4 :: N (N (N Z))Source

d5 :: N (N (N (N Z)))Source

d6 :: N (N (N (N (N Z))))Source

d7 :: N (N (N (N (N (N Z)))))Source

d8 :: N (N (N (N (N (N (N Z))))))Source

d9 :: N (N (N (N (N (N (N (N Z)))))))Source

d10 :: N (N (N (N (N (N (N (N (N Z))))))))Source

Map Type

Query

size :: IsEmm k => EnumMapMap k v -> Int Source

Number of elements in the EnumMapMap.

null :: IsEmm k => EnumMapMap k v -> Bool Source

Is the EnumMapMap empty?

Submaps can never be empty, so the following should always hold true:

 emm :: EnumMapMap (Int :& Int :& K ID) Bool)
 null $ splitKey x emm == False

member :: IsEmm k => k -> EnumMapMap k v -> Bool Source

Is the key present in the EnumMapMap?

lookup :: IsEmm k => k -> EnumMapMap k v -> Maybe vSource

Lookup up the value at a key in the EnumMapMap.

 emm = fromList [(3 :& K 1, "a")]
 lookup (3 :& K 1) emm == Just "a"
 lookup (2 :& K 1) emm == Nothing

Construction

empty :: IsEmm k => EnumMapMap k vSource

The empty EnumMapMap.

singleton :: IsEmm k => k -> v -> EnumMapMap k vSource

An EnumMapMap with one element

 singleton (5 :& K 3) "a" == fromList [(5 :& K 3, "a")]

Insertion

insert :: IsEmm k => k -> v -> EnumMapMap k v -> EnumMapMap k vSource

Insert a new key/value pair into the EnumMapMap.

insertWith :: IsEmm k => (v -> v -> v) -> k -> v -> EnumMapMap k v -> EnumMapMap k vSource

Insert with a combining function.

insertWithKey :: IsEmm k => (k -> v -> v -> v) -> k -> v -> EnumMapMap k v -> EnumMapMap k vSource

Insert with a combining function.

Delete/Update

delete :: IsEmm k => k -> EnumMapMap k v -> EnumMapMap k vSource

Remove a key and it's value from the EnumMapMap. If the key is not present the original EnumMapMap is returned.

alter :: IsEmm k => (Maybe v -> Maybe v) -> k -> EnumMapMap k v -> EnumMapMap k vSource

The expression (alter f k emm) alters the value at k, or absence thereof. alter can be used to insert, delete, or update a value in an EnumMapMap.

Combine

Union

union :: IsEmm k => EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource

The (left-biased) union of two EnumMapMaps. It prefers the first EnumMapMap when duplicate keys are encountered.

unionWith :: IsEmm k => (v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource

The union with a combining function.

unionWithKey :: IsEmm k => (k -> v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource

The union with a combining function.

unions :: IsEmm k => [EnumMapMap k v] -> EnumMapMap k vSource

The union of a list of maps.

Difference

difference :: IsEmm k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source

Difference between two EnumMapMaps (based on keys).

differenceWith :: IsEmm k => (v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source

Difference with a combining function.

differenceWithKey :: IsEmm k => (k -> v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source

Difference with a combining function.

Intersection

intersection :: IsEmm k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source

The (left-biased) intersection of two EnumMapMap (based on keys).

intersectionWith :: IsEmm k => (v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3Source

The intersection with a combining function.

intersectionWithKey :: IsEmm k => (k -> v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3Source

The intersection with a combining function.

Traversal

Map

map :: IsEmm k => (v -> t) -> EnumMapMap k v -> EnumMapMap k tSource

Map a function over all values in the EnumMapMap.

mapWithKey :: IsEmm k => (k -> v -> t) -> EnumMapMap k v -> EnumMapMap k tSource

Map a function over all key/value pairs in the EnumMapMap.

Folds

foldr :: IsEmm k => (v -> t -> t) -> t -> EnumMapMap k v -> tSource

Fold the values in the EnumMapMap using the given right-associative binary operator

foldrWithKey :: IsEmm k => (k -> v -> t -> t) -> t -> EnumMapMap k v -> tSource

Fold the keys and values in the EnumMapMap using the given right-associative binary operator.

Lists

toList :: IsEmm k => EnumMapMap k v -> [(k, v)]Source

Convert the EnumMapMap to a list of key/value pairs.

fromList :: IsEmm k => [(k, v)] -> EnumMapMap k vSource

Create a EnumMapMap from a list of key/value pairs.

Split/Join Keys

splitKey :: IsSplit k z => z -> EnumMapMap k v -> EnumMapMap (Head k z) (EnumMapMap (Tail k z) v)Source

Split a key so that an EnumMapMap becomes an EnumMapMap of EnumMapMaps.

 newtype ID = ID Int deriving Enum
 emm = empty :: EnumMapMap (Int :& K ID) Bool
 res :: EnumMapMap (K ID) Bool
 res = lookup (K 5) $ splitKey d1 emm

If the level is too high then the compilation will fail with an error

 emm = empty :: EnumMapMap (Int :& Int :& K Int) Bool -- 3 levels
 res1 = splitKey d4 emm -- ERROR! Instance not found...
 res2 = splitKey d3 emm -- ERROR! Instance not found...
 res3 = splitKey d2 emm -- Good

joinKey :: (IsEmm k, IsEmm (Plus k k2)) => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) vSource

Join a key so that an EnumMapMap of EnumMapMaps becomes an EnumMapMap.

 newtype ID = ID Int deriving Enum
 emm :: EnumMapMap (K Int) (EnumMapMap (K ID) Bool)
 res :: EnumMapMap (Int :& K ID) Bool
 res = joinKey emm

joinKey is the opposite of splitKey.

 emm = empty :: EnumMapMap (Int :& Int :& K ID) Bool)
 emm == joinKey $ splitKey d2 emm

unsafeJoinKey :: IsEmm k => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) vSource

Join a key so that an EnumMapMap of EnumMapMaps becomes an EnumMapMap. The unsafe version does not check for empty subtrees, so it is faster.

 newtype ID = ID Int deriving Enum
 emm :: EnumMapMap (K Int) (EnumMapMap (K ID) Bool)
 res :: EnumMapMap (Int :& K ID) Bool
 res = unsafeJoinKey emm