Module

Data.HashMap

Package
purescript-unordered-collections
Repository
fehrenbach/purescript-unordered-collections

#HashMap Source

data HashMap :: Type -> Type -> Type

Immutable hash maps from keys k to values v.

Note that this is an unordered collection.

Instances

#empty Source

empty :: forall v k. HashMap k v

The empty map.

#singleton Source

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 Source

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

Get a value by key.

#insert Source

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 Source

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 Source

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

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

size (singleton k v) == 1

#isEmpty Source

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

Test whether a map is empty.

isEmpty m == (m == empty)

#member Source

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

Test whether a key is in a map.

#upsert Source

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

Insert or update a value.

If your update function uses both the previously existing value and the new value, especially if you find yourself writing upsert (f v) k v, consider using insertWith instead.

#insertWith Source

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

Insert or update a value with the given function.

The combining function is called with the existing value as the first argument and the new value as the second argument.

insertWith (<>) 5 "b" (singleton 5 "a") == singleton 5 "ab"

If your update function does not use the existing value, especially if you find yourself writing insertWith (const f), consider using upsert instead.

#update Source

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 Source

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.

#filter Source

filter :: forall v k. (v -> Boolean) -> HashMap k v -> HashMap k v

Remove key-value-pairs from a map for which the predicate does not hold.

filter (const False) m == empty
filter (const True) m == m

#filterWithKey Source

filterWithKey :: forall v k. (k -> v -> Boolean) -> HashMap k v -> HashMap k v

Remove key-value-pairs from a map for which the predicate does not hold.

Like filter, but the predicate takes both key and value.

#filterKeys Source

filterKeys :: forall v k. (k -> Boolean) -> HashMap k v -> HashMap k v

Remove all keys from the map for which the predicate does not hold.

difference m1 m2 == filterKeys (\k -> member k m2) m1

#mapMaybe Source

mapMaybe :: forall w v k. (v -> Maybe w) -> HashMap k v -> HashMap k w

Apply a function to all values in a hash map, discard the Nothing results, and keep the value of the Just results.

#mapMaybeWithKey Source

mapMaybeWithKey :: forall w v k. (k -> v -> Maybe w) -> HashMap k v -> HashMap k w

Apply a function to all key value pairs in a hash map, discard the Nothing results, and keep the value of the Just results.

#fromArray Source

fromArray :: forall v k. Hashable k => Array (Tuple k v) -> HashMap k v

Turn an array of pairs into a hash map.

This uses a mutable hash map internally and is faster than fromFoldable.

If you have an array of something other than tuples, use fromArrayBy.

#fromFoldable Source

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.

If your input is an array, consider using fromArray instead.

#fromArrayBy Source

fromArrayBy :: forall v k a. Hashable k => (a -> k) -> (a -> v) -> Array a -> HashMap k v

Turn an array into a hash map given extraction functions for keys and values.

This uses a mutable hash map internally and is faster than fromFoldable and fromFoldableBy.

#fromFoldableBy Source

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

Turn a foldable functor into a hash map given extraction functions for keys and values.

If your input is an array, consider using fromArrayBy instead.

fromFoldableBy fst snd == fromFoldable

#fromFoldableWithIndex Source

fromFoldableWithIndex :: forall v k f. FoldableWithIndex k f => Hashable k => f v -> HashMap k v

Turn a foldable functor with index into a hash map.

This can be used to convert, for example, an ordered map into a hash map with the same keys and values, or an array into a hash map with values indexed by their position in the array.

fromFoldableWithIndex ["a", "b"] == fromArray [Tuple 0 "a", Tuple 1 "b"]

#toArrayBy Source

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 Source

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 Source

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 Source

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 Source

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 Source

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

Intersect two maps.

#intersectionWith Source

intersectionWith :: forall c b a k. Hashable k => (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c

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

#difference Source

difference :: forall w v k. Hashable k => HashMap k v -> HashMap k w -> HashMap k v

Compute the difference of two maps, that is a new map of all the mappings in the left map that do not have a corresponding key in the right map.

#nubHash Source

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 Source

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