gleam/dict

Types

Dict

A dictionary of keys and values.

Any type can be used for the keys and values of a dict, 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 dict once.

Dicts 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 type Dict(key, value)

Functions

combine

</>

pub fn combine(
  dict: Dict(a, b),
  other: Dict(a, b),
  with fun: fn(b, b) -> b,
) -> Dict(a, b)

Creates a new dict from a pair of given dicts by combining their entries.

If there are entries with the same keys in both dicts the given function is used to determine the new value to use in the resulting dict.

Examples

let a = from_list([#("a", 0), #("b", 1)])
let b = from_list([#("a", 2), #("c", 3)])
combine(a, b, fn(one, other) { one + other })
// -> from_list([#("a", 2), #("b", 1), #("c", 3)])

delete

</>

pub fn delete(from dict: Dict(a, b), delete key: a) -> Dict(a, b)

Creates a new dict from a given dict with all the same entries except for the one with a given key, if it exists.

Examples

from_list([#("a", 0), #("b", 1)]) |> delete("a")
// -> from_list([#("b", 1)])

from_list([#("a", 0), #("b", 1)]) |> delete("c")
// -> from_list([#("a", 0), #("b", 1)])

drop

</>

pub fn drop(
  from dict: Dict(a, b),
  drop disallowed_keys: List(a),
) -> Dict(a, b)

Creates a new dict from a given dict with all the same entries except any with keys found in a given list.

Examples

from_list([#("a", 0), #("b", 1)]) |> drop(["a"])
// -> from_list([#("b", 2)])

from_list([#("a", 0), #("b", 1)]) |> drop(["c"])
// -> from_list([#("a", 0), #("b", 1)])

from_list([#("a", 0), #("b", 1)]) |> drop(["a", "b", "c"])
// -> from_list([])

each

</>

pub fn each(dict: Dict(a, b), fun: fn(a, b) -> c) -> Nil

Calls a function for each key and value in a dict, discarding the return value.

Useful for producing a side effect for every item of a dict.

import gleam/io

let dict = from_list([#("a", "apple"), #("b", "banana"), #("c", "cherry")])

each(dict, fn(key, value) {
  io.println(key <> " => " <> value)
})
// -> Nil
// a => apple
// b => banana
// c => cherry

The order of elements in the iteration is an implementation detail that should not be relied upon.

filter

</>

pub fn filter(
  in dict: Dict(a, b),
  keeping predicate: fn(a, b) -> Bool,
) -> Dict(a, b)

Creates a new dict from a given dict, 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)])

fold

</>

pub fn fold(
  over dict: Dict(a, b),
  from initial: c,
  with fun: fn(c, a, b) -> c,
) -> c

Combines all entries into a single value by calling a given function on each one.

Dicts 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 dict = from_list([#("a", 1), #("b", 3), #("c", 9)])
fold(dict, 0, fn(accumulator, key, value) { accumulator + value })
// -> 13

import gleam/string

let dict = from_list([#("a", 1), #("b", 3), #("c", 9)])
fold(dict, "", fn(accumulator, key, value) {
  string.append(accumulator, key)
})
// -> "abc"

from_list

</>

pub fn from_list(list: List(#(a, b))) -> Dict(a, b)

Converts a list of 2-element tuples #(key, value) to a dict.

If two tuples have the same key the last one in the list will be the one that is present in the dict.

get

</>

pub fn get(from: Dict(a, b), get: a) -> Result(b, Nil)

Fetches a value from a dict for a given key.

The dict 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(dict: Dict(a, b), key: a) -> Bool

Determines whether or not a value present in the dict 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 dict: Dict(a, b),
  for key: a,
  insert value: b,
) -> Dict(a, b)

Inserts a value into the dict with the given key.

If the dict already has a value for the given key then the value is replaced with the new value.

Examples

new() |> insert("a", 0)
// -> from_list([#("a", 0)])

new() |> insert("a", 0) |> insert("a", 5)
// -> from_list([#("a", 5)])

keys

</>

pub fn keys(dict: Dict(a, b)) -> List(a)

Gets a list of all keys in a given dict.

Dicts 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

from_list([#("a", 0), #("b", 1)]) |> keys
// -> ["a", "b"]

map_values

</>

pub fn map_values(
  in dict: Dict(a, b),
  with fun: fn(a, b) -> c,
) -> Dict(a, c)

Updates all values in a given dict by calling a given function on each key and value.

Examples

from_list([#(3, 3), #(2, 4)])
|> map_values(fn(key, value) { key * value })
// -> from_list([#(3, 9), #(2, 8)])

merge

</>

pub fn merge(
  into dict: Dict(a, b),
  from new_entries: Dict(a, b),
) -> Dict(a, b)

Creates a new dict from a pair of given dicts by combining their entries.

If there are entries with the same keys in both dicts the entry from the second dict 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)])

new

</>

pub fn new() -> Dict(a, b)

Creates a fresh dict that contains no values.

size

</>

pub fn size(dict: Dict(a, b)) -> Int

Determines the number of key-value pairs in the dict. This function runs in constant time and does not need to iterate the dict.

Examples

new() |> size
// -> 0

new() |> insert("key", "value") |> size
// -> 1

take

</>

pub fn take(
  from dict: Dict(a, b),
  keeping desired_keys: List(a),
) -> Dict(a, b)

Creates a new dict from a given dict, 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)])

to_list

</>

pub fn to_list(dict: Dict(a, b)) -> List(#(a, b))

Converts the dict to a list of 2-element tuples #(key, value), one for each key-value pair in the dict.

The tuples in the list have no specific order.

Examples

Calling to_list on an empty dict returns an empty list.

new() |> to_list
// -> []

The ordering of elements in the resulting list is an implementation detail that should not be relied upon.

new() |> insert("b", 1) |> insert("a", 0) |> insert("c", 2) |> to_list
// -> [#("a", 0), #("b", 1), #("c", 2)]

update

</>

pub fn update(
  in dict: Dict(a, b),
  update key: a,
  with fun: fn(Option(b)) -> b,
) -> Dict(a, b)

Creates a new dict with one entry updated using a given function.

If there was not an entry in the dict for the given key then the function gets None as its argument, otherwise it gets Some(value).

Example

let dict = from_list([#("a", 0)])
let increment = fn(x) {
  case x {
    Some(i) -> i + 1
    None -> 0
  }
}

update(dict, "a", increment)
// -> from_list([#("a", 1)])

update(dict, "b", increment)
// -> from_list([#("a", 0), #("b", 0)])

values

</>

pub fn values(dict: Dict(a, b)) -> List(b)

Gets a list of all values in a given dict.

Dicts 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

from_list([#("a", 0), #("b", 1)]) |> values
// -> [0, 1]