veridret-plugins-core 1__tar.gz

veridret_plugins_core-1/.gitignore

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Ignore Vim swap files.
+.sw*
+.*.sw*
+
+# Ignore build & install artifacts.
+/build*/
+/dist*/
+/install*/
+/*.whl
+
+# Ignore Python bytecode cache files.
+__pycache__/

veridret_plugins_core-1/LICENSE.md

@@ -0,0 +1,50 @@
+<!-- SPDX-License-Identifier: BSD-3-Clause -->
+
+Copyright &copy; 2026 Jonathan Gruber.
+
+Redistribution and use in source and binary forms,
+with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions
+    and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions
+    and the following disclaimer
+    in the documentation and/or other materials
+    provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED
+BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+&ldquo;AS IS&rdquo;
+AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING,
+BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT,
+INDIRECT,
+INCIDENTAL,
+SPECIAL,
+EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES
+(INCLUDING,
+BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT,
+STRICT LIABILITY,
+OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

veridret_plugins_core-1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.5
+Name: veridret-plugins-core
+Version: 1
+Import-Name: veridret_plugins.core
+Import-Namespace: veridret_plugins
+Summary: The *official* Python package of the *official* standard core VerIdRet plugins
+Project-URL: homepage, https://codeberg.org/jonathan-gruber-jg/veridret-plugins-core.git
+Project-URL: source, https://codeberg.org/jonathan-gruber-jg/veridret-plugins-core.git
+Author-email: Jonathan Gruber <jonathan.gruber.jg@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Requires-Python: ~=3.14.6
+Requires-Dist: pydantic~=2.13
+Requires-Dist: veridret~=1.0
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: BSD-3-Clause -->
+
+`veridret-plugins-core` is the *official* Python package
+of the *official* standard core VerIdRet plugins.

veridret_plugins_core-1/README.md

@@ -0,0 +1,4 @@
+<!-- SPDX-License-Identifier: BSD-3-Clause -->
+
+`veridret-plugins-core` is the *official* Python package
+of the *official* standard core VerIdRet plugins.

veridret_plugins_core-1/pyproject.toml

@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+[build-system]
+requires = [
+    'hatchling',
+]
+build-backend = 'hatchling.build'
+
+[project]
+name = 'veridret-plugins-core'
+dynamic = [
+    'version',
+]
+description = """\
+The *official* Python package \
+of the *official* standard core VerIdRet plugins\
+"""
+readme = 'README.md'
+license = 'BSD-3-Clause'
+license-files = [
+    'LICENSE.md',
+]
+import-names = [
+    'veridret_plugins.core',
+]
+import-namespaces = [
+    'veridret_plugins',
+]
+requires-python = '~= 3.14.6'
+dependencies = [
+    'pydantic ~= 2.13',
+    'veridret ~= 1.0',
+]
+
+[[project.authors]]
+name = 'Jonathan Gruber'
+email = 'jonathan.gruber.jg@gmail.com'
+
+[project.urls]
+homepage = 'https://codeberg.org/jonathan-gruber-jg/veridret-plugins-core.git'
+source = 'https://codeberg.org/jonathan-gruber-jg/veridret-plugins-core.git'
+
+[tool.hatch.build.targets.wheel]
+packages = [
+    'src/veridret_plugins',
+]
+
+[tool.hatch.version]
+path = 'src/veridret_plugins/core/__init__.py'
+
+[tool.pylint.main]
+disable = [
+    'missing-class-docstring',
+    'missing-function-docstring',
+    'too-few-public-methods',
+    'too-many-instance-attributes',
+    'unspecified-encoding',
+]
+
+[tool.pylint.format]
+max-line-length = 79
+
+[tool.pylint.variables]
+init-import = false
+
+[tool.mypy]
+mypy_path = [
+    '${MYPY_CONFIG_FILE_DIR}/src',
+]
+packages = [
+    'veridret_plugins',
+]
+strict = true
+strict_equality_for_none = true
+warn_return_any = false
+
+[tool.pyrefly]
+project-includes = [
+    'src',
+]
+min-severity = 'warn'
+preset = 'strict'
+enabled-ignores = [
+    'pyrefly',
+]
+
+[tool.pyrefly.errors]
+implicit-any-lambda = 'ignore'
+
+[tool.pyright]
+include = [
+    'src',
+]
+#typeCheckingMode = 'strict'
+enableTypeIgnoreComments = false

veridret_plugins_core-1/src/veridret_plugins/core/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The *official* Python package
+of the *official* standard core VerIdRet plugins.
+"""
+
+__all__: list[str] = [
+]
+
+__version__ = '1'

veridret_plugins_core-1/src/veridret_plugins/core/_plugin.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Plugin utilities.
+"""
+
+from typing import Annotated, Any, ClassVar
+
+import pydantic
+
+import veridret.plugin
+
+__all__ = [
+    'AnnotatedCall',
+    'Call',
+    'evaluate_call',
+]
+
+class Call(pydantic.BaseModel):
+    """
+    A plugin call.
+    """
+
+    model_config: ClassVar = pydantic.ConfigDict(frozen=True)
+
+    plugin: str
+    args: dict[str, object] = pydantic.Field(
+        default_factory=dict,
+        validation_alias=pydantic.AliasChoices('arguments', 'args'),
+        serialization_alias='arguments',
+    )
+
+def evaluate_call(call: Call) -> Any:
+    """
+    Evaluate a plugin call.
+
+    :param call: The plugin call,
+    :return: The result of the plugin call.
+    :raise Exception:
+        If the plugin cannot be loaded
+        or the call to it fails.
+    """
+
+    return veridret.plugin.load(call.plugin)(call.args)
+
+def _inst_anno_call(value: Call | str) -> Call:
+    match value:
+        case Call():
+            return value
+        case str():
+            return Call(plugin=value)
+
+type AnnotatedCall = Annotated[
+    Call,
+    pydantic.ValidateAs(
+        Call | str, # pyright: ignore[reportArgumentType]
+        _inst_anno_call,
+    ),
+]
+"""
+:class:`Call` but annotated for Pydantic to instantiate the type
+from a string ``x`` via ``Call(plugin=x)``.
+"""

veridret_plugins_core-1/src/veridret_plugins/core/call.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Evaluate a call expression.
+
+In particular,
+the plugin evaluates ``id a[1] a[2] ... a[n]``,
+where ``id`` is the identity function
+and each operand ``a[i]`` is the result of a plugin call.
+"""
+
+from collections.abc import Callable
+import functools
+from typing import Any, cast, overload
+
+import pydantic
+
+from veridret_plugins.core import _plugin
+
+__all__ = [
+    'call',
+]
+
+class _Args(pydantic.BaseModel):
+    operands: tuple[_plugin.AnnotatedCall, ...] = pydantic.Field(
+        (),
+        validation_alias=pydantic.AliasChoices('operands', 'items'),
+        serialization_alias='operands',
+    )
+
+@overload
+def _try_call[T, U](func: Callable[[T], U], arg: T) -> U:
+    ...
+@overload
+def _try_call(func: object, arg: object) -> Any:
+    ...
+def _try_call(func: object, arg: object) -> Any:
+    return cast(Callable[[Any], Any], func)(arg)
+
+def _identity[T](obj: T, /) -> T:
+    return obj
+
+def call(args: dict[str, object]) -> Any:
+    """
+    Call the plugin.
+
+    :param args: A dictionary of the plugin's arguments.
+    :return: The result of the call expression specified by ``args``.
+    :raise Exception:
+        If ``args`` is invalid,
+        evaluating any of the plugin calls
+        that evaluate to the operands of the call expression
+        fails,
+        or any of the individual calls
+        made in evaluating the whole call expression
+        fails.
+    """
+
+    validated_args = _Args.model_validate(args, strict=True, by_name=False)
+    return functools.reduce(
+        _try_call,
+        map(_plugin.evaluate_call, validated_args.operands),
+        initial=_identity,
+    )

veridret_plugins_core-1/src/veridret_plugins/core/cmptools/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Utilities for comparing values.
+"""
+
+__all__: list[str] = [
+]

veridret_plugins_core-1/src/veridret_plugins/core/cmptools/reverse.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Reflect/reverse rich comparisons upon an object.
+"""
+
+from collections.abc import Callable
+import dataclasses
+import operator
+import types
+from typing import Any, final, Never, override
+
+__all__ = [
+    'call',
+    'Reverse',
+]
+
+@final
+@dataclasses.dataclass(frozen=True)
+class Reverse[T]:
+    """
+    A comparison key that reflects/reverses rich comparisons.
+    """
+
+    value: T
+
+    def _cmp_impl(
+        self, other: object, op: Callable[[Any, Any], object],
+    ) -> Any | types.NotImplementedType:
+        if not isinstance(other, Reverse):
+            return NotImplemented
+        return op(other.value, self.value)
+
+    def __lt__(self, other: object) -> Any | types.NotImplementedType:
+        return self._cmp_impl(other, operator.lt)
+
+    def __gt__(self, other: object) -> Any | types.NotImplementedType:
+        return self._cmp_impl(other, operator.gt)
+
+    def __le__(self, other: object) -> Any | types.NotImplementedType:
+        return self._cmp_impl(other, operator.le)
+
+    def __ge__(self, other: object) -> Any | types.NotImplementedType:
+        return self._cmp_impl(other, operator.ge)
+
+    @override
+    @classmethod
+    def __init_subclass__(cls) -> Never:
+        raise TypeError(
+            f'type {Reverse.__qualname__!r} is not an acceptable base type',
+        )
+
+def call(args: dict[str, object]) -> type[Reverse[Any]]:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: :class:`Reverse`.
+    """
+
+    # Unused.
+    del args
+
+    return Reverse

veridret_plugins_core-1/src/veridret_plugins/core/cmptools/unordered.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Disable ordering comparisons
+(``<``, ``<=``, ``>``, and ``>=``)
+upon an object.
+"""
+
+import dataclasses
+from typing import Any, final, Never, override
+
+__all__ = [
+    'call',
+    'Unordered',
+]
+
+@final
+@dataclasses.dataclass(frozen=True)
+class Unordered[T]:
+    """
+    A comparison key that disables comparisons
+    with ``<``, ``<=``, ``>``, or ``>=``
+    while preserving those with ``==`` or ``!=``.
+    """
+
+    value: T
+
+    @override
+    @classmethod
+    def __init_subclass__(cls) -> Never:
+        raise TypeError(
+            f'type {Unordered.__qualname__!r} is not an acceptable base type',
+        )
+
+def call(args: dict[str, object]) -> type[Unordered[Any]]:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: :class:`Unordered`.
+    """
+
+    # Unused.
+    del args
+
+    return Unordered

veridret_plugins_core-1/src/veridret_plugins/core/functools/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Utilities for manipulating functions.
+"""
+
+__all__: list[str] = [
+]

veridret_plugins_core-1/src/veridret_plugins/core/functools/call.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The function call operator.
+
+The operator is in fact the identity function over the functions;
+letting ``op`` denote the operator,
+we have ``op f x = (op f) x = f x``.
+"""
+
+from collections.abc import Callable
+from typing import Any, Protocol
+
+__all__ = [
+    'Call',
+    'call',
+]
+
+class Call(Protocol):
+    """
+    A protocol for the function call operator.
+    """
+
+    def __call__[F: Callable[[Any], Any]](self, obj: F, /) -> F:
+        ...
+
+def _identity[F: Callable[[Any], Any]](func: F, /) -> F:
+    return func
+
+def call(args: dict[str, object]) -> Call:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: The function call operator.
+    """
+
+    # Unused.
+    del args
+
+    return _identity

veridret_plugins_core-1/src/veridret_plugins/core/functools/call_right.py

@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The reverse or rightist function call operator.
+
+The operator is in fact the normal function call operator
+with the first two arguments switched;
+letting ``op`` denote the operator,
+we have ``op x f = f x``.
+Since,
+in an expression like ``operator a b``,
+the normal function call operator calls
+the *left* operand ``a`` upon the right operand ``b``
+while the reverse function call operator calls
+the *right* operand ``b`` upon the left operand ``a``,
+we refer to the latter operator as also
+the *right*\\ ist function call operator.
+"""
+
+from collections.abc import Callable
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'CallRight',
+    'CallRightOne'
+]
+
+class CallRightOne[T](Protocol):
+    """
+    A protocol for the reverse function call operator
+    with the first argument bound to an object of type ``T``.
+    """
+
+    def __call__[U](self, func: Callable[[T], U], /) -> U:
+        ...
+
+class CallRight(Protocol):
+    """
+    A protocol for the reverse function call operator.
+    """
+
+    def __call__[T](self, obj: T, /) -> CallRightOne[T]:
+        ...
+
+def _call_right[T](obj: T, /) -> CallRightOne[T]:
+    def call_right_one[U](func: Callable[[T], U], /) -> U:
+        return func(obj)
+
+    return call_right_one
+
+def call(args: dict[str, object]) -> CallRight:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: A curried reverse unary-function-call operator.
+    """
+
+    # Unused.
+    del args
+
+    return _call_right

veridret_plugins_core-1/src/veridret_plugins/core/functools/compose_left.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The leftist function composition operator.
+
+The order of the composed functions is opposite
+that of the usual function composition operator in mathematics;
+letting ``op`` denote the operator,
+we have ``op f g x = (op f g) x = g (f x)``.
+Since the function ``g`` with which ``f`` is composed
+thus ends up on the *left* of ``f``
+in the preceding evaluation of ``op f g x``,
+we call the operator the *left*\\ ist function composition operator.
+"""
+
+from collections.abc import Callable
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'ComposeLeft',
+    'ComposeLeftOne',
+]
+
+class ComposeLeftOne[T, U](Protocol):
+    """
+    A protocol for the leftist function composition operator
+    with the first argument bound to a function of type ``T -> U``.
+    """
+
+    def __call__[V](self, func: Callable[[U], V], /) -> Callable[[T], V]:
+        ...
+
+class ComposeLeft(Protocol):
+    """
+    A protocol for the leftist function composition operator.
+    """
+
+    def __call__[T, U](
+        self, func: Callable[[T], U], /,
+    ) -> ComposeLeftOne[T, U]:
+        ...
+
+def _compose_left[T, U](func1: Callable[[T], U], /) -> ComposeLeftOne[T, U]:
+    def compose_left_one[V](func2: Callable[[U], V], /) -> Callable[[T], V]:
+        def compose_left_two(obj: T, /) -> V:
+            return func2(func1(obj))
+
+        return compose_left_two
+
+    return compose_left_one
+
+def call(args: dict[str, object]) -> ComposeLeft:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: The leftist function composition operator.
+    """
+
+    # Unused.
+    del args
+
+    return _compose_left

veridret_plugins_core-1/src/veridret_plugins/core/functools/compose_right.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The rightist function composition operator.
+
+The operator corresponds to the usual function composition operator
+in mathematics;
+letting ``op`` denote the operator,
+we have ``op f g x = (op f g) x = f (g x)``.
+Since the function ``g`` with which ``f`` is composed
+thus ends up on the *right* of ``f``
+in the preceding evaluation of ``op f g x``,
+we call the operator the *right*\\ ist function composition operator.
+"""
+
+from collections.abc import Callable
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'ComposeRight',
+    'ComposeRightOne',
+]
+
+class ComposeRightOne[T, U](Protocol):
+    """
+    A protocol for the rightist function composition operator
+    with the first argument bound to a function of type ``T -> U``.
+    """
+
+    def __call__[V](self, func: Callable[[V], T], /) -> Callable[[V], U]:
+        ...
+
+class ComposeRight(Protocol):
+    """
+    A protocol for the rightist function composition operator.
+    """
+
+    def __call__[T, U](
+        self, func: Callable[[T], U], /,
+    ) -> ComposeRightOne[T, U]:
+        ...
+
+def _compose_right[T, U](func1: Callable[[T], U], /) -> ComposeRightOne[T, U]:
+    def compose_right_one[V](func2: Callable[[V], T], /) -> Callable[[V], U]:
+        def compose_right_two(obj: V, /) -> U:
+            return func1(func2(obj))
+
+        return compose_right_two
+
+    return compose_right_one
+
+def call(args: dict[str, object]) -> ComposeRight:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: The rightist function composition operator.
+    """
+
+    # Unused.
+    del args
+
+    return _compose_right

veridret_plugins_core-1/src/veridret_plugins/core/functools/identity.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The identity function.
+"""
+
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'Identity',
+]
+
+class Identity(Protocol):
+    """
+    A protocol for the identity function.
+    """
+
+    def __call__[T](self, obj: T, /) -> T:
+        ...
+
+def _identity[T](obj: T, /) -> T:
+    return obj
+
+def call(args: dict[str, object]) -> Identity:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: The identity function.
+    """
+
+    # Unused.
+    del args
+
+    return _identity

veridret_plugins_core-1/src/veridret_plugins/core/iterator.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Construct an iterator over a fixed sequence.
+
+In particular,
+the plugin constructs an iterator
+over the sequence ``(a[0], a[1], ..., a[n])``,
+where each ``a[i]`` is the result of a plugin call
+and is computed only once the iterator is made to yield it.
+"""
+
+from collections.abc import Iterator
+from typing import Any
+
+import pydantic
+
+from veridret_plugins.core import _plugin
+
+__all__ = [
+    'call',
+]
+
+class _Args(pydantic.BaseModel):
+    operands: tuple[_plugin.AnnotatedCall, ...] = pydantic.Field(
+        (),
+        validation_alias=pydantic.AliasChoices('operands', 'items'),
+        serialization_alias='operands',
+    )
+
+def call(args: dict[str, object]) -> Iterator[Any]:
+    """
+    Call the plugin.
+
+    :param args: A dictionary of the plugin's arguments.
+    :return: An iterator of the sequence specified by ``args``.
+    :raise Exception:
+        If ``args`` is invalid.
+
+    Since the plugin calls that evaluate to the items yielded by the iterator
+    are each only evaluated once the iterator is made to yield them,
+    if evaluating any of those plugin calls fails,
+    then attempting to yield the item
+    to which the plugin call would have evaluated
+    raises an exception.
+    """
+
+    validated_args = _Args.model_validate(args, strict=True, by_name=False)
+    return map(_plugin.evaluate_call, validated_args.operands)

veridret_plugins_core-1/src/veridret_plugins/core/itertools/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+Utilities for manipulating iterators and other iterables.
+"""
+
+__all__: list[str] = [
+]

veridret_plugins_core-1/src/veridret_plugins/core/itertools/filter.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The ``filter`` higher-order function over the iterables.
+
+Letting ``filter_`` denote the function,
+``filter_ p it`` is equivalent to the Python ``filter(p, it)``,
+including the special case where ``p`` is ``None``.
+"""
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'Filter',
+]
+
+class Filter(Protocol):
+    """
+    A protocol for the ``filter`` higher-order function over the iterables.
+    """
+
+    def __call__[T](
+        self, pred: Callable[[T], object] | None, /,
+    ) -> Callable[[Iterable[T]], Iterator[T]]:
+        ...
+
+def _filter[T](
+    pred: Callable[[T], object] | None, /,
+) -> Callable[[Iterable[T]], Iterator[T]]:
+    def filter_one(iterable: Iterable[T], /) -> Iterator[T]:
+        return filter(pred, iterable)
+
+    return filter_one
+
+def call(args: dict[str, object]) -> Filter:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: The ``filter`` higher-order function over the iterables.
+    """
+
+    # Unused.
+    del args
+
+    return _filter

veridret_plugins_core-1/src/veridret_plugins/core/itertools/fold_left.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The left-associative variant of the ``fold`` higher-order over the iterables.
+
+Letting ``fold_left`` denote the function,
+``fold_left f z it`` is equivalent to the Python
+``functools.reduce(lambda x, y: f(x)(y), it, initial=z)``.
+"""
+
+from collections.abc import Callable, Iterable
+import functools
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'FoldLeft',
+]
+
+class FoldLeft(Protocol):
+    """
+    A protocol for the left-associative variant of the ``fold`` higher-order
+    over the iterables.
+    """
+
+    def __call__[T, U](
+        self, func: Callable[[T], Callable[[U], T]], /,
+    ) -> Callable[[T], Callable[[Iterable[U]], T]]:
+        ...
+
+def _fold_left[T, U](
+    func: Callable[[T], Callable[[U], T]], /,
+) -> Callable[[T], Callable[[Iterable[U]], T]]:
+    def uncurried_func(x: T, y: U) -> T:
+        return func(x)(y)
+
+    def fold_left_one(seed: T, /) -> Callable[[Iterable[U]], T]:
+        def fold_left_two(iterable: Iterable[U], /) -> T:
+            return functools.reduce(uncurried_func, iterable, initial=seed)
+
+        return fold_left_two
+
+    return fold_left_one
+
+def call(args: dict[str, object]) -> FoldLeft:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return:
+        The left-associative variant of the ``fold`` higher-order
+        over the iterables.
+    """
+
+    # Unused.
+    del args
+
+    return _fold_left

veridret_plugins_core-1/src/veridret_plugins/core/itertools/map.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""
+The ``map`` higher-order function over the iterables.
+
+Letting ``map_`` denote the function,
+``map_ f it`` is equivalent to the Python ``map(f, it)``.
+"""
+
+from collections.abc import Callable, Iterable, Iterator
+from typing import Protocol
+
+__all__ = [
+    'call',
+    'Map',
+]
+
+class Map(Protocol):
+    """
+    A protocol for the ``map`` higher-order function over the iterables.
+    """
+
+    def __call__[T, U](
+        self, func: Callable[[T], U], /
+    ) -> Callable[[Iterable[T]], Iterator[U]]:
+        ...
+
+def _map[T, U](
+    func: Callable[[T], U], /,
+) -> Callable[[Iterable[T]], Iterator[U]]:
+    def map_one(iterable: Iterable[T], /) -> Iterator[U]:
+        return map(func, iterable)
+
+    return map_one
+
+def call(args: dict[str, object]) -> Map:
+    """
+    Call the plugin.
+
+    :param args:
+        A dictionary of the plugin's arguments;
+        unused.
+    :return: A ``map`` higher-order function over the iterables.
+    """
+
+    # Unused.
+    del args
+
+    return _map