Data.EnumMapMap.Lazy

Lazy EnumMapMap. Based upon Data.IntMap.Lazy, this version uses multi dimensional keys and Enum types instead of Ints. Keys are built using the :& operator and terminated with K. They are stored using Ints so 2 keys that Enum to the same Int value will overwrite each other. The intension is that the Enum types will actually be newtype Ints.

 newtype AppleID = AppleID Int
 newtype TreeID = TreeID Int
 type Orchard = EnumMapMap (TreeID :& K AppleID) Apple
 apple = lookup (TreeID 4 :& K AppleID 32) orchard

The K type is different to that used in Data.EnumMapMap.Strict so only lazy operations can be performed on a lazy EnumMapMap.

The functions are lazy on values, but strict on keys.

Documentation

emptySubTrees :: IsKey k => EnumMapMap k v -> Bool

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

Key types

data k :& t

Multiple keys are joined by the (:&) constructor.

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

Constructors

!k :& !t

Instances

(Enum k1, ~ * k1 k2) => SubKey (S k1) (:& k2 t2) ()

(Enum k1, ~ * k1 k2) => SubKey (K k1) (:& k2 t2) v

(Enum k1, ~ * k1 k2) => SubKey (K k1) (:& k2 t2) v

(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)

(NFData k, NFData t) => NFData (:& k t)

(Eq (:& k t), Eq k, Enum k, IsKey t, HasSKey t) => IsKey (:& k t)

HasSKey t => HasSKey (:& k t)

IsSplit (:& k t) Z

IsSplit (:& k t) Z

(Enum k1, ~ * k1 k2) => SubKeyS (:& k1 t) (S k2)

(Enum k1, ~ * k1 k2) => SubKeyS (:& k1 t) (S k2)

(IsSplit t n, Enum k) => IsSplit (:& k t) (N n)

(Enum k, IsKey t1, IsKey t2, SubKeyS t1 t2) => SubKeyS (:& k t1) (:& k t2)

(Enum k, IsKey t1, IsKey t2, SubKey t1 t2 v) => SubKey (:& k t1) (:& k t2) v

newtype K k

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)

NFData k => NFData (K k)

(Eq (K k), Enum k, Eq k) => IsKey (K k)

HasSKey (K k)

Enum k => SubKeyS (K k) (S k)

Enum k => SubKey (K k) (K k) v

(Enum k1, ~ * k1 k2) => SubKey (K k1) (:& k2 t2) v

Show v => Show (EnumMapMap (K k) v)

NFData v => NFData (EnumMapMap (K k) v)

d1 :: Z

Split after 1 key.

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

d2 :: N Z

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)

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))))))))

Map Type

Query

size :: IsKey k => EnumMapMap k v -> Int

Number of elements in the EnumMapMap.

null :: IsKey k => EnumMapMap k v -> Bool

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 :: SubKey k1 k2 v => k1 -> EnumMapMap k2 v -> Bool

Is the key present in the EnumMapMap?

lookup :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> EnumMapMap k2 v -> Maybe (Result k1 k2 v)

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

If the given key has less dimensions then the EnumMapMap then a submap is returned.

 emm2 = fromList [(3 :& 2 :& K 1, "a"), (3 :& 2 :& K 4, "a")]
 lookup (3 :& K 2) emm2 == Just $ fromList [(K 1, "a"), (K 4, "a")]

Construction

empty :: IsKey k => EnumMapMap k v

The empty EnumMapMap.

singleton :: SubKey k1 k2 v => k1 -> Result k1 k2 v -> EnumMapMap k2 v

An EnumMapMap with one element

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

Insertion

insert :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> Result k1 k2 v -> EnumMapMap k2 v -> EnumMapMap k2 v

Insert a new key/value pair into the EnumMapMap. Can also insert submaps.

insertWith :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => (Result k1 k2 v -> Result k1 k2 v -> Result k1 k2 v) -> k1 -> Result k1 k2 v -> EnumMapMap k2 v -> EnumMapMap k2 v

Insert with a combining function. Can also insert submaps.

insertWithKey :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => (k1 -> Result k1 k2 v -> Result k1 k2 v -> Result k1 k2 v) -> k1 -> Result k1 k2 v -> EnumMapMap k2 v -> EnumMapMap k2 v

Insert with a combining function. Can also insert submaps.

Delete/Update

delete :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> EnumMapMap k2 v -> EnumMapMap k2 v

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

alter :: IsKey k => (Maybe v -> Maybe v) -> k -> EnumMapMap k v -> EnumMapMap k v

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 :: IsKey k => EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v

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

unionWith :: IsKey k => (v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v

The union with a combining function.

unionWithKey :: IsKey k => (k -> v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v

The union with a combining function.

unions :: IsKey k => [EnumMapMap k v] -> EnumMapMap k v

The union of a list of maps.

Difference

difference :: IsKey k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1

Difference between two EnumMapMaps (based on keys).

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

Difference with a combining function.

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

Difference with a combining function.

differenceSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k v

The difference between an EnumMapMap and an EnumMapSet. If a key is present in the EnumMapSet it will not be present in the result.

Intersection

intersection :: IsKey k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1

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

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

The intersection with a combining function.

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

The intersection with a combining function.

intersectSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k v

The intersection of an EnumMapMap and an EnumMapSet. If a key is present in the EnumMapSet then it will be present in the resulting EnumMapMap. Works with EnumMapSets that are submaps of the EnumMapMap.

Map

map :: IsKey k => (v -> t) -> EnumMapMap k v -> EnumMapMap k t

Map a function over all values in the EnumMapMap.

mapWithKey :: IsKey k => (k -> v -> t) -> EnumMapMap k v -> EnumMapMap k t

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

Folds

foldr :: IsKey k => (v -> t -> t) -> t -> EnumMapMap k v -> t

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

foldrWithKey :: IsKey k => (k -> v -> t -> t) -> t -> EnumMapMap k v -> t

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

Lists and sets

toList :: (IsKey k, SubKey k k v) => EnumMapMap k v -> [(k, v)]

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

fromList :: (IsKey k, SubKey k k v, Result k k v ~ v) => [(k, v)] -> EnumMapMap k v

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

keys :: IsKey k => EnumMapMap k v -> [k]

List of keys

elems :: IsKey k => EnumMapMap k v -> [v]

List of elements in ascending order of keys

keysSet :: (IsKey k, HasSKey k) => EnumMapMap k v -> EnumMapMap (Skey k) ()

The EnumMapSet of the keys. EnumMapMap keys can be converted into EnumMapSet keys using toS, and back again using toK.

fromSet :: (IsKey k, HasSKey k) => (k -> v) -> EnumMapMap (Skey k) () -> EnumMapMap k v

Build an EnumMapMap from an EnumMapSet and a function which for each key computes it's value

Split/Join Keys

toK :: HasSKey k => Skey k -> k

Convert a key terminated with S into one terminated with K.

 s = 1 :& 2 :& S 3
 toK s == 1 :& 2 :& K 3

toS :: HasSKey k => k -> Skey k

Convert a key terminated with K into one terminated with S.

 k = 1 :& 2 :& 'K' 3
 toS k == 1 :& 2 :& 'S' 3

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

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 :: (IsKey k, IsKey (Plus k k2)) => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v

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 :: IsKey k => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v

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