Data.HashMap

data HashMap :: Type -> Type -> Type

Immutable hash maps from keys k to values v.

Note that this is an unordered collection.

Instances

• (Eq k, Eq v) => Eq (HashMap k v)
• (Hashable k, Hashable v) => Hashable (HashMap k v)
• (Hashable k) => Monoid (HashMap k v)
• (Hashable k) => Semigroup (HashMap k v)

  This is "the shallow" semigroup instance, where maps themselves are combined using union rather than elements being combined. For duplicate keys, values from the left map are preserved.

• Functor (HashMap k)
• FunctorWithIndex k (HashMap k)
• Foldable (HashMap k)

  The Foldable instance is best used with a commutative function/Monoid, since hash maps do not guarantee any particular order.

• FoldableWithIndex k (HashMap k)

  The FoldableWithIndex instance is best used with a commutative function/Monoid, since hash maps do not guarantee any particular order.

• Traversable (HashMap k)
• TraversableWithIndex k (HashMap k)
• (Show k, Show v) => Show (HashMap k v)

empty :: forall v k. HashMap k v

The empty map.

singleton :: forall v k. Hashable k => k -> v -> HashMap k v

A map of one key and its associated value.

singleton k v == insert k v empty

lookup :: forall v k. Hashable k => k -> HashMap k v -> Maybe v

Get a value by key.

insert :: forall v k. Hashable k => k -> v -> HashMap k v -> HashMap k v

Insert or replace a value.

lookup k (insert k v m) == Just v

delete :: forall v k. Hashable k => k -> HashMap k v -> HashMap k v

Remove a key and its associated value from a map.

lookup k (delete k m) == Nothing

size :: forall v k. HashMap k v -> Int

Returns the number of key-value pairs in a map.

size (singleton k v) == 1

isEmpty :: forall v k. HashMap k v -> Boolean

Test whether a map is empty.

isEmpty m == (m == empty)

member :: forall v k. Hashable k => k -> HashMap k v -> Boolean

Test whether a key is in a map.

update :: forall v k. Hashable k => (v -> Maybe v) -> k -> HashMap k v -> HashMap k v

Update or delete the value for a key in a map

alter :: forall v k. Hashable k => (Maybe v -> Maybe v) -> k -> HashMap k v -> HashMap k v

Insert a value, delete a value, or update a value for a key in a map

fromFoldable :: forall v k f. Foldable f => Hashable k => f (Tuple k v) -> HashMap k v

Turn a foldable functor of pairs into a hash map.

In the presence of duplicate keys, later (by foldl) mappings overwrite earlier mappings.

toArrayBy :: forall v k a. (k -> v -> a) -> HashMap k v -> Array a

Convert a map to an array using the given function.

Note that no particular order is guaranteed.

toArrayBy Tuple (singleton 1 2) == [Tuple 1 2]
toArrayBy const        m == keys m
toArrayBy (flip const) m == values m

keys :: forall v k. HashMap k v -> Array k

Returns the keys of the map in no particular order.

If you need both keys and values, use toArrayBy rather than both keys and values.

values :: forall v k. HashMap k v -> Array v

Returns the values of the map in no particular order.

If you need both keys and values, use toArrayBy rather than both keys and values.

debugShow :: forall v k. HashMap k v -> String