Map -is:module

A Map from keys k to values a. The Semigroup operation for Map is union, which prefers values from the left operand. If m1 maps a key k to a value a1, and m2 maps the same key to a different value a2, then their union m1 <> m2 maps k to a1.

Invariant preserving version of Map from the containers packages, suitable for use with Uniplate. Use toMap to construct values, and fromMap to deconstruct values.

A Map that remembers the original ordering of keys This is primarily used so that formatting preserves field order This is done primarily to avoid a dependency on insert-ordered-containers and also to improve performance

Hash-table, based on STM-specialized Hash Array Mapped Trie.

Type-level fmap for type-level functors. Note: this name clashes with Map from containers. FMap is provided as a synonym to avoid this.

Example

>>> data AddMul :: Nat -> Nat -> Exp Nat

>>> type instance Eval (AddMul x y) = (x TL.+ y) TL.* (x TL.+ y)

>>> :kind! Eval (Map (AddMul 2) '[0, 1, 2, 3, 4])
Eval (Map (AddMul 2) '[0, 1, 2, 3, 4]) :: [Nat]
= '[4, 9, 16, 25, 36]

A Map from keys k to values a.

Lists of pairs representing maps. The Listable tiers enumeration will not have repeated maps.

> take 6 (list :: [Map Nat Nat])
[Map [],Map [(0,0)],Map [(0,1)],Map [(1,0)],Map [(0,2)],Map [(1,1)]]

The abstract type of a Map. Its interface is a suitable subset of IntMap.

Map a type level function over a Row.

A mapping from keys to values. The keys in a map needs to be an instance of the Key typeclass. Instances are already provided for many common element types. Map implements Foldable, Monoid, etc so many common operations such as foldr to reduce the structure with a right fold, length to get the number of key/value pairs in the dictionary, null to test whether the map is empty, and (<>) to join two maps together are available. To convert to other dictionary types see fromMap below. (this is a thin wrapper around unordered-containers's HashMap, but if you use the conversion functions to extract the key/value pairs in a list the list will be ordered according to the keys' Ord instance)

linear maps from elements of a free module to another free module over r

f $# x + y = (f $# x) + (f $# y)
f $# (r .* x) = r .* (f $# x)

Map r b a represents a linear mapping from a free module with basis a over r to a free module with basis b over r. Note well the reversed direction of the arrow, due to the contravariance of change of basis! This way enables we can employ arbitrary pure functions as linear maps by lifting them using arr, or build them by using the monad instance for Map r b. As a consequence Map is an instance of, well, almost everything.

A map based on Strict. O(log(n)) for most operations.