Portability | portable |
---|---|
Stability | beta |
Maintainer | wren@community.haskell.org |
Additional convenience versions of the generic functions.
- lookupWithDefault :: a -> KeyString -> Trie a -> a
- insertIfAbsent :: KeyString -> a -> Trie a -> Trie a
- insertWith :: (a -> a -> a) -> KeyString -> a -> Trie a -> Trie a
- insertWithKey :: (KeyString -> a -> a -> a) -> KeyString -> a -> Trie a -> Trie a
- adjustWithKey :: (KeyString -> a -> a) -> KeyString -> Trie a -> Trie a
- update :: (a -> Maybe a) -> KeyString -> Trie a -> Trie a
- updateWithKey :: (KeyString -> a -> Maybe a) -> KeyString -> Trie a -> Trie a
- fromListL :: [(KeyString, a)] -> Trie a
- fromListR :: [(KeyString, a)] -> Trie a
- fromListS :: [(KeyString, a)] -> Trie a
- disunion :: Trie a -> Trie a -> Trie a
- unionWith :: (a -> a -> a) -> Trie a -> Trie a -> Trie a
lookupBy
variants
lookupWithDefault :: a -> KeyString -> Trie a -> aSource
Lookup a key, returning a default value if it's not found.
alterBy
variants
insertIfAbsent :: KeyString -> a -> Trie a -> Trie aSource
Insert a new key, retaining old value on conflict.
insertWith :: (a -> a -> a) -> KeyString -> a -> Trie a -> Trie aSource
Insert a new key, with a function to resolve conflicts.
adjustWithKey :: (KeyString -> a -> a) -> KeyString -> Trie a -> Trie aSource
Apply a function to change the value at a key.
update :: (a -> Maybe a) -> KeyString -> Trie a -> Trie aSource
Apply a function to the value at a key, possibly removing it.
Conversion functions
Just like fromList
both of these functions convert an association
list into a trie, with earlier values shadowing later ones when
keys conflict. Depending on the order of keys in the list, there
can be as much as 5x speed difference between the two. Yet,
performance is about the same when matching best-case to best-case
and worst-case to worst-case (which is which is swapped when
reversing the list or changing which function is used).
fromListS :: [(KeyString, a)] -> Trie aSource
This version sorts the list before folding over it. This adds O(n log n) overhead and requires the whole list be in memory at once, but it ensures that the list is in best-case order. The benefits generally outweigh the costs.