A dictionary that allows asking for the mappings in reverse direction.

Think about it as

type alias BiDict a b =
    { forward : Dict a b -- just a normal Dict!
    , reverse : Dict b (Set a) -- the reverse mappings!
    }

Convert BiDict into a Dict. (Throw away the reverse mapping.)

Convert Dict into a BiDict. (Compute the reverse mapping.)

Get the keys associated with a value. If the value is not found, return an empty set.

Get a list of unique values in the dictionary.

Get a count of unique values in the dictionary.

Convert a dictionary into a reverse association list of value-keys pairs.

Create an empty dictionary.

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 key-value pair from a dictionary. If the key is not found, no changes are made.

Determine if a dictionary is empty.

isEmpty empty == True

Determine 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 == Nothing

Determine 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 key-value pairs 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:

1. Only in the left dictionary.
2. In both dictionaries.
3. Only in the right dictionary.

You then traverse all the keys from lowest to highest, building up whatever you want.