Map

A Map holds key-value pairs. Any value may be used as a key or value. Operations on a Map mutate the internal state, so it never needs to be re-assigned.

An immutable map implementation is available in the Immutable submodule.

1

from "map" include Map

Types

Type declarations included in the Map module.

Map.Map

1

type Map<k, v>

Map.InternalMapStats

1
2
3
4

record InternalMapStats {
  currentSize: Number,
  bucketCount: Number,
}

Represents the internal state of a map.

Values

Functions and constants included in the Map module.

Map.make

1

make : (?size: Number) => Map<a, b>

Creates a new empty map with an initial storage of the given size. As values are added or removed, the internal storage may grow or shrink. Generally, you won’t need to care about the storage size of your map and can use the default size.

Parameters:

Returns:

Map.set

1

set : (key: a, value: b, map: Map<a, b>) => Void

Adds a new key-value pair to the map. If the key already exists in the map, the value is replaced.

Parameters:

Map.get

1

get : (key: a, map: Map<a, b>) => Option<b>

Retrieves the value for the given key.

Parameters:

Returns:

Map.contains

1

contains : (key: a, map: Map<a, b>) => Bool

Determines if the map contains the given key. In such a case, it will always contain a value for the given key.

Parameters:

Returns:

Map.remove

1

remove : (key: a, map: Map<a, b>) => Void

Removes the given key from the map, which also removes the value. If the key pair doesn’t exist, nothing happens.

Parameters:

Map.update

1

update : (key: a, fn: (Option<b> => Option<b>), map: Map<a, b>) => Void

Updates a value in the map by calling an updater function that receives the previously stored value as an Option and returns the new value to be stored as an Option. If the key didn’t exist previously, the value will be None. If None is returned from the updater function, the key-value pair is removed.

Parameters:

Map.size

1

size : (map: Map<a, b>) => Number

Provides the count of key-value pairs stored within the map.

Parameters:

Returns:

Map.isEmpty

1

isEmpty : (map: Map<a, b>) => Bool

Determines if the map contains no key-value pairs.

Parameters:

Returns:

Map.clear

1

clear : (map: Map<a, b>) => Void

Resets the map by removing all key-value pairs.

Parameters:

Map.forEach

1

forEach : (fn: ((a, b) => Void), map: Map<a, b>) => Void

Iterates the map, calling an iterator function with each key and value.

Parameters:

Map.reduce

1

reduce : (fn: ((a, b, c) => a), init: a, map: Map<b, c>) => a

Combines all key-value pairs of a map using a reducer function.

Parameters:

Returns:

Map.keys

1

keys : (map: Map<a, b>) => List<a>

Enumerates all keys in the given map.

Parameters:

Returns:

Map.values

1

values : (map: Map<a, b>) => List<b>

Enumerates all values in the given map.

Parameters:

Returns:

Map.toList

1

toList : (map: Map<a, b>) => List<(a, b)>

Enumerates all key-value pairs in the given map.

Parameters:

Returns:

Map.fromList

1

fromList : (list: List<(a, b)>) => Map<a, b>

Creates a map from a list.

Parameters:

Returns:

Map.toArray

1

toArray : (map: Map<a, b>) => Array<(a, b)>

Converts a map into an array of its key-value pairs.

Parameters:

Returns:

Map.fromArray

1

fromArray : (array: Array<(a, b)>) => Map<a, b>

Creates a map from an array.

Parameters:

Returns:

Map.filter

1

filter : (fn: ((a, b) => Bool), map: Map<a, b>) => Void

Removes key-value pairs from a map where a predicate function returns false.

Parameters:

Map.reject

1

reject : (fn: ((a, b) => Bool), map: Map<a, b>) => Void

Removes key-value pairs from a map where a predicate function returns true.

Parameters:

Map.getInternalStats

1

getInternalStats : (map: Map<a, b>) => InternalMapStats

Provides data representing the internal state state of the map.

Parameters:

Returns:

Map.Immutable

An immutable map implementation.

Types

Type declarations included in the Map.Immutable module.

Map.Immutable.Map

1

type Map<k, v>

Values

Functions and constants included in the Map.Immutable module.

Map.Immutable.empty

1

empty : Map<a, b>

An empty map

Map.Immutable.size

1

size : (map: Map<a, b>) => Number

Provides the count of key-value pairs stored within the map.

Parameters:

Returns:

Map.Immutable.isEmpty

1

isEmpty : (map: Map<a, b>) => Bool

Determines if the map contains no key-value pairs.

Parameters:

Returns:

Map.Immutable.set

1

set : (key: a, value: b, map: Map<a, b>) => Map<a, b>

Produces a new map containing a new key-value pair. If the key already exists in the map, the value is replaced.

Parameters:

Returns:

Map.Immutable.get

1

get : (key: a, map: Map<a, b>) => Option<b>

Retrieves the value for the given key.

Parameters:

Returns:

Map.Immutable.contains

1

contains : (key: a, map: Map<a, b>) => Bool

Determines if the map contains the given key. In such a case, it will always contain a value for the given key.

Parameters:

Returns:

Map.Immutable.remove

1

remove : (key: a, map: Map<a, b>) => Map<a, b>

Produces a new map without the key-value pair corresponding to the given key. If the key doesn’t exist in the map, the map will be returned unmodified.

Parameters:

Returns:

Map.Immutable.update

1

update : (key: a, fn: (Option<b> => Option<b>), map: Map<a, b>) => Map<a, b>

Produces a new map by calling an updater function that receives the previously stored value as an Option and returns the new value to be stored as an Option. If the key didn’t exist previously, the value will be None. If None is returned from the updater function, the key-value pair is excluded.

Parameters:

Returns:

Map.Immutable.forEach

1

forEach : (fn: ((a, b) => Void), map: Map<a, b>) => Void

Iterates the map, calling an iterator function with each key and value.

Parameters:

Map.Immutable.reduce

1

reduce : (fn: ((a, b, c) => a), init: a, map: Map<b, c>) => a

Combines all key-value pairs of a map using a reducer function.

Parameters:

Returns:

Map.Immutable.keys

1

keys : (map: Map<a, b>) => List<a>

Enumerates all keys in the given map.

Parameters:

Returns:

Map.Immutable.values

1

values : (map: Map<a, b>) => List<b>

Enumerates all values in the given map.

Parameters:

Returns:

Map.Immutable.filter

1

filter : (fn: ((a, b) => Bool), map: Map<a, b>) => Map<a, b>

Produces a new map excluding the key-value pairs where a predicate function returns false.

Parameters:

Returns:

Map.Immutable.reject

1

reject : (fn: ((a, b) => Bool), map: Map<a, b>) => Map<a, b>

Produces a new map excluding the key-value pairs where a predicate function returns true.

Parameters:

Returns:

Map.Immutable.fromList

1

fromList : (list: List<(a, b)>) => Map<a, b>

Creates a map from a list.

Parameters:

Returns:

Map.Immutable.toList

1

toList : (map: Map<a, b>) => List<(a, b)>

Enumerates all key-value pairs in the given map.

Parameters:

Returns:

Map.Immutable.fromArray

1

fromArray : (array: Array<(a, b)>) => Map<a, b>

Creates a map from an array.

Parameters:

Returns:

Map.Immutable.toArray

1

toArray : (map: Map<a, b>) => Array<(a, b)>

Converts a map into an array of its key-value pairs.

Parameters:

Returns: