gleam/map
Types
Map
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
delete
pub fn delete(from map: Map(a, b), delete key: a) -> Map(a, b)
Create 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([tuple("a", 0), tuple("b", 1)], "a")
from_list([tuple("b", 2)])
> delete([tuple("a", 0), tuple("b", 1)], "c")
from_list([tple("a", 0), tuple("b", 2)])
drop
pub fn drop( from map: Map(a, b), drop disallowed_keys: List(a), ) -> Map(a, b)
Create a new map from a given map with all the same entries except any with keys found in a given list.
Examples
> drop([tuple("a", 0), tuple("b", 1)], ["a"])
from_list([tuple("b", 2)])
> delete([tuple("a", 0), tuple("b", 1)], ["c"])
from_list([tple("a", 0), tuple("b", 2)])
> drop([tuple("a", 0), tuple("b", 1)], ["a", "b", "c"])
from_list([])
filter
pub fn filter( in map: Map(a, b), for predicate: fn(a, b) -> Bool, ) -> Map(a, b)
Create a new map from a given map, minus any entries that a given function returns False for.
Examples
> from_list([tuple("a", 0), tuple("b", 1)])
> |> filter(fn(key, value) { value != 0 })
from_list([tuple("b", 1)])
> from_list([tuple("a", 0), tuple("b", 1)])
> |> filter(fn(key, value) { True })
from_list([tuple("a", 0), tuple("b", 1)])
fold
pub fn fold( map: Map(a, b), from initial: c, with fun: fn(a, b, c) -> c, ) -> a
Combine 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([tuple("a", 1), tuple("b", 3), tuple("c", 9)])
> fold(map, 0, fn(key, value, accumulator) { accumulator + value })
13
> import gleam/string.{append}
> fold(map, "", fn(key, value, accumulator) { append(accumulator, value) })
"abc"
from_list
pub external fn from_list( List(tuple(key, value)), ) -> Map(key, value)
Convert a list of 2-element tuples tuple(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.
get
pub external fn get( from: Map(key, value), get: key, ) -> Option(value)
Fetch 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)
has_key
pub fn has_key(map: Map(a, b), key: a) -> Bool
Determind 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
insert
pub fn insert( into map: Map(a, b), for key: a, insert value: b, ) -> Map(a, b)
Insert 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
[tuple("a", 0)]
> new() |> insert("a", 0) |> insert("a", 5) |> to_list
[tuple("a", 5)]
keys
pub external fn keys(Map(keys, v)) -> List(keys)
Get 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([tuple("a", 0), tuple("b", 1)])
["a", "b"]
map_values
pub fn map_values( in map: Map(a, b), with fun: fn(a, b) -> c, ) -> Map(a, b)
Update all values in a given map by calling a given function on each key and value.
Examples
> [tuple(3, 3), tuple(2, 4)]
> |> from_list
> |> map_values(fn(key, value) { key * value })
[tuple(3, 9), tuple(2, 8)]
merge
pub external fn merge( into: Map(k, v), merge: Map(k, v), ) -> Map(k, v)
Create 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([tuple("a", 0), tuple("b", 1)])
> let b = from_list([tuple("b", 2), tuple("c", 3)])
> merge(a, b)
from_list([tuple("a", 0), tuple("b", 2), tuple("c", 3)])
size
pub external fn size(Map(k, v)) -> Int
Determine 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
take
pub fn take( from map: Map(a, b), drop desired_keys: List(a), ) -> Map(a, b)
Create a new map from a given map, only including any entries for which the keys are in a given list.
Examples
> from_list([tuple("a", 0), tuple("b", 1)])
> |> take(["b"])
from_list([tuple("b", 1)])
> from_list([tuple("a", 0), tuple("b", 1)])
> |> take(["a", "b", "c"])
from_list([tuple("a", 0), tuple("b", 1)])
to_list
pub external fn to_list( Map(key, value), ) -> List(tuple(key, value))
Convert the map to a list of 2-element tuples tuple(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()
[tuple("key", 0)]
update
pub fn update( in map: Map(a, b), update key: a, with fun: fn(Result(b, Nil)) -> b, ) -> Map(a, b)
Create 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 Error(Nil) as its argument, otherwise it gets Ok(value).
Example
> let increment = fn(x) {
> case x {
> Ok(i) -> i + 1
> Error(Nil) -> 0
> }
> }
> let map = from_list([tuple("a", 0)])
>
> update(map, "a" increment)
from_list([tuple("a", 1)])
> update(map, "b" increment)
from_list([tuple("a", 0), tuple("b", 0)])
values
pub external fn values(Map(k, values)) -> List(values)
Get 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
> keys(from_list([tuple("a", 0), tuple("b", 1)]))
[0, 1]