Module

pooka/dict

src/pooka/dict.pooka

Keep the keys in a small cabinet whose earlier drawers remain intact.

Dict wraps native immutable Erlang maps behind typed storage capabilities. Updates return a new dictionary. Iteration order is unspecified, duplicate input keys keep their last value, and equals compares contents rather than closure identities.

import pooka/dict

assert dict.from_list([#("oak", 3)]).get("oak") == Some(3)

class

Dict

src/pooka/dict.pooka:23

class Dict(k, v)

An immutable key/value cabinet backed by typed native-map capabilities. Prefer empty and from_list when constructing public dictionaries.

constructor

new

src/pooka/dict.pooka:28

new(storage: Storage(k, v))

INFERREDfn(pooka/internal/map.Storage(k, v)) -> pooka/dict.Dict(k, v)

Create the value from its declared fields. Public factory functions keep the storage details out of ordinary calling code.

method

get

src/pooka/dict.pooka:39

get(key: k) -> Option(v)

INFERREDfn(k) -> Option(v)

Look up one key without treating absence as an exception.

import pooka/dict

assert dict.from_list([#("oak", 1)]).get("oak") == Some(1)

method

insert

src/pooka/dict.pooka:50

insert(key: k, value: v) -> Dict(k, v)

INFERREDfn(k, v) -> pooka/dict.Dict(k, v)

Return a dictionary with the key associated to the new value.

import pooka/dict

assert dict.empty().insert("oak", 2).get("oak") == Some(2)

method

delete

src/pooka/dict.pooka:61

delete(key: k) -> Dict(k, v)

INFERREDfn(k) -> pooka/dict.Dict(k, v)

Return a dictionary without the key. Removing an absent key is harmless.

import pooka/dict

assert dict.from_list([#("oak", 1)]).delete("oak").is_empty()

method

has_key

src/pooka/dict.pooka:72

has_key(key: k) -> Bool

INFERREDfn(k) -> Bool

Check membership without exposing the stored value.

import pooka/dict

assert dict.from_list([#("oak", 1)]).has_key("oak")

method

size

src/pooka/dict.pooka:86

size() -> Int

INFERREDfn() -> Int

Count distinct keys.

import pooka/dict

assert dict.from_list([#("oak", 1)]).size() == 1

method

is_empty

src/pooka/dict.pooka:97

is_empty() -> Bool

INFERREDfn() -> Bool

Ask whether no keys are stored.

import pooka/dict

assert dict.empty().is_empty()

method

keys

src/pooka/dict.pooka:109

keys() -> List(k)

INFERREDfn() -> List(k)

Enumerate keys in unspecified order.

import pooka/dict
import pooka/list

assert list.contains(dict.from_list([#("oak", 1)]).keys(), "oak")

method

values

src/pooka/dict.pooka:124

values() -> List(v)

INFERREDfn() -> List(v)

Enumerate stored values in unspecified order.

import pooka/dict
import pooka/list

assert list.contains(dict.from_list([#("oak", 1)]).values(), 1)

method

to_list

src/pooka/dict.pooka:139

to_list() -> List(#(k, v))

INFERREDfn() -> List(#(k, v))

Enumerate key/value pairs in unspecified order.

import pooka/dict
import pooka/list

assert list.contains(dict.from_list([#("oak", 1)]).to_list(), #("oak", 1))

method

map_values

src/pooka/dict.pooka:150

map_values(transform: fn(v) -> b) -> Dict(k, b)

INFERREDfn(fn(v) -> a) -> pooka/dict.Dict(k, a)

Transform each value while retaining keys. The value type may change.

import pooka/dict

assert dict.from_list([#("oak", 1)]).map_values(fn(x) { x == 1 }).get("oak") == Some(True)

method

filter

src/pooka/dict.pooka:166

filter(keep: fn(k, v) -> Bool) -> Dict(k, v)

INFERREDfn(fn(k, v) -> Bool) -> pooka/dict.Dict(k, v)

Keep pairs whose key-and-value predicate returns True.

import pooka/dict

assert dict.from_list([#("oak", 1)]).filter(fn(_, value) { value > 1 }).is_empty()

method

fold

src/pooka/dict.pooka:182

fold(initial: b, step: fn(b, k, v) -> b) -> b

INFERREDfn(a, fn(a, k, v) -> a) -> a

Fold with accumulator, key and value. Entry order is unspecified.

import pooka/dict

assert dict.from_list([#("oak", 2)]).fold(0, fn(acc, _, value) { acc + value }) == 2

method

equals

src/pooka/dict.pooka:196

equals(right: Dict(k, v)) -> Bool

INFERREDfn(pooka/dict.Dict(k, v)) -> Bool

Compare keys and values, independent of storage closure identity.

import pooka/dict

assert dict.from_list([#("oak", 1)]).equals(dict.from_list([#("oak", 1)]))

method

merge

src/pooka/dict.pooka:210

merge(right: Dict(k, v)) -> Dict(k, v)

INFERREDfn(pooka/dict.Dict(k, v)) -> pooka/dict.Dict(k, v)

Merge dictionaries, taking the right-hand value for a shared key.

import pooka/dict

assert dict.from_list([#("oak", 1)]).merge(dict.from_list([#("oak", 2)])).get("oak") == Some(2)

function

empty

src/pooka/dict.pooka:224

empty() -> Dict(k, v)

INFERREDfn() -> pooka/dict.Dict(a, b)

Open an empty typed dictionary.

import pooka/dict

assert dict.empty().is_empty()

function

from_list

src/pooka/dict.pooka:235

from_list(pairs: List(#(k, v))) -> Dict(k, v)

INFERREDfn(List(#(a, b))) -> pooka/dict.Dict(a, b)

Build a dictionary from pairs. For repeated keys, the last pair wins.

import pooka/dict

assert dict.from_list([#("oak", 1), #("oak", 2)]).get("oak") == Some(2)