Portability | Uses GHC extensions |
---|---|
Stability | experimental |
Safe Haskell | None |
Strict EnumMapMap
. Based upon Data.IntMap.Strict, this version uses multi
dimensional keys and Enum
types instead of Int
s. Keys are built using
the :&
operator and terminated with K
. They are stored using Int
s 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
s.
Int
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.Lazy so only strict
operations can be performed on a strict EnumMapMap
.
The functions are strict on values and keys.
- emptySubTrees :: IsKey k => EnumMapMap k v -> Bool
- data k :& t = !k :& !t
- newtype 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 :: IsKey k => EnumMapMap k v -> Int
- null :: IsKey k => EnumMapMap k v -> Bool
- member :: SubKey k1 k2 v => k1 -> EnumMapMap k2 v -> Bool
- lookup :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> EnumMapMap k2 v -> Maybe (Result k1 k2 v)
- empty :: IsKey k => EnumMapMap k v
- singleton :: SubKey k1 k2 v => k1 -> Result k1 k2 v -> EnumMapMap k2 v
- insert :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> Result k1 k2 v -> EnumMapMap k2 v -> EnumMapMap k2 v
- 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
- 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
- delete :: (SubKey k1 k2 v, IsKey k1, IsKey k2) => k1 -> EnumMapMap k2 v -> EnumMapMap k2 v
- alter :: IsKey k => (Maybe v -> Maybe v) -> k -> EnumMapMap k v -> EnumMapMap k v
- union :: IsKey k => EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
- unionWith :: IsKey k => (v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
- unionWithKey :: IsKey k => (k -> v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k v
- unions :: IsKey k => [EnumMapMap k v] -> EnumMapMap k v
- difference :: IsKey k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
- differenceWith :: IsKey k => (v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
- differenceWithKey :: IsKey k => (k -> v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
- differenceSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k v
- intersection :: IsKey k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1
- intersectionWith :: IsKey k => (v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3
- intersectionWithKey :: IsKey k => (k -> v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3
- intersectSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k v
- map :: IsKey k => (v -> t) -> EnumMapMap k v -> EnumMapMap k t
- mapWithKey :: IsKey k => (k -> v -> t) -> EnumMapMap k v -> EnumMapMap k t
- foldr :: IsKey k => (v -> t -> t) -> t -> EnumMapMap k v -> t
- foldrWithKey :: IsKey k => (k -> v -> t -> t) -> t -> EnumMapMap k v -> t
- toList :: (IsKey k, SubKey k k v) => EnumMapMap k v -> [(k, v)]
- fromList :: (IsKey k, SubKey k k v, Result k k v ~ v) => [(k, v)] -> EnumMapMap k v
- keys :: IsKey k => EnumMapMap k v -> [k]
- elems :: IsKey k => EnumMapMap k v -> [v]
- keysSet :: (IsKey k, HasSKey k) => EnumMapMap k v -> EnumMapMap (Skey k) ()
- fromSet :: (IsKey k, HasSKey k) => (k -> v) -> EnumMapMap (Skey k) () -> EnumMapMap k v
- toK :: HasSKey k => Skey k -> k
- toS :: HasSKey k => k -> Skey k
- splitKey :: IsSplit k z => z -> EnumMapMap k v -> EnumMapMap (Head k z) (EnumMapMap (Tail k z) v)
- joinKey :: (IsKey k, IsKey (Plus k k2)) => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v
- unsafeJoinKey :: IsKey k => EnumMapMap k (EnumMapMap k2 v) -> EnumMapMap (Plus k k2) v
Documentation
emptySubTrees :: IsKey k => EnumMapMap k v -> BoolSource
No subtrees should be empty. Returns True
if one is.
Key types
Multiple keys are joined by the (:&
) constructor.
multiKey :: Int :& Int :& K Int multiKey = 5 :& 6 :& K 5
!k :& !t |
(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 |
Keys are terminated with the K
type
singleKey :: K Int singleKey = K 5
K k |
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) |
Split after 1 key.
emm :: EnumMapMap (T1 :& T2 :& K T3) v splitKey d1 emm :: EnumMapMap (T1 :& K T2) (EnumMapMap (K T3) v)
Split after 2 keys.
emm :: EnumMapMap (T1 :& T2 :& K T3) v splitKey d1 emm :: EnumMapMap (K T1) (EnumMapMap (T2 :& K T3) v)
Map Type
Query
null :: IsKey k => EnumMapMap k v -> BoolSource
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 -> BoolSource
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)Source
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
singleton :: SubKey k1 k2 v => k1 -> Result k1 k2 v -> EnumMapMap k2 vSource
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 vSource
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 vSource
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 vSource
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 vSource
Remove a key and it's value from the EnumMapMap
. If the key is not
present the original EnumMapMap
is returned.
Combine
Union
union :: IsKey k => EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource
The (left-biased) union of two EnumMapMap
s.
It prefers the first EnumMapMap
when duplicate keys are encountered.
unionWith :: IsKey k => (v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource
The union with a combining function.
unionWithKey :: IsKey k => (k -> v -> v -> v) -> EnumMapMap k v -> EnumMapMap k v -> EnumMapMap k vSource
The union with a combining function.
Difference
difference :: IsKey k => EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source
Difference between two EnumMapMap
s (based on keys).
differenceWith :: IsKey k => (v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source
Difference with a combining function.
differenceWithKey :: IsKey k => (k -> v1 -> v2 -> Maybe v1) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v1Source
Difference with a combining function.
differenceSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k vSource
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 v1Source
The (left-biased) intersection of two EnumMapMap
(based on keys).
intersectionWith :: IsKey k => (v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3Source
The intersection with a combining function.
intersectionWithKey :: IsKey k => (k -> v1 -> v2 -> v3) -> EnumMapMap k v1 -> EnumMapMap k v2 -> EnumMapMap k v3Source
The intersection with a combining function.
intersectSet :: (SubKeyS k s, IsKey k, IsKey s) => EnumMapMap k v -> EnumMapMap s () -> EnumMapMap k vSource
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 EnumMapSet
s that are submaps of the
EnumMapMap
.
Traversal
Map
map :: IsKey k => (v -> t) -> EnumMapMap k v -> EnumMapMap k tSource
Map a function over all values in the EnumMapMap
.
mapWithKey :: IsKey k => (k -> v -> t) -> EnumMapMap k v -> EnumMapMap k tSource
Map a function over all key/value pairs in the EnumMapMap
.
Folds
foldr :: IsKey k => (v -> t -> t) -> t -> EnumMapMap k v -> tSource
Fold the values in the EnumMapMap
using the given right-associative
binary operator
foldrWithKey :: IsKey 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 and Sets
toList :: (IsKey k, SubKey k k v) => EnumMapMap k v -> [(k, v)]Source
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 vSource
Create a EnumMapMap
from a list of key/value pairs.
keysSet :: (IsKey k, HasSKey k) => EnumMapMap k v -> EnumMapMap (Skey k) ()Source
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 vSource
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 -> kSource
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 kSource
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)Source
Split a key so that an EnumMapMap
becomes an EnumMapMap
of
EnumMapMap
s.
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) vSource
Join a key so that an EnumMapMap
of EnumMapMap
s 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) vSource
Join a key so that an EnumMapMap
of EnumMapMap
s 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