pyfect-dev 0.1.0__py3-none-any.whl

pyfect/hash_map.py

@@ -0,0 +1,317 @@
+"""``HashMap[K, V]``: an immutable map whose keys compare as Effect's
+``Equal.equals`` does (Effect's ``HashMap``).
+
+A ``dict`` keys by ``==`` and ``hash``: it calls ``1`` and ``True`` one key,
+a NaN never equal to itself and a list or dict unhashable. A ``HashMap``
+keys by ``pyfect._equal.equal_key``: ``True`` stays apart from ``1``, NaN
+finds NaN, and lists, tuples, dicts and sets are keys by their items::
+
+    m = HashMap.make((["a", 1], "x"), (True, "y"))
+    m.get(["a", 1])    # Some("x")
+    m.get(1)           # None
+    m2 = m.set(1, "z") # a new map; m is unchanged
+
+Every update returns a new map and leaves the old one as it was. Like
+Effect's, the map is a persistent hash array mapped trie (``pyfect._hamt``):
+an update copies about ``log32(size)`` nodes and shares the rest.
+Iteration yields ``(key, value)`` pairs in hash order, Effect's order: keys
+are hashed with Effect's ``Hash.hash`` (``pyfect._effect_hash``).
+The ``hash`` arguments of ``get_hash`` / ``has_hash`` / ``modify_hash`` are
+accepted for Effect's API and not needed: keys are found by value.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import Any, TypeIs, cast, overload
+
+from pyfect import _hamt
+from pyfect._equal import equal_key, equals
+from pyfect._hamt import Entry, Node
+from pyfect._unsubscripted import Unsubscripted
+from pyfect.option import Option, Some
+from pyfect.result import Ok, Result
+
+
+class HashMap[K = Unsubscripted, V = Unsubscripted]:
+    """Build one with ``HashMap.empty()``, ``HashMap.make(*entries)`` or
+    ``HashMap.from_iterable(entries)``."""
+
+    __slots__ = ("_mutable", "_root", "_size")
+
+    _root: Node | None
+    _size: int
+    _mutable: bool
+
+    def __init__(self, root: Node | None = None, size: int = 0) -> None:
+        self._root = root
+        self._size = size
+        self._mutable = False
+
+    # --- constructors -------------------------------------------------------------
+
+    @classmethod
+    def empty(cls) -> HashMap[K, V]:
+        """Spelled ``HashMap[str, int].empty()``."""
+        return HashMap()
+
+    @overload
+    @classmethod
+    def make[K2, V2](
+        cls: type[HashMap[Unsubscripted, Unsubscripted]], *entries: tuple[K2, V2]
+    ) -> HashMap[K2, V2]: ...
+    @overload
+    @classmethod
+    def make(cls, *entries: tuple[K, V]) -> HashMap[K, V]: ...
+    @classmethod
+    def make[K2, V2](cls, *entries: tuple[K2, V2]) -> HashMap[K2, V2]:
+        return HashMap.from_iterable(entries)
+
+    @overload
+    @classmethod
+    def from_iterable[K2, V2](
+        cls: type[HashMap[Unsubscripted, Unsubscripted]], entries: Iterable[tuple[K2, V2]]
+    ) -> HashMap[K2, V2]: ...
+    @overload
+    @classmethod
+    def from_iterable(cls, entries: Iterable[tuple[K, V]]) -> HashMap[K, V]: ...
+    @classmethod
+    def from_iterable[K2, V2](cls, entries: Iterable[tuple[K2, V2]]) -> HashMap[K2, V2]:
+        """The map of ``entries``; a later value for an equal key wins, and
+        the first key is kept."""
+        return HashMap[K2, V2]().set_many(entries)
+
+    # --- reading ------------------------------------------------------------------
+
+    def _entries(self) -> Iterator[Entry[K, V]]:
+        return cast("Iterator[Entry[K, V]]", _hamt.entries(self._root))
+
+    def _find(self, key: object) -> Entry[K, V] | None:
+        ident = equal_key(key)
+        found = _hamt.find(self._root, _hamt.hash_of(ident), ident)
+        return cast("Entry[K, V] | None", found)
+
+    def __len__(self) -> int:
+        return self._size
+
+    def __bool__(self) -> bool:
+        return self._size > 0
+
+    def __iter__(self) -> Iterator[tuple[K, V]]:
+        return ((e.key, e.value) for e in self._entries())
+
+    def __contains__(self, key: object) -> bool:
+        return self.has(key)
+
+    def __getitem__(self, key: K) -> V:
+        found = self._find(key)
+        if found is None:
+            raise KeyError(key)
+        return found.value
+
+    def is_empty(self) -> bool:
+        return self._size == 0
+
+    def get(self, key: object) -> Option[V]:
+        """``Some(value)`` for ``key``, or ``None``."""
+        found = self._find(key)
+        return None if found is None else Some(found.value)
+
+    def get_hash(self, key: object, hash: int) -> Option[V]:
+        return self.get(key)
+
+    def get_unsafe(self, key: object) -> V:
+        """The value for ``key``; raises ``KeyError`` without one."""
+        found = self._find(key)
+        if found is None:
+            raise KeyError("HashMap.getUnsafe: key not found")
+        return found.value
+
+    def has(self, key: object) -> bool:
+        return self._find(key) is not None
+
+    def has_hash(self, key: object, hash: int) -> bool:
+        return self.has(key)
+
+    def has_by(self, predicate: Callable[[V, K], bool]) -> bool:
+        """Whether an entry satisfies ``predicate(value, key)``."""
+        return any(predicate(e.value, e.key) for e in self._entries())
+
+    def keys(self) -> Iterator[K]:
+        return (e.key for e in self._entries())
+
+    def values(self) -> Iterator[V]:
+        return (e.value for e in self._entries())
+
+    def to_values(self) -> list[V]:
+        return list(self.values())
+
+    def entries(self) -> Iterator[tuple[K, V]]:
+        return iter(self)
+
+    def to_entries(self) -> list[tuple[K, V]]:
+        return list(self)
+
+    def find_first(self, predicate: Callable[[V, K], bool]) -> Option[tuple[K, V]]:
+        """The first entry satisfying ``predicate(value, key)``."""
+        for e in self._entries():
+            if predicate(e.value, e.key):
+                return Some((e.key, e.value))
+        return None
+
+    def some(self, predicate: Callable[[V, K], bool]) -> bool:
+        return self.has_by(predicate)
+
+    def every(self, predicate: Callable[[V, K], bool]) -> bool:
+        return all(predicate(e.value, e.key) for e in self._entries())
+
+    def reduce[Z](self, zero: Z, f: Callable[[Z, V, K], Z]) -> Z:
+        out = zero
+        for e in self._entries():
+            out = f(out, e.value, e.key)
+        return out
+
+    def for_each(self, f: Callable[[V, K], object]) -> None:
+        for e in self._entries():
+            f(e.value, e.key)
+
+    # --- updates --------------------------------------------------------------------
+
+    def _with(self, root: Node | None, size: int) -> HashMap[K, V]:
+        if root is self._root:
+            return self
+        if self._mutable:
+            self._root, self._size = root, size
+            return self
+        return HashMap(root, size)
+
+    def set(self, key: K, value: V) -> HashMap[K, V]:
+        """The map with ``key`` set to ``value``; the same map when ``key``
+        already holds this value (``Object.is``: ``pyfect._js.same_value``).
+        An equal key already there is kept."""
+        ident = equal_key(key)
+        hash = _hamt.hash_of(ident)
+        added = _hamt.find(self._root, hash, ident) is None
+        root = _hamt.insert(self._root, Entry(hash, ident, key, value))
+        return self._with(root, self._size + added)
+
+    def set_many(self, entries: Iterable[tuple[K, V]]) -> HashMap[K, V]:
+        root, size = self._root, self._size
+        for key, value in entries:
+            ident = equal_key(key)
+            hash = _hamt.hash_of(ident)
+            size += _hamt.find(root, hash, ident) is None
+            root = _hamt.insert(root, Entry(hash, ident, key, value))
+        return self._with(root, size)
+
+    def remove(self, key: K) -> HashMap[K, V]:
+        """The map without ``key``; the same map when it has no ``key``."""
+        return self.remove_many((key,))
+
+    def remove_many(self, keys: Iterable[K]) -> HashMap[K, V]:
+        root, size = self._root, self._size
+        for key in keys:
+            ident = equal_key(key)
+            smaller = _hamt.remove(root, _hamt.hash_of(ident), ident)
+            size -= smaller is not root
+            root = smaller
+        return self._with(root, size)
+
+    def modify_at(self, key: K, f: Callable[[Option[V]], Option[V]]) -> HashMap[K, V]:
+        """Set, keep or remove ``key`` by what ``f`` makes of its current
+        value: ``Some(new)`` sets it, ``None`` removes it."""
+        match f(self.get(key)):
+            case Some(value):
+                return self.set(key, value)
+            case None:
+                return self.remove(key)
+
+    def modify_hash(self, key: K, hash: int, f: Callable[[Option[V]], Option[V]]) -> HashMap[K, V]:
+        return self.modify_at(key, f)
+
+    def modify(self, key: K, f: Callable[[V], V]) -> HashMap[K, V]:
+        """The map with ``key``'s value replaced by ``f(value)``; the same
+        map without ``key``."""
+        found = self._find(key)
+        return self if found is None else self.set(found.key, f(found.value))
+
+    def union[K1, V1](self, that: HashMap[K1, V1]) -> HashMap[K | K1, V | V1]:
+        """Both maps' entries; ``that``'s value wins for an equal key."""
+        return HashMap[K | K1, V | V1](self._root, self._size).set_many(that)
+
+    def _rebuilt[A](self, pairs: Iterable[tuple[K, A]]) -> HashMap[K, A]:
+        return HashMap[K, A]().set_many(pairs)
+
+    def map[A](self, f: Callable[[V, K], A]) -> HashMap[K, A]:
+        return self._rebuilt((e.key, f(e.value, e.key)) for e in list(self._entries()))
+
+    def flat_map[A](self, f: Callable[[V, K], HashMap[K, A]]) -> HashMap[K, A]:
+        """The union of ``f(value, key)`` for every entry."""
+        return self._rebuilt(pair for e in list(self._entries()) for pair in f(e.value, e.key))
+
+    @overload
+    def filter[B](self, predicate: Callable[[V, K], TypeIs[B]]) -> HashMap[K, B]: ...
+    @overload
+    def filter(self, predicate: Callable[[V, K], bool]) -> HashMap[K, V]: ...
+    def filter(self, predicate: Callable[[V, K], bool]) -> HashMap[K, Any]:
+        return self._rebuilt((e.key, e.value) for e in self._entries() if predicate(e.value, e.key))
+
+    def filter_map[A](self, f: Callable[[V, K], Result[A, object]]) -> HashMap[K, A]:
+        """The entries ``f(value, key)`` keeps (``Ok``), with its values."""
+
+        def kept() -> Iterator[tuple[K, A]]:
+            for e in self._entries():
+                result = f(e.value, e.key)
+                if isinstance(result, Ok):
+                    yield e.key, result.value
+
+        return self._rebuilt(kept())
+
+    def compact[A](self: HashMap[K, Option[A]]) -> HashMap[K, A]:
+        """The ``Some`` values, unwrapped."""
+        return self._rebuilt(
+            (e.key, e.value.value) for e in self._entries() if isinstance(e.value, Some)
+        )
+
+    # --- batched updates --------------------------------------------------------------
+
+    def begin_mutation(self) -> HashMap[K, V]:
+        """A copy whose ``set`` / ``remove`` / ... update it in place (and
+        return it) until ``end_mutation``."""
+        out = HashMap[K, V](self._root, self._size)
+        out._mutable = True
+        return out
+
+    def end_mutation(self) -> HashMap[K, V]:
+        """Freeze a map from ``begin_mutation``; returns the same map."""
+        self._mutable = False
+        return self
+
+    def mutate(self, f: Callable[[HashMap[K, V]], object]) -> HashMap[K, V]:
+        """A new map: a mutable copy of this one after ``f`` has updated it."""
+        draft = self.begin_mutation()
+        f(draft)
+        return draft.end_mutation()
+
+    # --- equality -------------------------------------------------------------------
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HashMap):
+            return NotImplemented
+        theirs = cast("HashMap[object, object]", other)
+        if self._size != theirs._size:
+            return False
+        for e in self._entries():
+            found = _hamt.find(theirs._root, e.hash, e.ident)
+            if found is None or not equals(e.value, found.value):
+                return False
+        return True
+
+    def __hash__(self) -> int:
+        return hash(frozenset((e.ident, equal_key(e.value)) for e in self._entries()))
+
+    def __repr__(self) -> str:
+        return f"HashMap({self.to_entries()!r})"
+
+
+__all__ = ["HashMap"]

pyfect/hash_ring.py

@@ -0,0 +1,206 @@
+"""Consistent hashing (Effect's ``HashRing``): nodes named by their
+``primary_key()`` placed on a ring of virtual points, ``base_weight`` points
+per unit of weight::
+
+    ring = HashRing[Runner]()
+    ring.add(runner_a)
+    ring.add(runner_b, weight=2)
+    ring.get("user-1")        # the node nearest the input's hash
+    ring.get_shards(300)      # a balanced node for each of 300 shards
+
+Hashes are Effect's ``Hash.string``, so the same nodes give the same
+assignment as Effect's ring.
+
+``get`` is only as even as the node keys hash: with short keys such as ``a``
+and ``b``, 600 inputs ``job-0`` to ``job-599`` split 97 / 503 (Effect's ring
+gives the same counts). For an even split, hash each input to one of a fixed
+number of shards and place the shards with ``get_shards``, as the cluster
+does.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterable, Iterator
+
+from pyfect import _js as js
+from pyfect._js import js_sort_key
+from pyfect._string_hash import string_hash
+from pyfect.primary_key import PrimaryKey
+
+_shard_hashes: list[int] = []
+"""``Hash.string(f"shard-{i}")`` for each shard index seen so far."""
+
+
+def _shard_hash(shard: int) -> int:
+    while len(_shard_hashes) <= shard:
+        _shard_hashes.append(string_hash(f"shard-{len(_shard_hashes)}"))
+    return _shard_hashes[shard]
+
+
+def _js_round(x: float) -> int:
+    return int(js.round(x))
+
+
+def _normalize_count(n: float) -> int:
+    return math.floor(n) if n > 0 else 0
+
+
+class HashRing[A: PrimaryKey]:
+    """A mutable ring of nodes. ``base_weight`` (at least 1) is the number
+    of virtual points per unit of weight."""
+
+    __slots__ = ("_base_weight", "_nodes", "_ring", "_total_weight")
+
+    def __init__(self, *, base_weight: int = 128) -> None:
+        self._base_weight = max(base_weight, 1)
+        self._total_weight = 0.0
+        self._nodes: dict[str, tuple[A, float]] = {}
+        self._ring: list[tuple[int, str]] = []
+
+    @property
+    def base_weight(self) -> int:
+        return self._base_weight
+
+    def __iter__(self) -> Iterator[A]:
+        return (node for node, _ in self._nodes.values())
+
+    def __len__(self) -> int:
+        return len(self._nodes)
+
+    def __repr__(self) -> str:
+        return f"HashRing(base_weight={self._base_weight}, nodes={list(self)!r})"
+
+    def add_many(self, nodes: Iterable[A], *, weight: float = 1) -> None:
+        """Add ``nodes`` with ``weight`` (at least 0.1). A node whose key is
+        already there replaces the stored node and takes the new weight."""
+        weight = max(weight, 0.1)
+        keys: list[str] = []
+        reweighted: set[str] = set()
+        for node in nodes:
+            key = node.primary_key()
+            entry = self._nodes.get(key)
+            self._nodes[key] = (node, weight)
+            if entry is not None:
+                if entry[1] == weight:
+                    continue
+                reweighted.add(key)
+            keys.append(key)
+        if reweighted:
+            self._ring = [point for point in self._ring if point[1] not in reweighted]
+        self._add_points(keys, _js_round(weight * self._base_weight))
+        self._update_total_weight()
+
+    def add(self, node: A, *, weight: float = 1) -> None:
+        """``add_many([node], weight=weight)``."""
+        self.add_many([node], weight=weight)
+
+    def remove(self, node: A) -> None:
+        """Remove the node with ``node``'s key, if there is one."""
+        key = node.primary_key()
+        if self._nodes.pop(key, None) is not None:
+            self._ring = [point for point in self._ring if point[1] != key]
+            self._update_total_weight()
+
+    def has(self, node: A) -> bool:
+        """Whether a node with ``node``'s key is on the ring."""
+        return node.primary_key() in self._nodes
+
+    def get(self, input: str) -> A | None:
+        """The node nearest ``input``'s hash; ``None`` on an empty ring.
+
+        Only as even as the node keys hash, so short keys can split inputs
+        very unevenly; ``get_shards`` with a shard per input is balanced."""
+        if not self._ring:
+            return None
+        index = self._index_for(string_hash(input), None)[0]
+        return self._nodes[self._ring[index][1]][0]
+
+    def get_shards(self, count: float) -> list[A] | None:
+        """A node for each of ``count`` shards (floored; at most zero is
+        none), no node taking more than its share of the weight while
+        another has room; ``None`` on an empty ring."""
+        if not self._ring:
+            return None
+        count = _normalize_count(count)
+        shards: list[A | None] = [None] * count
+        allocations: dict[str, int] = {}
+        remaining: dict[int, None] = {}
+        exclude: set[str] = set()
+
+        distances: list[tuple[int, str, int]] = []
+        for shard in range(count):
+            index, distance = self._index_for(_shard_hash(shard), None)
+            distances.append((shard, self._ring[index][1], distance))
+            remaining[shard] = None
+        distances.sort(key=lambda entry: entry[2])
+        for shard, key, _ in distances:
+            if key in exclude:
+                continue
+            value, weight = self._nodes[key]
+            shards[shard] = value
+            del remaining[shard]
+            if self._allocate(allocations, key, weight, count):
+                exclude.add(key)
+
+        all_at_max = len(exclude) == len(self._nodes)
+        for shard in remaining:
+            index = self._index_for(_shard_hash(shard), None if all_at_max else exclude)[0]
+            key = self._ring[index][1]
+            value, weight = self._nodes[key]
+            shards[shard] = value
+            if all_at_max:
+                continue
+            if self._allocate(allocations, key, weight, count):
+                exclude.add(key)
+                all_at_max = len(exclude) == len(self._nodes)
+        return [shard for shard in shards if shard is not None]
+
+    def _allocate(self, allocations: dict[str, int], key: str, weight: float, count: int) -> bool:
+        """Count one more shard for ``key``; whether it reached its share."""
+        allocations[key] = allocations.get(key, 0) + 1
+        max_per_node = max(1, math.floor(count * (weight / self._total_weight)))
+        return allocations[key] >= max_per_node
+
+    def _add_points(self, keys: list[str], weight: int) -> None:
+        for i in range(weight, 0, -1):
+            for key in keys:
+                self._ring.append((string_hash(f"{key}:{i}"), key))
+        # Ties broken by node key, so the ring does not depend on insertion order.
+        self._ring.sort(key=lambda point: (point[0], js_sort_key(point[1])))
+
+    def _update_total_weight(self) -> None:
+        # Summed in key order, so the total does not depend on history.
+        total = 0.0
+        for key in sorted(self._nodes, key=js_sort_key):
+            total += self._nodes[key][1]
+        self._total_weight = total
+
+    def _index_for(self, hash: int, exclude: set[str] | None) -> tuple[int, int]:
+        ring = self._ring
+        length = len(ring)
+        lo, hi = 0, length - 1
+        while lo <= hi:
+            mid = (lo + hi) // 2
+            if ring[mid][0] >= hash:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        a = lo - 1 if lo == length else lo
+        dist_a = abs(ring[a][0] - hash)
+        if exclude is None:
+            b = lo - 1
+            if b < 0:
+                return a, dist_a
+            dist_b = abs(ring[b][0] - hash)
+            return (a, dist_a) if dist_a <= dist_b else (b, dist_b)
+        if ring[a][1] not in exclude:
+            return a, dist_a
+        for i in range(1, max(lo, length - lo) + 1):
+            for index in (lo - i, lo + i):
+                if 0 <= index < length and ring[index][1] not in exclude:
+                    return index, abs(ring[index][0] - hash)
+        return a, dist_a
+
+
+__all__ = ["HashRing"]

pyfect/hash_set.py

@@ -0,0 +1,163 @@
+"""``HashSet[A]``: an immutable set whose members compare as Effect's
+``Equal.equals`` does (Effect's ``HashSet``).
+
+A ``frozenset`` calls ``1`` and ``True`` one member and cannot hold a list;
+a ``HashSet`` keys members by ``pyfect._equal.equal_key``: ``True`` stays
+apart from ``1``, NaN is one member, and lists, tuples, dicts and sets are
+members by their items. Updates return a new set, or the same set when
+nothing changes; like Effect's, it is a persistent hash array mapped trie
+(``pyfect._hamt``), so an update costs about ``log32(size)``. Iteration
+follows Effect's hashes (``pyfect._effect_hash``), in Effect's order.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable, Iterable, Iterator
+from typing import Any, TypeIs, cast, overload
+
+from pyfect import _hamt
+from pyfect._equal import equal_key
+from pyfect._hamt import Entry, Node
+from pyfect._unsubscripted import Unsubscripted
+
+
+class HashSet[A = Unsubscripted]:
+    """Build one with ``HashSet.empty()``, ``HashSet.make(*values)`` or
+    ``HashSet.from_iterable(values)``."""
+
+    __slots__ = ("_root", "_size")
+
+    _root: Node | None
+    _size: int
+
+    def __init__(self, root: Node | None = None, size: int = 0) -> None:
+        self._root = root
+        self._size = size
+
+    @classmethod
+    def empty(cls) -> HashSet[A]:
+        """Spelled ``HashSet[str].empty()``."""
+        return HashSet()
+
+    @overload
+    @classmethod
+    def make[B](cls: type[HashSet[Unsubscripted]], *values: B) -> HashSet[B]: ...
+    @overload
+    @classmethod
+    def make(cls, *values: A) -> HashSet[A]: ...
+    @classmethod
+    def make[B](cls, *values: B) -> HashSet[B]:
+        return HashSet.from_iterable(values)
+
+    @overload
+    @classmethod
+    def from_iterable[B](cls: type[HashSet[Unsubscripted]], values: Iterable[B]) -> HashSet[B]: ...
+    @overload
+    @classmethod
+    def from_iterable(cls, values: Iterable[A]) -> HashSet[A]: ...
+    @classmethod
+    def from_iterable[B](cls, values: Iterable[B]) -> HashSet[B]:
+        """The set of ``values``; the first of equal values is kept."""
+        return HashSet[B]()._added(values)
+
+    def _entries(self) -> Iterator[Entry[A, None]]:
+        return cast("Iterator[Entry[A, None]]", _hamt.entries(self._root))
+
+    def _has_ident(self, ident: Hashable) -> bool:
+        return _hamt.find(self._root, _hamt.hash_of(ident), ident) is not None
+
+    def _added[B](self, values: Iterable[B]) -> HashSet[A | B]:
+        root, size = self._root, self._size
+        for value in values:
+            ident = equal_key(value)
+            hash = _hamt.hash_of(ident)
+            if _hamt.find(root, hash, ident) is None:
+                root = _hamt.insert(root, Entry(hash, ident, value, None))
+                size += 1
+        return cast("HashSet[A | B]", self) if root is self._root else HashSet(root, size)
+
+    def __len__(self) -> int:
+        return self._size
+
+    def __bool__(self) -> bool:
+        return self._size > 0
+
+    def __iter__(self) -> Iterator[A]:
+        return (e.key for e in self._entries())
+
+    def __contains__(self, value: object) -> bool:
+        return self.has(value)
+
+    def is_empty(self) -> bool:
+        return self._size == 0
+
+    def has(self, value: object) -> bool:
+        return self._has_ident(equal_key(value))
+
+    def add(self, value: A) -> HashSet[A]:
+        """The set with ``value``; the same set when it has it already."""
+        return self._added((value,))
+
+    def remove(self, value: A) -> HashSet[A]:
+        """The set without ``value``; the same set when it lacks it."""
+        ident = equal_key(value)
+        root = _hamt.remove(self._root, _hamt.hash_of(ident), ident)
+        return self if root is self._root else HashSet(root, self._size - 1)
+
+    def union[B](self, that: HashSet[B]) -> HashSet[A | B]:
+        return self._added(that)
+
+    def _kept(self, keep: Callable[[Entry[A, None]], bool]) -> HashSet[A]:
+        return HashSet[A]()._added(e.key for e in self._entries() if keep(e))
+
+    def intersection(self, that: HashSet[Any]) -> HashSet[A]:
+        """The members of this set that ``that`` has too."""
+        return self._kept(lambda e: that._has_ident(e.ident))
+
+    def difference(self, that: HashSet[Any]) -> HashSet[A]:
+        """The members of this set that ``that`` lacks."""
+        return self._kept(lambda e: not that._has_ident(e.ident))
+
+    def is_subset(self, that: HashSet[Any]) -> bool:
+        """Whether ``that`` has every member of this set."""
+        return all(that._has_ident(e.ident) for e in self._entries())
+
+    def map[B](self, f: Callable[[A], B]) -> HashSet[B]:
+        """``f`` of every member; equal results are kept once."""
+        return HashSet.from_iterable(f(v) for v in list(self))
+
+    @overload
+    def filter[B](self, predicate: Callable[[A], TypeIs[B]]) -> HashSet[B]: ...
+    @overload
+    def filter(self, predicate: Callable[[A], bool]) -> HashSet[A]: ...
+    def filter(self, predicate: Callable[[A], bool]) -> HashSet[Any]:
+        return self._kept(lambda e: predicate(e.key))
+
+    def some(self, predicate: Callable[[A], bool]) -> bool:
+        return any(predicate(v) for v in self)
+
+    def every(self, predicate: Callable[[A], bool]) -> bool:
+        return all(predicate(v) for v in self)
+
+    def reduce[Z](self, zero: Z, f: Callable[[Z, A], Z]) -> Z:
+        out = zero
+        for v in self:
+            out = f(out, v)
+        return out
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HashSet):
+            return NotImplemented
+        theirs = cast("HashSet[object]", other)
+        return self._size == theirs._size and all(
+            theirs._has_ident(e.ident) for e in self._entries()
+        )
+
+    def __hash__(self) -> int:
+        return hash(frozenset(e.ident for e in self._entries()))
+
+    def __repr__(self) -> str:
+        return f"HashSet({list(self)!r})"
+
+
+__all__ = ["HashSet"]