A module that allows tagging dictionaries, while maintaining an API parallel to Dict.
A common idea is wanting to use a value that is not comparable as the key of a Dict a b.
Since we can't currently do that there are many different ways to address the problem.
One way to solve that problem is to use a type level assertion.
Rather than holding on to an entirely different type in the keys and threading a comparison function through,
we can just tell elm that we'd like to tag the Dict a b at compile time.
Doing so allows us to reuse the underlying behavior of the Dict a b with very little runtime overhead.
Most functions here are simple wrappers to refine the types without modifying the values.
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.
Determine if a key is in a dictionary.
Get the value associated with a key.
Determine the number of key-value pairs in the dictionary.
Get all of the untagged keys in a dictionary, sorted from lowest to highest.
Get all of the keys in a dictionary, sorted from lowest to highest.
Get all of the values in a dictionary, in the order of their keys.
Convert a dictionary into an association list of untagged key-value pairs, sorted by keys.
Convert an untagged association list into a dictionary.
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, in order from lowest key to highest key.
Fold over the key-value pairs in a dictionary, in order from highest key to lowest key.
Keep a key-value pair when it satisfies a predicate.
Partition a dictionary according to a predicate. The first dictionary contains all key-value pairs which satisfy the predicate, and the second contains the rest.
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.
A dictionary that tags the keys with an additional constraint.
The constraint is phantom in that it doesn't show up at runtime.