dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/iterables.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import builtins
-import datetime as dt
 from collections import Counter
 from collections.abc import (
     Callable,
@@ -19,14 +18,12 @@ from enum import Enum
 from functools import cmp_to_key, partial, reduce
 from itertools import accumulate, chain, groupby, islice, pairwise, product
 from math import isnan
-from operator import add, itemgetter, or_
+from operator import add, or_
 from typing import (
     TYPE_CHECKING,
     Any,
-    Generic,
     Literal,
     TypeGuard,
-    TypeVar,
     assert_never,
     cast,
     overload,
@@ -34,7 +31,6 @@ from typing import (
 )
 
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_hashable, ensure_not_none, ensure_str
 from utilities.math import (
     _CheckIntegerEqualError,
     _CheckIntegerEqualOrApproxError,
@@ -43,58 +39,35 @@ from utilities.math import (
     check_integer,
 )
 from utilities.reprlib import get_repr
-from utilities.sentinel import Sentinel, sentinel
-from utilities.types import Sign, THashable, TSupportsAdd, TSupportsLT
-from utilities.zoneinfo import UTC
+from utilities.sentinel import Sentinel, is_sentinel, sentinel
+from utilities.types import SupportsAdd, SupportsLT
 
 if TYPE_CHECKING:
     from types import NoneType
 
-    from utilities.types import MaybeIterable, MaybeIterableHashable, StrMapping
-
-
-_K = TypeVar("_K")
-_T = TypeVar("_T")
-_U = TypeVar("_U")
-_V = TypeVar("_V")
-_W = TypeVar("_W")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
+    from utilities.types import MaybeIterable, Sign, StrMapping
 
 
 ##
 
 
-def always_iterable(obj: MaybeIterable[_T], /) -> Iterable[_T]:
+def always_iterable[T](obj: MaybeIterable[T], /) -> Iterable[T]:
     """Typed version of `always_iterable`."""
     obj = cast("Any", obj)
     if isinstance(obj, str | bytes):
-        return cast("list[_T]", [obj])
+        return cast("list[T]", [obj])
     try:
-        return iter(cast("Iterable[_T]", obj))
+        return iter(cast("Iterable[T]", obj))
     except TypeError:
-        return cast("list[_T]", [obj])
+        return cast("list[T]", [obj])
 
 
 ##
 
 
-def always_iterable_hashable(
-    obj: MaybeIterable[_T] | None, /
-) -> MaybeIterableHashable[_T] | None:
-    """Ensure an object is always hashable."""
-    return None if obj is None else tuple(always_iterable(obj))
-
-
-##
-
-
-def apply_bijection(
-    func: Callable[[_T], _U], iterable: Iterable[_T], /
-) -> Mapping[_T, _U]:
+def apply_bijection[T, U](
+    func: Callable[[T], U], iterable: Iterable[T], /
+) -> Mapping[T, U]:
     """Apply a function bijectively."""
     keys = list(iterable)
     try:
@@ -114,21 +87,21 @@ def apply_bijection(
 
 
 @dataclass(kw_only=True, slots=True)
-class ApplyBijectionError(Exception, Generic[_T]):
-    keys: list[_T]
-    counts: Mapping[_T, int]
+class ApplyBijectionError[T](Exception):
+    keys: list[T]
+    counts: Mapping[T, int]
 
 
 @dataclass(kw_only=True, slots=True)
-class _ApplyBijectionDuplicateKeysError(ApplyBijectionError[_T]):
+class _ApplyBijectionDuplicateKeysError[T](ApplyBijectionError[T]):
     @override
     def __str__(self) -> str:
         return f"Keys {get_repr(self.keys)} must not contain duplicates; got {get_repr(self.counts)}"
 
 
 @dataclass(kw_only=True, slots=True)
-class _ApplyBijectionDuplicateValuesError(ApplyBijectionError[_T], Generic[_T, _U]):
-    values: list[_U]
+class _ApplyBijectionDuplicateValuesError[T, U](ApplyBijectionError[T]):
+    values: list[U]
 
     @override
     def __str__(self) -> str:
@@ -138,7 +111,7 @@ class _ApplyBijectionDuplicateValuesError(ApplyBijectionError[_T], Generic[_T, _
 ##
 
 
-def apply_to_tuple(func: Callable[..., _T], args: tuple[Any, ...], /) -> _T:
+def apply_to_tuple[T](func: Callable[..., T], args: tuple[Any, ...], /) -> T:
     """Apply a function to a tuple of args."""
     return apply_to_varargs(func, *args)
 
@@ -146,7 +119,7 @@ def apply_to_tuple(func: Callable[..., _T], args: tuple[Any, ...], /) -> _T:
 ##
 
 
-def apply_to_varargs(func: Callable[..., _T], *args: Any) -> _T:
+def apply_to_varargs[T](func: Callable[..., T], *args: Any) -> T:
     """Apply a function to a variable number of arguments."""
     return func(*args)
 
@@ -155,17 +128,17 @@ def apply_to_varargs(func: Callable[..., _T], *args: Any) -> _T:
 
 
 @overload
-def chain_mappings(
-    *mappings: Mapping[_K, _V], list: Literal[True]
-) -> Mapping[_K, Sequence[_V]]: ...
+def chain_mappings[K, V](
+    *mappings: Mapping[K, V], list: Literal[True]
+) -> Mapping[K, Sequence[V]]: ...
 @overload
-def chain_mappings(
-    *mappings: Mapping[_K, _V], list: bool = False
-) -> Mapping[_K, Iterable[_V]]: ...
-def chain_mappings(
-    *mappings: Mapping[_K, _V],
+def chain_mappings[K, V](
+    *mappings: Mapping[K, V], list: bool = False
+) -> Mapping[K, Iterable[V]]: ...
+def chain_mappings[K, V](
+    *mappings: Mapping[K, V],
     list: bool = False,  # noqa: A002
-) -> Mapping[_K, Iterable[_V]]:
+) -> Mapping[K, Iterable[V]]:
     """Chain the values of a set of mappings."""
     try:
         first, *rest = mappings
@@ -178,9 +151,9 @@ def chain_mappings(
     return reduced
 
 
-def _chain_mappings_one(
-    acc: Mapping[_K, Iterable[_V]], el: Mapping[_K, _V], /
-) -> Mapping[_K, Iterable[_V]]:
+def _chain_mappings_one[K, V](
+    acc: Mapping[K, Iterable[V]], el: Mapping[K, V], /
+) -> Mapping[K, Iterable[V]]:
     """Chain the values of a set of mappings."""
     out = dict(acc)
     for key, value in el.items():
@@ -191,7 +164,7 @@ def _chain_mappings_one(
 ##
 
 
-def chain_maybe_iterables(*maybe_iterables: MaybeIterable[_T]) -> Iterable[_T]:
+def chain_maybe_iterables[T](*maybe_iterables: MaybeIterable[T]) -> Iterable[T]:
     """Chain a set of maybe iterables."""
     iterables = map(always_iterable, maybe_iterables)
     return chain.from_iterable(iterables)
@@ -200,7 +173,7 @@ def chain_maybe_iterables(*maybe_iterables: MaybeIterable[_T]) -> Iterable[_T]:
 ##
 
 
-def chain_nullable(*maybe_iterables: Iterable[_T | None] | None) -> Iterable[_T]:
+def chain_nullable[T](*maybe_iterables: Iterable[T | None] | None) -> Iterable[T]:
     """Chain a set of values; ignoring nulls."""
     iterables = (mi for mi in maybe_iterables if mi is not None)
     values = ((i for i in it if i is not None) for it in iterables)
@@ -219,7 +192,7 @@ def check_bijection(mapping: Mapping[Any, Hashable], /) -> None:
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckBijectionError(Exception, Generic[THashable]):
+class CheckBijectionError[THashable](Exception):
     mapping: Mapping[Any, THashable]
     counts: Mapping[THashable, int]
 
@@ -239,7 +212,7 @@ def check_duplicates(iterable: Iterable[Hashable], /) -> None:
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckDuplicatesError(Exception, Generic[THashable]):
+class CheckDuplicatesError[THashable](Exception):
     iterable: Iterable[THashable]
     counts: Mapping[THashable, int]
 
@@ -262,8 +235,7 @@ def check_iterables_equal(left: Iterable[Any], right: Iterable[Any], /) -> None:
             if lv != rv:
                 errors.append((i, lv, rv))
     except ValueError as error:
-        msg = ensure_str(one(error.args))
-        match msg:
+        match one(error.args):
             case "zip() argument 2 is longer than argument 1":
                 state = "right_longer"
             case "zip() argument 2 is shorter than argument 1":
@@ -282,10 +254,10 @@ type _CheckIterablesEqualState = Literal["left_longer", "right_longer"]
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckIterablesEqualError(Exception, Generic[_T]):
-    left: list[_T]
-    right: list[_T]
-    errors: list[tuple[int, _T, _T]]
+class CheckIterablesEqualError[T](Exception):
+    left: list[T]
+    right: list[T]
+    errors: list[tuple[int, T, T]]
     state: _CheckIterablesEqualState | None
 
     @override
@@ -311,7 +283,7 @@ class CheckIterablesEqualError(Exception, Generic[_T]):
                 yield "right was longer"
             case None:
                 pass
-            case _ as never:
+            case never:
                 assert_never(never)
 
 
@@ -436,12 +408,12 @@ def check_mappings_equal(left: Mapping[Any, Any], right: Mapping[Any, Any], /) -
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckMappingsEqualError(Exception, Generic[_K, _V]):
-    left: Mapping[_K, _V]
-    right: Mapping[_K, _V]
-    left_extra: AbstractSet[_K]
-    right_extra: AbstractSet[_K]
-    errors: list[tuple[_K, _V, _V]]
+class CheckMappingsEqualError[K, V](Exception):
+    left: Mapping[K, V]
+    right: Mapping[K, V]
+    left_extra: AbstractSet[K]
+    right_extra: AbstractSet[K]
+    errors: list[tuple[K, V, V]]
 
     @override
     def __str__(self) -> str:
@@ -486,11 +458,11 @@ def check_sets_equal(left: Iterable[Any], right: Iterable[Any], /) -> None:
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckSetsEqualError(Exception, Generic[_T]):
-    left: AbstractSet[_T]
-    right: AbstractSet[_T]
-    left_extra: AbstractSet[_T]
-    right_extra: AbstractSet[_T]
+class CheckSetsEqualError[T](Exception):
+    left: AbstractSet[T]
+    right: AbstractSet[T]
+    left_extra: AbstractSet[T]
+    right_extra: AbstractSet[T]
 
     @override
     def __str__(self) -> str:
@@ -533,11 +505,11 @@ def check_submapping(left: Mapping[Any, Any], right: Mapping[Any, Any], /) -> No
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckSubMappingError(Exception, Generic[_K, _V]):
-    left: Mapping[_K, _V]
-    right: Mapping[_K, _V]
-    extra: AbstractSet[_K]
-    errors: list[tuple[_K, _V, _V]]
+class CheckSubMappingError[K, V](Exception):
+    left: Mapping[K, V]
+    right: Mapping[K, V]
+    extra: AbstractSet[K]
+    errors: list[tuple[K, V, V]]
 
     @override
     def __str__(self) -> str:
@@ -572,10 +544,10 @@ def check_subset(left: Iterable[Any], right: Iterable[Any], /) -> None:
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckSubSetError(Exception, Generic[_T]):
-    left: AbstractSet[_T]
-    right: AbstractSet[_T]
-    extra: AbstractSet[_T]
+class CheckSubSetError[T](Exception):
+    left: AbstractSet[T]
+    right: AbstractSet[T]
+    extra: AbstractSet[T]
 
     @override
     def __str__(self) -> str:
@@ -604,11 +576,11 @@ def check_supermapping(left: Mapping[Any, Any], right: Mapping[Any, Any], /) ->
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckSuperMappingError(Exception, Generic[_K, _V]):
-    left: Mapping[_K, _V]
-    right: Mapping[_K, _V]
-    extra: AbstractSet[_K]
-    errors: list[tuple[_K, _V, _V]]
+class CheckSuperMappingError[K, V](Exception):
+    left: Mapping[K, V]
+    right: Mapping[K, V]
+    extra: AbstractSet[K]
+    errors: list[tuple[K, V, V]]
 
     @override
     def __str__(self) -> str:
@@ -643,10 +615,10 @@ def check_superset(left: Iterable[Any], right: Iterable[Any], /) -> None:
 
 
 @dataclass(kw_only=True, slots=True)
-class CheckSuperSetError(Exception, Generic[_T]):
-    left: AbstractSet[_T]
-    right: AbstractSet[_T]
-    extra: AbstractSet[_T]
+class CheckSuperSetError[T](Exception):
+    left: AbstractSet[T]
+    right: AbstractSet[T]
+    extra: AbstractSet[T]
 
     @override
     def __str__(self) -> str:
@@ -695,7 +667,7 @@ class _CheckUniqueModuloCaseDuplicateLowerCaseStringsError(CheckUniqueModuloCase
 ##
 
 
-def cmp_nullable(x: TSupportsLT | None, y: TSupportsLT | None, /) -> Sign:
+def cmp_nullable[T: SupportsLT](x: T | None, y: T | None, /) -> Sign:
     """Compare two nullable objects."""
     match x, y:
         case None, None:
@@ -706,14 +678,14 @@ def cmp_nullable(x: TSupportsLT | None, y: TSupportsLT | None, /) -> Sign:
             return 1
         case _, _:
             return cast("Sign", (x > y) - (x < y))
-        case _ as never:
+        case never:
             assert_never(never)
 
 
 ##
 
 
-def chunked(iterable: Iterable[_T], n: int, /) -> Iterator[Sequence[_T]]:
+def chunked[T](iterable: Iterable[T], n: int, /) -> Iterator[Sequence[T]]:
     """Break an iterable into lists of length n."""
     return iter(partial(take, n, iter(iterable)), [])
 
@@ -721,18 +693,6 @@ def chunked(iterable: Iterable[_T], n: int, /) -> Iterator[Sequence[_T]]:
 ##
 
 
-def ensure_hashables(
-    *args: Any, **kwargs: Any
-) -> tuple[list[Hashable], dict[str, Hashable]]:
-    """Ensure a set of positional & keyword arguments are all hashable."""
-    hash_args = list(map(ensure_hashable, args))
-    hash_kwargs = {k: ensure_hashable(v) for k, v in kwargs.items()}
-    return hash_args, hash_kwargs
-
-
-##
-
-
 def ensure_iterable(obj: Any, /) -> Iterable[Any]:
     """Ensure an object is iterable."""
     if is_iterable(obj):
@@ -771,10 +731,30 @@ class EnsureIterableNotStrError(Exception):
 ##
 
 
-def expanding_window(iterable: Iterable[_T], /) -> islice[list[_T]]:
+_EDGE: int = 5
+
+
+def enumerate_with_edge[T](
+    iterable: Iterable[T], /, *, start: int = 0, edge: int = _EDGE
+) -> Iterator[tuple[int, int, bool, T]]:
+    """Enumerate an iterable, with the edge items marked."""
+    as_list = list(iterable)
+    total = len(as_list)
+    indices = set(range(edge)) | set(range(total)[-edge:])
+    is_edge = (i in indices for i in range(total))
+    for (i, value), is_edge_i in zip(
+        enumerate(as_list, start=start), is_edge, strict=True
+    ):
+        yield i, total, is_edge_i, value
+
+
+##
+
+
+def expanding_window[T](iterable: Iterable[T], /) -> islice[list[T]]:
     """Yield an expanding window over an iterable."""
 
-    def func(acc: Iterable[_T], el: _T, /) -> list[_T]:
+    def func(acc: Iterable[T], el: T, /) -> list[T]:
         return list(chain(acc, [el]))
 
     return islice(accumulate(iterable, func=func, initial=[]), 1, None)
@@ -784,31 +764,31 @@ def expanding_window(iterable: Iterable[_T], /) -> islice[list[_T]]:
 
 
 @overload
-def filter_include_and_exclude(
-    iterable: Iterable[_T],
+def filter_include_and_exclude[T, U](
+    iterable: Iterable[T],
     /,
     *,
-    include: MaybeIterable[_U] | None = None,
-    exclude: MaybeIterable[_U] | None = None,
-    key: Callable[[_T], _U],
-) -> Iterable[_T]: ...
+    include: MaybeIterable[U] | None = None,
+    exclude: MaybeIterable[U] | None = None,
+    key: Callable[[T], U],
+) -> Iterable[T]: ...
 @overload
-def filter_include_and_exclude(
-    iterable: Iterable[_T],
+def filter_include_and_exclude[T](
+    iterable: Iterable[T],
     /,
     *,
-    include: MaybeIterable[_T] | None = None,
-    exclude: MaybeIterable[_T] | None = None,
-    key: Callable[[_T], Any] | None = None,
-) -> Iterable[_T]: ...
-def filter_include_and_exclude(
-    iterable: Iterable[_T],
+    include: MaybeIterable[T] | None = None,
+    exclude: MaybeIterable[T] | None = None,
+    key: Callable[[T], Any] | None = None,
+) -> Iterable[T]: ...
+def filter_include_and_exclude[T, U](
+    iterable: Iterable[T],
     /,
     *,
-    include: MaybeIterable[_U] | None = None,
-    exclude: MaybeIterable[_U] | None = None,
-    key: Callable[[_T], _U] | None = None,
-) -> Iterable[_T]:
+    include: MaybeIterable[U] | None = None,
+    exclude: MaybeIterable[U] | None = None,
+    key: Callable[[T], U] | None = None,
+) -> Iterable[T]:
     """Filter an iterable based on an inclusion/exclusion pair."""
     include, exclude = resolve_include_and_exclude(include=include, exclude=exclude)
     if include is not None:
@@ -827,35 +807,17 @@ def filter_include_and_exclude(
 ##
 
 
-def group_consecutive_integers(iterable: Iterable[int], /) -> Iterable[tuple[int, int]]:
-    """Group consecutive integers."""
-    integers = sorted(iterable)
-    for _, group in groupby(enumerate(integers), key=lambda x: x[1] - x[0]):
-        as_list = list(map(itemgetter(1), group))
-        yield as_list[0], as_list[-1]
-
-
-def ungroup_consecutive_integers(
-    iterable: Iterable[tuple[int, int]], /
-) -> Iterable[int]:
-    """Ungroup consecutive integers."""
-    return chain.from_iterable(range(start, end + 1) for start, end in iterable)
-
-
-##
-
-
 @overload
-def groupby_lists(
-    iterable: Iterable[_T], /, *, key: None = None
-) -> Iterator[tuple[_T, list[_T]]]: ...
+def groupby_lists[T](
+    iterable: Iterable[T], /, *, key: None = None
+) -> Iterator[tuple[T, list[T]]]: ...
 @overload
-def groupby_lists(
-    iterable: Iterable[_T], /, *, key: Callable[[_T], _U]
-) -> Iterator[tuple[_U, list[_T]]]: ...
-def groupby_lists(
-    iterable: Iterable[_T], /, *, key: Callable[[_T], _U] | None = None
-) -> Iterator[tuple[_T, list[_T]]] | Iterator[tuple[_U, list[_T]]]:
+def groupby_lists[T, U](
+    iterable: Iterable[T], /, *, key: Callable[[T], U]
+) -> Iterator[tuple[U, list[T]]]: ...
+def groupby_lists[T, U](
+    iterable: Iterable[T], /, *, key: Callable[[T], U] | None = None
+) -> Iterator[tuple[T, list[T]]] | Iterator[tuple[U, list[T]]]:
     """Yield consecutive keys and groups (as lists)."""
     if key is None:
         for k, group in groupby(iterable):
@@ -868,7 +830,7 @@ def groupby_lists(
 ##
 
 
-def hashable_to_iterable(obj: THashable | None, /) -> tuple[THashable, ...] | None:
+def hashable_to_iterable[T: Hashable](obj: T | None, /) -> tuple[T, ...] | None:
     """Lift a hashable singleton to an iterable of hashables."""
     return None if obj is None else (obj,)
 
@@ -904,9 +866,9 @@ def is_iterable_not_str(obj: Any, /) -> TypeGuard[Iterable[Any]]:
 ##
 
 
-def map_mapping(
-    func: Callable[[_V], _W], mapping: Mapping[_K, _V], /
-) -> Mapping[_K, _W]:
+def map_mapping[K, V, W](
+    func: Callable[[V], W], mapping: Mapping[K, V], /
+) -> Mapping[K, W]:
     """Map a function over the values of a mapping."""
     return {k: func(v) for k, v in mapping.items()}
 
@@ -914,7 +876,7 @@ def map_mapping(
 ##
 
 
-def merge_mappings(*mappings: Mapping[_K, _V]) -> Mapping[_K, _V]:
+def merge_mappings[K, V](*mappings: Mapping[K, V]) -> Mapping[K, V]:
     """Merge a set of mappings."""
     return reduce(or_, map(dict, mappings), {})
 
@@ -922,7 +884,7 @@ def merge_mappings(*mappings: Mapping[_K, _V]) -> Mapping[_K, _V]:
 ##
 
 
-def merge_sets(*iterables: Iterable[_T]) -> AbstractSet[_T]:
+def merge_sets[T](*iterables: Iterable[T]) -> AbstractSet[T]:
     """Merge a set of sets."""
     return reduce(or_, map(set, iterables), set())
 
@@ -969,9 +931,9 @@ class MergeStrMappingsError(Exception):
 ##
 
 
-def one(*iterables: Iterable[_T]) -> _T:
+def one[T](*iterables: Iterable[T]) -> T:
     """Return the unique value in a set of iterables."""
-    it = iter(chain(*iterables))
+    it = chain(*iterables)
     try:
         first = next(it)
     except StopIteration:
@@ -984,21 +946,21 @@ def one(*iterables: Iterable[_T]) -> _T:
 
 
 @dataclass(kw_only=True, slots=True)
-class OneError(Exception, Generic[_T]):
-    iterables: tuple[Iterable[_T], ...]
+class OneError[T](Exception):
+    iterables: tuple[Iterable[T], ...]
 
 
 @dataclass(kw_only=True, slots=True)
-class OneEmptyError(OneError[_T]):
+class OneEmptyError[T](OneError[T]):
     @override
     def __str__(self) -> str:
         return f"Iterable(s) {get_repr(self.iterables)} must not be empty"
 
 
 @dataclass(kw_only=True, slots=True)
-class OneNonUniqueError(OneError, Generic[_T]):
-    first: _T
-    second: _T
+class OneNonUniqueError[T](OneError):
+    first: T
+    second: T
 
     @override
     def __str__(self) -> str:
@@ -1008,7 +970,7 @@ class OneNonUniqueError(OneError, Generic[_T]):
 ##
 
 
-def one_maybe(*objs: MaybeIterable[_T]) -> _T:
+def one_maybe[T](*objs: MaybeIterable[T]) -> T:
     """Return the unique value in a set of values/iterables."""
     try:
         return one(chain_maybe_iterables(*objs))
@@ -1032,10 +994,10 @@ class OneMaybeEmptyError(OneMaybeError):
 
 
 @dataclass(kw_only=True, slots=True)
-class OneMaybeNonUniqueError(OneMaybeError, Generic[_T]):
-    objs: tuple[MaybeIterable[_T], ...]
-    first: _T
-    second: _T
+class OneMaybeNonUniqueError[T](OneMaybeError):
+    objs: tuple[MaybeIterable[T], ...]
+    first: T
+    second: T
 
     @override
     def __str__(self) -> str:
@@ -1064,7 +1026,7 @@ def one_str(
             it = (t for t in as_list if t.startswith(text))
         case True, False:
             it = (t for t in as_list if t.lower().startswith(text.lower()))
-        case _ as never:
+        case never:
             assert_never(never)
     try:
         return one(it)
@@ -1105,7 +1067,7 @@ class OneStrEmptyError(OneStrError):
                 tail = f"any string starting with {self.text!r}"
             case True, False:
                 tail = f"any string starting with {self.text!r} (modulo case)"
-            case _ as never:
+            case never:
                 assert_never(never)
         return f"{head} {tail}"
 
@@ -1127,7 +1089,7 @@ class OneStrNonUniqueError(OneStrError):
                 mid = f"exactly one string starting with {self.text!r}"
             case True, False:
                 mid = f"exactly one string starting with {self.text!r} (modulo case)"
-            case _ as never:
+            case never:
                 assert_never(never)
         return f"{head} {mid}; got {self.first!r}, {self.second!r} and perhaps more"
 
@@ -1135,7 +1097,7 @@ class OneStrNonUniqueError(OneStrError):
 ##
 
 
-def one_unique(*iterables: Iterable[THashable]) -> THashable:
+def one_unique[T: Hashable](*iterables: Iterable[T]) -> T:
     """Return the set-unique value in a set of iterables."""
     try:
         return one(set(chain(*iterables)))
@@ -1159,7 +1121,7 @@ class OneUniqueEmptyError(OneUniqueError):
 
 
 @dataclass(kw_only=True, slots=True)
-class OneUniqueNonUniqueError(OneUniqueError, Generic[THashable]):
+class OneUniqueNonUniqueError[THashable](OneUniqueError):
     iterables: tuple[MaybeIterable[THashable], ...]
     first: THashable
     second: THashable
@@ -1172,7 +1134,7 @@ class OneUniqueNonUniqueError(OneUniqueError, Generic[THashable]):
 ##
 
 
-def pairwise_tail(iterable: Iterable[_T], /) -> Iterator[tuple[_T, _T | Sentinel]]:
+def pairwise_tail[T](iterable: Iterable[T], /) -> Iterator[tuple[T, T | Sentinel]]:
     """Return pairwise elements, with the last paired with the sentinel."""
     return pairwise(chain(iterable, [sentinel]))
 
@@ -1180,11 +1142,11 @@ def pairwise_tail(iterable: Iterable[_T], /) -> Iterator[tuple[_T, _T | Sentinel
 ##
 
 
-def product_dicts(mapping: Mapping[_K, Iterable[_V]], /) -> Iterator[Mapping[_K, _V]]:
+def product_dicts[K, V](mapping: Mapping[K, Iterable[V]], /) -> Iterator[Mapping[K, V]]:
     """Return the cartesian product of the values in a mapping, as mappings."""
     keys = list(mapping)
     for values in product(*mapping.values()):
-        yield cast("Mapping[_K, _V]", dict(zip(keys, values, strict=True)))
+        yield cast("Mapping[K, V]", dict(zip(keys, values, strict=True)))
 
 
 ##
@@ -1241,41 +1203,39 @@ class _RangePartitionsNumError(RangePartitionsError):
 
 
 @overload
-def reduce_mappings(
-    func: Callable[[_V, _V], _V], sequence: Iterable[Mapping[_K, _V]], /
-) -> Mapping[_K, _V]: ...
+def reduce_mappings[K, V](
+    func: Callable[[V, V], V], sequence: Iterable[Mapping[K, V]], /
+) -> Mapping[K, V]: ...
 @overload
-def reduce_mappings(
-    func: Callable[[_W, _V], _W],
-    sequence: Iterable[Mapping[_K, _V]],
+def reduce_mappings[K, V, W](
+    func: Callable[[W, V], W],
+    sequence: Iterable[Mapping[K, V]],
     /,
     *,
-    initial: _W | Sentinel = sentinel,
-) -> Mapping[_K, _W]: ...
-def reduce_mappings(
-    func: Callable[[_V, _V], _V] | Callable[[_W, _V], _W],
-    sequence: Iterable[Mapping[_K, _V]],
+    initial: W | Sentinel = sentinel,
+) -> Mapping[K, W]: ...
+def reduce_mappings[K, V, W](
+    func: Callable[[V, V], V] | Callable[[W, V], W],
+    sequence: Iterable[Mapping[K, V]],
     /,
     *,
-    initial: _W | Sentinel = sentinel,
-) -> Mapping[_K, _V | _W]:
+    initial: W | Sentinel = sentinel,
+) -> Mapping[K, V | W]:
     """Reduce a function over the values of a set of mappings."""
     chained = chain_mappings(*sequence)
-    if isinstance(initial, Sentinel):
-        func2 = cast("Callable[[_V, _V], _V]", func)
+    if is_sentinel(initial):
+        func2 = cast("Callable[[V, V], V]", func)
         return {k: reduce(func2, v) for k, v in chained.items()}
-    func2 = cast("Callable[[_W, _V], _W]", func)
+    func2 = cast("Callable[[W, V], W]", func)
     return {k: reduce(func2, v, initial) for k, v in chained.items()}
 
 
 ##
 
 
-def resolve_include_and_exclude(
-    *,
-    include: MaybeIterable[_T] | None = None,
-    exclude: MaybeIterable[_T] | None = None,
-) -> tuple[set[_T] | None, set[_T] | None]:
+def resolve_include_and_exclude[T](
+    *, include: MaybeIterable[T] | None = None, exclude: MaybeIterable[T] | None = None
+) -> tuple[set[T] | None, set[T] | None]:
     """Resolve an inclusion/exclusion pair."""
     include_use = include if include is None else set(always_iterable(include))
     exclude_use = exclude if exclude is None else set(always_iterable(exclude))
@@ -1289,9 +1249,9 @@ def resolve_include_and_exclude(
 
 
 @dataclass(kw_only=True, slots=True)
-class ResolveIncludeAndExcludeError(Exception, Generic[_T]):
-    include: Iterable[_T]
-    exclude: Iterable[_T]
+class ResolveIncludeAndExcludeError[T](Exception):
+    include: Iterable[T]
+    exclude: Iterable[T]
 
     @override
     def __str__(self) -> str:
@@ -1304,7 +1264,7 @@ class ResolveIncludeAndExcludeError(Exception, Generic[_T]):
 ##
 
 
-def sort_iterable(iterable: Iterable[_T], /) -> list[_T]:
+def sort_iterable[T](iterable: Iterable[T], /) -> list[T]:
     """Sort an iterable across types."""
     return sorted(iterable, key=cmp_to_key(_sort_iterable_cmp))
 
@@ -1326,9 +1286,6 @@ def _sort_iterable_cmp(x: Any, y: Any, /) -> Sign:
     if x is None:
         y = cast("NoneType", y)
         return 0
-    if isinstance(x, dt.datetime):
-        y = cast("dt.datetime", y)
-        return _sort_iterable_cmp_datetimes(x, y)
     if isinstance(x, float):
         y = cast("float", y)
         return _sort_iterable_cmp_floats(x, y)
@@ -1371,30 +1328,6 @@ class SortIterableError(Exception):
         return f"Unable to sort {get_repr(self.x)} and {get_repr(self.y)}"
 
 
-def _sort_iterable_cmp_datetimes(x: dt.datetime, y: dt.datetime, /) -> Sign:
-    """Compare two datetimes."""
-    match x.tzinfo, y.tzinfo:
-        case None, None:
-            return cast("Sign", (x > y) - (x < y))
-        case dt.tzinfo(), None:
-            return 1
-        case None, dt.tzinfo():
-            return -1
-        case dt.tzinfo(), dt.tzinfo():
-            x_utc = x.astimezone(tz=UTC)
-            y_utc = y.astimezone(tz=UTC)
-            result = cast("Sign", (x_utc > y_utc) - (x_utc < y_utc))
-            if result != 0:
-                return result
-            x_time_zone = ensure_not_none(ensure_not_none(x.tzinfo).tzname(x))
-            y_time_zone = ensure_not_none(ensure_not_none(y.tzinfo).tzname(y))
-            return cast(
-                "Sign", (x_time_zone > y_time_zone) - (x_time_zone < y_time_zone)
-            )
-        case _ as never:
-            assert_never(never)
-
-
 def _sort_iterable_cmp_floats(x: float, y: float, /) -> Sign:
     """Compare two floats."""
     x_nan, y_nan = map(isnan, [x, y])
@@ -1407,14 +1340,16 @@ def _sort_iterable_cmp_floats(x: float, y: float, /) -> Sign:
             return -1
         case False, False:
             return cast("Sign", (x > y) - (x < y))
-        case _ as never:
+        case never:
             assert_never(never)
 
 
 ##
 
 
-def sum_mappings(*mappings: Mapping[_K, TSupportsAdd]) -> Mapping[_K, TSupportsAdd]:
+def sum_mappings[K: Hashable, V: SupportsAdd](
+    *mappings: Mapping[K, V],
+) -> Mapping[K, V]:
     """Sum the values of a set of mappings."""
     return reduce_mappings(add, mappings, initial=0)
 
@@ -1422,7 +1357,7 @@ def sum_mappings(*mappings: Mapping[_K, TSupportsAdd]) -> Mapping[_K, TSupportsA
 ##
 
 
-def take(n: int, iterable: Iterable[_T], /) -> Sequence[_T]:
+def take[T](n: int, iterable: Iterable[T], /) -> Sequence[T]:
     """Return first n items of the iterable as a list."""
     return list(islice(iterable, n))
 
@@ -1431,23 +1366,23 @@ def take(n: int, iterable: Iterable[_T], /) -> Sequence[_T]:
 
 
 @overload
-def transpose(iterable: Iterable[tuple[_T1]], /) -> tuple[list[_T1]]: ...
+def transpose[T1](iterable: Iterable[tuple[T1]], /) -> tuple[list[T1]]: ...
 @overload
-def transpose(
-    iterable: Iterable[tuple[_T1, _T2]], /
-) -> tuple[list[_T1], list[_T2]]: ...
+def transpose[T1, T2](
+    iterable: Iterable[tuple[T1, T2]], /
+) -> tuple[list[T1], list[T2]]: ...
 @overload
-def transpose(
-    iterable: Iterable[tuple[_T1, _T2, _T3]], /
-) -> tuple[list[_T1], list[_T2], list[_T3]]: ...
+def transpose[T1, T2, T3](
+    iterable: Iterable[tuple[T1, T2, T3]], /
+) -> tuple[list[T1], list[T2], list[T3]]: ...
 @overload
-def transpose(
-    iterable: Iterable[tuple[_T1, _T2, _T3, _T4]], /
-) -> tuple[list[_T1], list[_T2], list[_T3], list[_T4]]: ...
+def transpose[T1, T2, T3, T4](
+    iterable: Iterable[tuple[T1, T2, T3, T4]], /
+) -> tuple[list[T1], list[T2], list[T3], list[T4]]: ...
 @overload
-def transpose(
-    iterable: Iterable[tuple[_T1, _T2, _T3, _T4, _T5]], /
-) -> tuple[list[_T1], list[_T2], list[_T3], list[_T4], list[_T5]]: ...
+def transpose[T1, T2, T3, T4, T5](
+    iterable: Iterable[tuple[T1, T2, T3, T4, T5]], /
+) -> tuple[list[T1], list[T2], list[T3], list[T4], list[T5]]: ...
 def transpose(iterable: Iterable[tuple[Any]]) -> tuple[list[Any], ...]:  # pyright: ignore[reportInconsistentOverload]
     """Typed verison of `transpose`."""
     return tuple(map(list, zip(*iterable, strict=True)))
@@ -1456,9 +1391,9 @@ def transpose(iterable: Iterable[tuple[Any]]) -> tuple[list[Any], ...]:  # pyrig
 ##
 
 
-def unique_everseen(
-    iterable: Iterable[_T], /, *, key: Callable[[_T], Any] | None = None
-) -> Iterator[_T]:
+def unique_everseen[T](
+    iterable: Iterable[T], /, *, key: Callable[[T], Any] | None = None
+) -> Iterator[T]:
     """Yield unique elements, preserving order."""
     seenset = set()
     seenset_add = seenset.add
@@ -1512,7 +1447,6 @@ __all__ = [
     "ResolveIncludeAndExcludeError",
     "SortIterableError",
     "always_iterable",
-    "always_iterable_hashable",
     "apply_bijection",
     "apply_to_tuple",
     "apply_to_varargs",
@@ -1532,12 +1466,11 @@ __all__ = [
     "check_unique_modulo_case",
     "chunked",
     "cmp_nullable",
-    "ensure_hashables",
     "ensure_iterable",
     "ensure_iterable_not_str",
+    "enumerate_with_edge",
     "expanding_window",
     "filter_include_and_exclude",
-    "group_consecutive_integers",
     "groupby_lists",
     "hashable_to_iterable",
     "is_iterable",
@@ -1560,6 +1493,5 @@ __all__ = [
     "sum_mappings",
     "take",
     "transpose",
-    "ungroup_consecutive_integers",
     "unique_everseen",
 ]