A dictionary mapping unique keys to multiple values, allowing for modelling one-to-many relationships.
Example usage:
oneToMany : MultiDict String Int
oneToMany =
MultiDict.empty
|> MultiDict.insert "A" 1
|> MultiDict.insert "B" 2
|> MultiDict.insert "C" 3
|> MultiDict.insert "A" 2
MultiDict.get "A" oneToMany
--> Set.fromList [1, 2]Convert MultiDict into a Dict. (Throw away the reverse mapping.)
Convert Dict into a MultiDict. (Compute the reverse mapping.)
Create a dictionary with one key-value pair.
Insert a key-value pair into a dictionary. Replaces value when there is a collision.
Update the value of a dictionary for a specific key with a given function.
Remove a single key-value pair from a dictionary. If the key is not found, no changes are made.
Remove all key-value pairs for the given key from a dictionary. If the key is not found, no changes are made.
Determine if a dictionary is empty.
isEmpty empty == TrueDetermine if a key is in a dictionary.
Get the value associated with a key. If the key is not found, return
Nothing. This is useful when you are not sure if a key will be in the
dictionary.
animals = fromList [ ("Tom", Cat), ("Jerry", Mouse) ]
get "Tom" animals == Just Cat
get "Jerry" animals == Just Mouse
get "Spike" animals == NothingDetermine the number of key-value pairs in the dictionary.
Get all of the keys in a dictionary, sorted from lowest to highest.
keys (fromList [ ( 0, "Alice" ), ( 1, "Bob" ) ]) == [ 0, 1 ]Get all of the values in a dictionary, in the order of their keys.
values (fromList [ ( 0, "Alice" ), ( 1, "Bob" ) ]) == [ "Alice", "Bob" ]Convert a dictionary into an association list of key-value pairs, sorted by keys.
Convert an association list into a dictionary.
Apply a function to all values in a dictionary.
Fold over the key-value pairs in a dictionary from lowest key to highest key.
getAges users =
Dict.foldl addAge [] users
addAge _ user ages =
user.age :: ages
-- getAges users == [33,19,28]Fold over the key-value pairs in a dictionary from highest key to lowest key.
getAges users =
Dict.foldr addAge [] users
addAge _ user ages =
user.age :: ages
-- getAges users == [28,19,33]Keep only the mappings that pass the given test.
Partition a dictionary according to some test. The first dictionary contains all key-value pairs which passed the test, and the second contains the pairs that did not.
Combine two dictionaries. If there is a collision, preference is given to the first dictionary.
Keep a key-value pair when its key appears in the second dictionary. Preference is given to values in the first dictionary.
Keep a key-value pair when its key does not appear in the second dictionary.
The most general way of combining two dictionaries. You provide three accumulators for when a given key appears:
You then traverse all the keys from lowest to highest, building up whatever you want.
The underlying data structure. Think about it as