joneshf / elm-tagged / Tagged.Dict

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.


type alias TaggedDict a b c =
Tagged a (Dict b c)

A dictionary that tags the keys with an additional constraint.

The constraint is phantom in that it doesn't show up at runtime.

Build

empty : TaggedDict tag comparable v

Create an empty dictionary.

singleton : Tagged tag comparable -> v -> TaggedDict tag comparable v

Create a dictionary with one key-value pair.

insert : Tagged tag comparable -> v -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Insert a key-value pair into a dictionary. Replaces value when there is a collision.

update : Tagged tag comparable -> (Maybe v -> Maybe v) -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Update the value of a dictionary for a specific key with a given function.

remove : Tagged tag comparable -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Remove a key-value pair from a dictionary. If the key is not found, no changes are made.

Query

isEmpty : TaggedDict tag c v -> Basics.Bool

Determine if a dictionary is empty.

member : Tagged tag comparable -> TaggedDict tag comparable v -> Basics.Bool

Determine if a key is in a dictionary.

get : Tagged tag comparable -> TaggedDict tag comparable v -> Maybe v

Get the value associated with a key.

size : TaggedDict tag c v -> Basics.Int

Determine the number of key-value pairs in the dictionary.

Lists

untaggedKeys : TaggedDict tag comparable v -> List comparable

Get all of the untagged keys in a dictionary, sorted from lowest to highest.

keys : TaggedDict tag comparable v -> List (Tagged tag comparable)

Get all of the keys in a dictionary, sorted from lowest to highest.

values : TaggedDict tag comparable v -> List v

Get all of the values in a dictionary, in the order of their keys.

toUntaggedList : TaggedDict tag comparable v -> List ( comparable, v )

Convert a dictionary into an association list of untagged key-value pairs, sorted by keys.

fromUntaggedList : List ( comparable, v ) -> TaggedDict tag comparable v

Convert an untagged association list into a dictionary.

toList : TaggedDict tag comparable v -> List ( Tagged tag comparable, v )

Convert a dictionary into an association list of key-value pairs, sorted by keys.

fromList : List ( Tagged tag comparable, v ) -> TaggedDict tag comparable v

Convert an association list into a dictionary.

Transform

map : (Tagged tag comparable -> a -> b) -> TaggedDict tag comparable a -> TaggedDict tag comparable b

Apply a function to all values in a dictionary.

foldl : (Tagged tag comparable -> v -> b -> b) -> b -> TaggedDict tag comparable v -> b

Fold over the key-value pairs in a dictionary, in order from lowest key to highest key.

foldr : (Tagged tag comparable -> v -> b -> b) -> b -> TaggedDict tag comparable v -> b

Fold over the key-value pairs in a dictionary, in order from highest key to lowest key.

filter : (Tagged tag comparable -> v -> Basics.Bool) -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Keep a key-value pair when it satisfies a predicate.

partition : (Tagged tag comparable -> v -> Basics.Bool) -> TaggedDict tag comparable v -> ( TaggedDict tag comparable v, TaggedDict tag comparable v )

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

union : TaggedDict tag comparable v -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Combine two dictionaries. If there is a collision, preference is given to the first dictionary.

intersect : TaggedDict tag comparable v -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Keep a key-value pair when its key appears in the second dictionary. Preference is given to values in the first dictionary.

diff : TaggedDict tag comparable v -> TaggedDict tag comparable v -> TaggedDict tag comparable v

Keep a key-value pair when its key does not appear in the second dictionary.

merge : (Tagged tag comparable -> a -> result -> result) -> (Tagged tag comparable -> a -> b -> result -> result) -> (Tagged tag comparable -> b -> result -> result) -> TaggedDict tag comparable a -> TaggedDict tag comparable b -> result -> result

The most general way of combining two dictionaries.