Zafu/Collection/HashMap

source code:

• src/Zafu/Collection/HashMap.bosatsu

public dependencies: Zafu/Abstract/Eq, Zafu/Abstract/Hash

Index

• Types: HashMap
• Values: alter, contains_key, difference, difference_assume_same_hash, empty, eq, filter, from_List, get, get_or, hash, intersection_with, is_empty, map_hash_key, map_values, partition, remove, singleton, size, transform, union_with, union_with_assume_same_hash, updated

Types

HashMap[k, v]

type HashMap[k: *, v: +*]

Values

alter

Unified insert/update/remove operation.

references: HashMap, Option

def alter[a, b](map: HashMap[a, b], key: a, fn: Option[b] -> Option[b]) -> HashMap[a, b]

contains_key

True when key is present.

references: Bool, HashMap

def contains_key[a, b](map: HashMap[a, b], key: a) -> Bool

difference

Removes keys from left that appear in right (always using left semantics).

references: HashMap

def difference[a, b, c](left: HashMap[a, b], right: HashMap[a, c]) -> HashMap[a, b]

difference_assume_same_hash

Fast path difference when caller knows both maps share key hash semantics.

references: HashMap

def difference_assume_same_hash[a, b, c](left: HashMap[a, b], right: HashMap[a, c]) -> HashMap[a, b]

empty

Empty map for a chosen key hash/equality dictionary.

references: HashMap, Zafu/Abstract/Hash::Hash

def empty[a, b](hash_key: Zafu/Abstract/Hash::Hash[a]) -> HashMap[a, b]

eq

Equality adapter for maps.

references: HashMap, Zafu/Abstract/Eq::Eq

def eq[a, b](eq_value: Zafu/Abstract/Eq::Eq[a]) -> Zafu/Abstract/Eq::Eq[HashMap[b, a]]

filter

Keep only entries satisfying pred.

references: Bool, HashMap

def filter[a, b](map: HashMap[a, b], pred: (a, b) -> Bool) -> HashMap[a, b]

from_List

Builds a map from pairs using last-write-wins for duplicate keys.

references: HashMap, List, Tuple2, Zafu/Abstract/Hash::Hash

def from_List[a, b](hash_key: Zafu/Abstract/Hash::Hash[a], items: List[(a, b)]) -> HashMap[a, b]

get

Returns value for key when present.

references: HashMap, Option

def get[a, b](map: HashMap[a, b], key: a) -> Option[b]

get_or

Returns value for key or evaluates fallback when absent.

references: HashMap, Unit

def get_or[a, b](map: HashMap[a, b], key: a, on_missing: () -> b) -> b

hash

Hash adapter for maps.

references: HashMap, Zafu/Abstract/Hash::Hash

def hash[a, b](hash_value: Zafu/Abstract/Hash::Hash[a]) -> Zafu/Abstract/Hash::Hash[HashMap[b, a]]

intersection_with

Builds values for keys present in both maps.

references: HashMap

def intersection_with[a,
    b,
    c,
    d](left: HashMap[a, b], right: HashMap[a, c], combine: (a, b, c) -> d) -> HashMap[a, d]

is_empty

True if map has no entries.

references: Bool, HashMap

def is_empty[a, b](map: HashMap[a, b]) -> Bool

map_hash_key

references: HashMap, Zafu/Abstract/Hash::Hash

def map_hash_key[a, b](map: HashMap[a, b]) -> Zafu/Abstract/Hash::Hash[a]

map_values

Value-only map transform.

references: HashMap

def map_values[a, b, c](map: HashMap[a, b], fn: b -> c) -> HashMap[a, c]

partition

Splits map by predicate.

references: Bool, HashMap, Tuple2

def partition[a, b](map: HashMap[a, b], pred: (a, b) -> Bool) -> (HashMap[a, b], HashMap[a, b])

remove

Removes one key when present.

references: HashMap

def remove[a, b](map: HashMap[a, b], key: a) -> HashMap[a, b]

singleton

Single-item map.

references: HashMap, Zafu/Abstract/Hash::Hash

def singleton[a, b](hash_key: Zafu/Abstract/Hash::Hash[a], key: a, value: b) -> HashMap[a, b]

size

O(1) cached size.

references: HashMap, Int

def size[a, b](map: HashMap[a, b]) -> Int

transform

Shape-preserving key/value transform without key rehashing.

references: HashMap

def transform[a, b, c](map: HashMap[a, b], fn: (a, b) -> c) -> HashMap[a, c]

union_with

Safe union that always uses left-map key semantics.

references: HashMap

def union_with[a,
    b](left: HashMap[a, b], right: HashMap[a, b], resolve: (a, b, b) -> b) -> HashMap[a, b]

union_with_assume_same_hash

Fast path union when caller knows both maps share key hash semantics.

references: HashMap

def union_with_assume_same_hash[a,
    b](left: HashMap[a, b], right: HashMap[a, b], resolve: (a, b, b) -> b) -> HashMap[a, b]

updated

Inserts/replaces one key/value.

references: HashMap

def updated[a, b](map: HashMap[a, b], key: a, value: b) -> HashMap[a, b]