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.

fromFoldableBy :: forall v k a f. Foldable f => Hashable k => (a -> k) -> (a -> v) -> f a -> HashMap k v

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.

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

Union two maps.

For duplicate keys, we keep the value from the left map.

This is the same as Semigroup.append aka (<>).

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

Union two maps, combining the values for keys that appear in both maps using the given function.

unionWith (-) (singleton 0 3) (singleton 0 2) == singleton 0 1

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

Intersect two maps.

For duplicate keys, we keep the value from the right map.

This is the same as Semigroup.append aka (<>).

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

Intersect two maps, combining the values for keys that appear in both maps using the given function.

intersectionWith (-) (singleton 0 3) (singleton 0 2) == singleton 0 1

nubHash :: forall a. Hashable a => Array a -> Array a

Remove duplicates from an array.

Like nub from Data.Array, but uses a Hashable constraint instead of an Ord constraint.

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