gleam/map
Types
A dictionary of keys and values.
Any type can be used for the keys and values of a map, but all the keys must be of the same type and all the values must be of the same type.
Each key can only be present in a map once.
Maps are not ordered in any way, and any unintentional ordering is not to be relied upon in your code as it may change in future versions of Erlang or Gleam.
See the Erlang map module for more information.
pub external type Map(key, value)Functions
pub fn delete(from map: Map(a, b), delete key: a) -> Map(a, b)Creates a new map from a given map with all the same entries except for the one with a given key, if it exists.
Examples
> delete([#("a", 0), #("b", 1)], "a")
from_list([#("b", 1)])
> delete([#("a", 0), #("b", 1)], "c")
from_list([#("a", 0), #("b", 1)])
pub fn drop(from map: Map(a, b), drop disallowed_keys: List(a)) -> Map(
a,
b,
)Creates a new map from a given map with all the same entries except any with keys found in a given list.
Examples
> drop([#("a", 0), #("b", 1)], ["a"])
from_list([#("b", 2)])
> delete([#("a", 0), #("b", 1)], ["c"])
from_list([#("a", 0), #("b", 1)])
> drop([#("a", 0), #("b", 1)], ["a", "b", "c"])
from_list([])
pub fn filter(in map: Map(a, b), for property: fn(a, b) -> Bool) -> Map(
a,
b,
)Creates a new map from a given map, minus any entries that a given function
returns False for.
Examples
> from_list([#("a", 0), #("b", 1)])
> |> filter(fn(key, value) { value != 0 })
from_list([#("b", 1)])
> from_list([#("a", 0), #("b", 1)])
> |> filter(fn(key, value) { True })
from_list([#("a", 0), #("b", 1)])
pub fn fold(over map: Map(a, b), from initial: c, with fun: fn(
c,
a,
b,
) -> c) -> cCombines all entries into a single value by calling a given function on each one.
Maps are not ordered so the values are not returned in any specific order. Do not write code that relies on the order entries are used by this function as it may change in later versions of Gleam or Erlang.
Examples
> let map = from_list([#("a", 1), #("b", 3), #("c", 9)])
> fold(map, 0, fn(accumulator, key, value) { accumulator + value })
13
> import gleam/string.{append}
> fold(map, "", fn(accumulator, key, value) { append(accumulator, key) })
"abc"
pub fn from_list(list: List(#(a, b))) -> Map(a, b)Converts a list of 2-element tuples #(key, value) to a map.
If two tuples have the same key the last one in the list will be the one that is present in the map.
pub fn get(from: Map(a, b), get: a) -> Result(b, Nil)Fetches a value from a map for a given key.
The map may not have a value for the key, so the value is wrapped in a
Result.
Examples
> new() |> insert("a", 0) |> get("a")
Ok(0)
> new() |> insert("a", 0) |> get("b")
Error(Nil)
pub fn has_key(map: Map(a, b), key: a) -> BoolDetermines whether or not a value present in the map for a given key.
Examples
> new() |> insert("a", 0) |> has_key("a")
True
> new() |> insert("a", 0) |> has_key("b")
False
pub fn insert(into map: Map(a, b), for key: a, insert value: b) -> Map(
a,
b,
)Inserts a value into the map with the given key.
If the map already has a value for the given key then the value is replaced with the new value.
Examples
> new() |> insert("a", 0) |> to_list
[#("a", 0)]
> new() |> insert("a", 0) |> insert("a", 5) |> to_list
[#("a", 5)]
pub fn keys(map: Map(a, b)) -> List(a)Gets a list of all keys in a given map.
Maps are not ordered so the keys are not returned in any specific order. Do not write code that relies on the order keys are returned by this function as it may change in later versions of Gleam or Erlang.
Examples
> keys([#("a", 0), #("b", 1)])
["a", "b"]
pub fn map_values(in map: Map(a, b), with fun: fn(a, b) -> c) -> Map(
a,
c,
)Updates all values in a given map by calling a given function on each key and value.
Examples
> [#(3, 3), #(2, 4)]
> |> from_list
> |> map_values(fn(key, value) { key * value })
[#(3, 9), #(2, 8)]
pub fn merge(into map: Map(a, b), from new_entries: Map(a, b)) -> Map(
a,
b,
)Creates a new map from a pair of given maps by combining their entries.
If there are entries with the same keys in both maps the entry from the second map takes precedence.
Examples
> let a = from_list([#("a", 0), #("b", 1)])
> let b = from_list([#("b", 2), #("c", 3)])
> merge(a, b)
from_list([#("a", 0), #("b", 2), #("c", 3)])
pub fn size(map: Map(a, b)) -> IntDetermines the number of key-value pairs in the map. This function runs in constant time and does not need to iterate the map.
Examples
> new() |> size()
0
> new() |> insert("key", "value") |> size()
1
pub fn take(from map: Map(a, b), keeping desired_keys: List(a)) -> Map(
a,
b,
)Creates a new map from a given map, only including any entries for which the keys are in a given list.
Examples
> from_list([#("a", 0), #("b", 1)])
> |> take(["b"])
from_list([#("b", 1)])
> from_list([#("a", 0), #("b", 1)])
> |> take(["a", "b", "c"])
from_list([#("a", 0), #("b", 1)])
pub fn to_list(map: Map(a, b)) -> List(#(a, b))Converts the map to a list of 2-element tuples #(key, value), one for
each key-value pair in the map.
The tuples in the list have no specific order.
Examples
> new() |> to_list()
[]
> new() |> insert("key", 0) |> to_list()
[#("key", 0)]
pub fn update(in map: Map(a, b), update key: a, with fun: fn(
Option(b),
) -> b) -> Map(a, b)Creates a new map with one entry updated using a given function.
If there was not an entry in the map for the given key then the function
gets None as its argument, otherwise it gets Some(value).
Example
> let increment = fn(x) {
> case x {
> Some(i) -> i + 1
> None -> 0
> }
> }
> let map = from_list([#("a", 0)])
>
> update(map, "a", increment)
from_list([#("a", 1)])
> update(map, "b", increment)
from_list([#("a", 0), #("b", 0)])
pub fn values(map: Map(a, b)) -> List(b)Gets a list of all values in a given map.
Maps are not ordered so the values are not returned in any specific order. Do not write code that relies on the order values are returned by this function as it may change in later versions of Gleam or Erlang.
Examples
> values(from_list([#("a", 0), #("b", 1)]))
[0, 1]