effectful 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

effectful/ops/syntax.py

@@ -2,21 +2,16 @@ import collections.abc
 import dataclasses
 import functools
 import inspect
+import numbers
+import operator
 import random
 import types
 import typing
-from typing import Annotated, Callable, Generic, Optional, Type, TypeVar
+import warnings
+from collections.abc import Callable, Iterable, Mapping
+from typing import Annotated, Any, Concatenate
 
-import tree
-from typing_extensions import Concatenate, ParamSpec
-
-from effectful.ops.types import Annotation, Expr, Interpretation, Operation, Term
-
-P = ParamSpec("P")
-Q = ParamSpec("Q")
-S = TypeVar("S")
-T = TypeVar("T")
-V = TypeVar("V")
+from effectful.ops.types import Annotation, Expr, NotHandled, Operation, Term
 
 
 @dataclasses.dataclass
@@ -54,11 +49,9 @@ class Scoped(Annotation):
     We illustrate the use of :class:`Scoped` with a few case studies of classical
     syntactic variable binding constructs expressed as :class:`Operation` s.
 
-    >>> from typing import Annotated, TypeVar
+    >>> from typing import Annotated
     >>> from effectful.ops.syntax import Scoped, defop
     >>> from effectful.ops.semantics import fvsof
-    >>> from effectful.handlers.numbers import add
-    >>> A, B, S, T = TypeVar('A'), TypeVar('B'), TypeVar('S'), TypeVar('T')
     >>> x, y = defop(int, name='x'), defop(int, name='y')
 
     * For example, we can define a higher-order operation :func:`Lambda`
@@ -67,64 +60,66 @@ class Scoped(Annotation):
       and returns a :class:`Term` representing a lambda function:
 
       >>> @defop
-      ... def Lambda(
+      ... def Lambda[S, T, A, B](
       ...     var: Annotated[Operation[[], S], Scoped[A]],
       ...     body: Annotated[T, Scoped[A | B]]
       ... ) -> Annotated[Callable[[S], T], Scoped[B]]:
-      ...     raise NotImplementedError
+      ...     raise NotHandled
 
     * The :class:`Scoped` annotation is used here to indicate that the argument ``var``
       passed to :func:`Lambda` may appear free in ``body``, but not in the resulting function.
       In other words, it is bound by :func:`Lambda`:
 
-      >>> assert x not in fvsof(Lambda(x, add(x(), 1)))
+      >>> assert x not in fvsof(Lambda(x, x() + 1))
 
       However, variables in ``body`` other than ``var`` still appear free in the result:
 
-      >>> assert y in fvsof(Lambda(x, add(x(), y())))
+      >>> assert y in fvsof(Lambda(x, x() + y()))
 
     * :class:`Scoped` can also be used with variadic arguments and keyword arguments.
       For example, we can define a generalized :func:`LambdaN` that takes a variable
       number of arguments and keyword arguments:
 
       >>> @defop
-      ... def LambdaN(
-      ...     body: Annotated[T, Scoped[A | B]]
+      ... def LambdaN[S, T, A, B](
+      ...     body: Annotated[T, Scoped[A | B]],
       ...     *args: Annotated[Operation[[], S], Scoped[A]],
       ...     **kwargs: Annotated[Operation[[], S], Scoped[A]]
       ... ) -> Annotated[Callable[..., T], Scoped[B]]:
-      ...     raise NotImplementedError
+      ...     raise NotHandled
 
       This is equivalent to the built-in :class:`Operation` :func:`deffn`:
 
-      >>> assert not {x, y} & fvsof(LambdaN(add(x(), y()), x, y))
+      >>> assert not {x, y} & fvsof(LambdaN(x() + y(), x, y))
 
     * :class:`Scoped` and :func:`defop` can also express more complex scoping semantics.
       For example, we can define a :func:`Let` operation that binds a variable in
       a :class:`Term` ``body`` to a ``value`` that may be another possibly open :class:`Term` :
 
       >>> @defop
-      ... def Let(
+      ... def Let[S, T, A, B](
       ...     var: Annotated[Operation[[], S], Scoped[A]],
       ...     val: Annotated[S, Scoped[B]],
       ...     body: Annotated[T, Scoped[A | B]]
       ... ) -> Annotated[T, Scoped[B]]:
-      ...     raise NotImplementedError
+      ...     raise NotHandled
 
       Here the variable ``var`` is bound by :func:`Let` in `body` but not in ``val`` :
 
-      >>> assert x not in fvsof(Let(x, add(y(), 1), add(x(), y())))
-      >>> assert {x, y} in fvsof(Let(x, add(y(), x()), add(x(), y())))
+      >>> assert x not in fvsof(Let(x, y() + 1, x() + y()))
+
+      >>> fvs = fvsof(Let(x, y() + x(), x() + y()))
+      >>> assert x in fvs and y in fvs
 
       This is reflected in the free variables of subterms of the result:
 
-      >>> assert x in fvsof(Let(x, add(x(), y()), add(x(), y())).args[1])
-      >>> assert x not in fvsof(Let(x, add(y(), 1), add(x(), y())).args[2])
+      >>> assert x in fvsof(Let(x, x() + y(), x() + y()).args[1])
+      >>> assert x not in fvsof(Let(x, y() + 1, x() + y()).args[2])
     """
 
     ordinal: collections.abc.Set
 
-    def __class_getitem__(cls, item: TypeVar | typing._SpecialForm):
+    def __class_getitem__(cls, item: typing.TypeVar | typing._SpecialForm):
         assert not isinstance(item, tuple), "can only be in one scope"
         if isinstance(item, typing.TypeVar):
             return cls(ordinal=frozenset({item}))
@@ -183,7 +178,7 @@ class Scoped(Annotation):
 
     @classmethod
     def _get_fresh_ordinal(cls, *, name: str = "RootScope") -> collections.abc.Set:
-        return {TypeVar(name)}
+        return {typing.TypeVar(name)}
 
     @classmethod
     def _check_has_single_scope(cls, sig: inspect.Signature) -> bool:
@@ -211,10 +206,10 @@ class Scoped(Annotation):
 
         def _get_free_type_vars(
             tp: type | typing._SpecialForm | inspect.Parameter | tuple | list,
-        ) -> collections.abc.Set[TypeVar]:
-            if isinstance(tp, TypeVar):
+        ) -> collections.abc.Set[typing.TypeVar]:
+            if isinstance(tp, typing.TypeVar):
                 return {tp}
-            elif isinstance(tp, (tuple, list)):
+            elif isinstance(tp, tuple | list):
                 return set().union(*map(_get_free_type_vars, tp))
             elif isinstance(tp, inspect.Parameter):
                 return _get_free_type_vars(tp.annotation)
@@ -341,36 +336,52 @@ class Scoped(Annotation):
         return_ordinal = self._get_param_ordinal(bound_sig.signature.return_annotation)
         for name, param in bound_sig.signature.parameters.items():
             param_ordinal = self._get_param_ordinal(param)
-            if (
-                self._param_is_var(param)
-                and param_ordinal <= self.ordinal
-                and not param_ordinal <= return_ordinal
-            ):
-                if param.kind is inspect.Parameter.VAR_POSITIONAL:
-                    # pre-condition: all bound variables should be distinct
-                    assert len(bound_sig.arguments[name]) == len(
-                        set(bound_sig.arguments[name])
-                    )
-                    param_bound_vars = {*bound_sig.arguments[name]}
-                elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                    # pre-condition: all bound variables should be distinct
-                    assert len(bound_sig.arguments[name].values()) == len(
-                        set(bound_sig.arguments[name].values())
-                    )
-                    param_bound_vars = {*bound_sig.arguments[name].values()}
-                else:
-                    param_bound_vars = {bound_sig.arguments[name]}
+            if param_ordinal <= self.ordinal and not param_ordinal <= return_ordinal:
+                param_value = bound_sig.arguments[name]
+                param_bound_vars = set()
+
+                if self._param_is_var(param):
+                    # Handle individual Operation parameters (existing behavior)
+                    if param.kind is inspect.Parameter.VAR_POSITIONAL:
+                        # pre-condition: all bound variables should be distinct
+                        assert len(param_value) == len(set(param_value))
+                        param_bound_vars = set(param_value)
+                    elif param.kind is inspect.Parameter.VAR_KEYWORD:
+                        # pre-condition: all bound variables should be distinct
+                        assert len(param_value.values()) == len(
+                            set(param_value.values())
+                        )
+                        param_bound_vars = set(param_value.values())
+                    else:
+                        param_bound_vars = {param_value}
+                elif param_ordinal:  # Only process if there's a Scoped annotation
+                    # We can't use flatten here because we want to be able
+                    # to see dict keys
+                    def extract_operations(obj):
+                        if isinstance(obj, Operation):
+                            param_bound_vars.add(obj)
+                        elif isinstance(obj, dict):
+                            for k, v in obj.items():
+                                extract_operations(k)
+                                extract_operations(v)
+                        elif isinstance(obj, list | set | tuple):
+                            for v in obj:
+                                extract_operations(v)
+
+                    extract_operations(param_value)
 
                 # pre-condition: all bound variables should be distinct
-                assert not bound_vars & param_bound_vars
-
-                bound_vars |= param_bound_vars
+                if param_bound_vars:
+                    assert not bound_vars & param_bound_vars
+                    bound_vars |= param_bound_vars
 
         return bound_vars
 
 
 @functools.singledispatch
-def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
+def defop[**P, T](
+    t: Callable[P, T], *, name: str | None = None, freshening=list[int] | None
+) -> Operation[P, T]:
     """Creates a fresh :class:`Operation`.
 
     :param t: May be a type, callable, or :class:`Operation`. If a type, the
@@ -411,13 +422,13 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
     * Defining an operation with no default rule:
 
       We can use :func:`defop` and the
-      :exc:`NotImplementedError` exception to define an
+      :exc:`NotHandled` exception to define an
       operation with no default rule:
 
       >>> @defop
       ... def add(x: int, y: int) -> int:
-      ...     raise NotImplementedError
-      >>> add(1, 2)
+      ...     raise NotHandled
+      >>> print(str(add(1, 2)))
       add(1, 2)
 
       When an operation has no default rule, the free rule is used instead, which
@@ -428,15 +439,14 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
 
       Passing :func:`defop` a type is a handy way to create a free variable.
 
-      >>> import effectful.handlers.operator
       >>> from effectful.ops.semantics import evaluate
       >>> x = defop(int, name='x')
       >>> y = x() + 1
 
       ``y`` is free in ``x``, so it is not fully evaluated:
 
-      >>> y
-      add(x(), 1)
+      >>> print(str(y))
+      __add__(x(), 1)
 
       We bind ``x`` by installing a handler for it:
 
@@ -449,7 +459,8 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
         Because the result of :func:`defop` is always fresh, it's important to
         be careful with variable identity.
 
-        Two variables with the same name are not equal:
+        Two operations with the same name that come from different calls to
+        ``defop`` are not equal:
 
         >>> x1 = defop(int, name='x')
         >>> x2 = defop(int, name='x')
@@ -460,24 +471,22 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
         operation object. In this example, ``scale`` returns a term with a free
         variable ``x``:
 
-        >>> import effectful.handlers.operator
+        >>> x = defop(float, name='x')
         >>> def scale(a: float) -> float:
-        ...     x = defop(float, name='x')
         ...     return x() * a
 
-        Binding the variable ``x`` by creating a fresh operation object does not
+        Binding the variable ``x`` as follows does not work:
 
         >>> term = scale(3.0)
-        >>> x = defop(float, name='x')
-        >>> with handler({x: lambda: 2.0}):
-        ...     print(evaluate(term))
-        mul(x(), 3.0)
+        >>> fresh_x = defop(float, name='x')
+        >>> with handler({fresh_x: lambda: 2.0}):
+        ...     print(str(evaluate(term)))
+        __mul__(x(), 3.0)
 
-        This does:
+        Only the original operation object will work:
 
         >>> from effectful.ops.semantics import fvsof
-        >>> correct_x = [v for v in fvsof(term) if str(x) == 'x'][0]
-        >>> with handler({correct_x: lambda: 2.0}):
+        >>> with handler({x: lambda: 2.0}):
         ...     print(evaluate(term))
         6.0
 
@@ -487,7 +496,7 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
       the same name and signature, but no default rule.
 
       >>> fresh_select = defop(select)
-      >>> fresh_select(1, 2)
+      >>> print(str(fresh_select(1, 2)))
       select(1, 2)
 
       The new operation is distinct from the original:
@@ -504,17 +513,24 @@ def defop(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
     raise NotImplementedError(f"expected type or callable, got {t}")
 
 
-@defop.register(typing.cast(Type[collections.abc.Callable], collections.abc.Callable))
-class _BaseOperation(Generic[Q, V], Operation[Q, V]):
+@defop.register(typing.cast(type[collections.abc.Callable], collections.abc.Callable))
+class _BaseOperation[**Q, V](Operation[Q, V]):
     __signature__: inspect.Signature
     __name__: str
 
     _default: Callable[Q, V]
 
-    def __init__(self, default: Callable[Q, V], *, name: Optional[str] = None):
+    def __init__(
+        self,
+        default: Callable[Q, V],
+        *,
+        name: str | None = None,
+        freshening: list[int] | None = None,
+    ):
         functools.update_wrapper(self, default)
         self._default = default
         self.__name__ = name or default.__name__
+        self._freshening = freshening or []
         self.__signature__ = inspect.signature(default)
 
     def __eq__(self, other):
@@ -522,21 +538,30 @@ class _BaseOperation(Generic[Q, V], Operation[Q, V]):
             return NotImplemented
         return self is other
 
+    def __lt__(self, other):
+        if not isinstance(other, Operation):
+            return NotImplemented
+        return id(self) < id(other)
+
     def __hash__(self):
         return hash(self._default)
 
     def __default_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> "Expr[V]":
         try:
-            return self._default(*args, **kwargs)
-        except NotImplementedError:
+            try:
+                return self._default(*args, **kwargs)
+            except NotImplementedError:
+                warnings.warn(
+                    "Operations should raise effectful.ops.types.NotHandled instead of NotImplementedError.",
+                    DeprecationWarning,
+                )
+                raise NotHandled
+        except NotHandled:
             return typing.cast(
                 Callable[Concatenate[Operation[Q, V], Q], Expr[V]], defdata
             )(self, *args, **kwargs)
 
-    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> tuple[
-        tuple[collections.abc.Set[Operation], ...],
-        dict[str, collections.abc.Set[Operation]],
-    ]:
+    def __fvs_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> inspect.BoundArguments:
         sig = Scoped.infer_annotations(self.__signature__)
         bound_sig = sig.bind(*args, **kwargs)
         bound_sig.apply_defaults()
@@ -555,115 +580,214 @@ class _BaseOperation(Generic[Q, V], Operation[Q, V]):
                                 param_bound_vars for _ in bound_sig.arguments[name]
                             )
                         elif param.kind is inspect.Parameter.VAR_KEYWORD:
-                            result_sig.kwargs[name] = {
-                                k: param_bound_vars for k in bound_sig.arguments[name]
-                            }
+                            for k in bound_sig.arguments[name]:
+                                result_sig.arguments[name][k] = param_bound_vars
                         else:
                             result_sig.arguments[name] = param_bound_vars
 
-        return tuple(result_sig.args), dict(result_sig.kwargs)
+        return result_sig
 
-    def __type_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> Type[V]:
-        sig = inspect.signature(self._default)
-        bound_sig = sig.bind(*args, **kwargs)
-        bound_sig.apply_defaults()
+    def __type_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> type[V]:
+        from effectful.internals.unification import (
+            freetypevars,
+            nested_type,
+            substitute,
+            unify,
+        )
 
-        anno = sig.return_annotation
-        if anno is inspect.Signature.empty:
-            return typing.cast(Type[V], object)
-        elif isinstance(anno, typing.TypeVar):
-            # rudimentary but sound special-case type inference sufficient for syntax ops:
-            # if the return type annotation is a TypeVar,
-            # look for a parameter with the same annotation and return its type,
-            # otherwise give up and return Any/object
-            for name, param in bound_sig.signature.parameters.items():
-                if param.annotation is anno and param.kind not in (
-                    inspect.Parameter.VAR_POSITIONAL,
-                    inspect.Parameter.VAR_KEYWORD,
-                ):
-                    arg = bound_sig.arguments[name]
-                    tp: Type[V] = type(arg) if not isinstance(arg, type) else arg
-                    return tp
-            return typing.cast(Type[V], object)
-        elif typing.get_origin(anno) is typing.Annotated:
-            tp = typing.get_args(anno)[0]
-            if not typing.TYPE_CHECKING:
-                tp = tp if typing.get_origin(tp) is None else typing.get_origin(tp)
-            return tp
-        elif typing.get_origin(anno) is not None:
-            return typing.get_origin(anno)
-        else:
-            return anno
+        return_anno = self.__signature__.return_annotation
+        if typing.get_origin(return_anno) is typing.Annotated:
+            return_anno = typing.get_args(return_anno)[0]
 
-    def __repr_rule__(self, *args: Q.args, **kwargs: Q.kwargs) -> str:
-        args_str = ", ".join(map(str, args)) if args else ""
-        kwargs_str = (
-            ", ".join(f"{k}={str(v)}" for k, v in kwargs.items()) if kwargs else ""
-        )
+        if return_anno is inspect.Parameter.empty:
+            return typing.cast(type[V], object)
+        elif return_anno is None:
+            return type(None)  # type: ignore
+        elif not freetypevars(return_anno):
+            return return_anno
 
-        ret = f"{self.__name__}({args_str}"
-        if kwargs:
-            ret += f"{', ' if args else ''}"
-        ret += f"{kwargs_str})"
-        return ret
+        type_args = tuple(nested_type(a) for a in args)
+        type_kwargs = {k: nested_type(v) for k, v in kwargs.items()}
+        bound_sig = self.__signature__.bind(*type_args, **type_kwargs)
+        return substitute(return_anno, unify(self.__signature__, bound_sig))  # type: ignore
 
     def __repr__(self):
+        return f"_BaseOperation({self._default}, name={self.__name__}, freshening={self._freshening})"
+
+    def __str__(self):
         return self.__name__
 
+    def __get__(self, instance, owner):
+        if instance is not None:
+            # This is an instance-level operation, so we need to bind the instance
+            return functools.partial(self, instance)
+        else:
+            # This is a static operation, so we return the operation itself
+            return self
+
 
 @defop.register(Operation)
-def _(t: Operation[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
-
+def _[**P, T](t: Operation[P, T], *, name: str | None = None) -> Operation[P, T]:
     @functools.wraps(t)
     def func(*args, **kwargs):
-        raise NotImplementedError
+        raise NotHandled
 
     if name is None:
-        name = (
-            getattr(t, "__name__", str(t))[:10000] + f"__{random.randint(0, 1 << 32)}"
-        )
-    return defop(func, name=name)
+        name = getattr(t, "__name__", str(t))
+    freshening = getattr(t, "_freshening", []) + [random.randint(0, 1 << 32)]
+
+    return defop(func, name=name, freshening=freshening)
 
 
 @defop.register(type)
-def _(t: Type[T], *, name: Optional[str] = None) -> Operation[[], T]:
+@defop.register(typing.cast(type, types.GenericAlias))
+@defop.register(typing.cast(type, typing._GenericAlias))  # type: ignore
+@defop.register(typing.cast(type, types.UnionType))
+def _[T](t: type[T], *, name: str | None = None) -> Operation[[], T]:
     def func() -> t:  # type: ignore
-        raise NotImplementedError
+        raise NotHandled
 
+    freshening = []
     if name is None:
-        name = t.__name__ + f"__{random.randint(0, 1 << 32)}"
-    return typing.cast(Operation[[], T], defop(func, name=name))
+        name = t.__name__
+        freshening = [random.randint(0, 1 << 32)]
+
+    return typing.cast(
+        Operation[[], T],
+        defop(func, name=name, freshening=freshening),
+    )
 
 
 @defop.register(types.BuiltinFunctionType)
-def _(t: Callable[P, T], *, name: Optional[str] = None) -> Operation[P, T]:
-
+def _[**P, T](t: Callable[P, T], *, name: str | None = None) -> Operation[P, T]:
     @functools.wraps(t)
     def func(*args, **kwargs):
-        if not any(isinstance(a, Term) for a in tree.flatten((args, kwargs))):
+        from effectful.ops.semantics import fvsof
+
+        if not fvsof((args, kwargs)):
             return t(*args, **kwargs)
         else:
-            raise NotImplementedError
+            raise NotHandled
 
     return defop(func, name=name)
 
 
+@defop.register(classmethod)
+def _[**P, S, T](  # type: ignore
+    t: classmethod, *, name: str | None = None
+) -> Operation[Concatenate[type[S], P], T]:
+    raise NotImplementedError("classmethod operations are not yet supported")
+
+
+@defop.register(staticmethod)
+class _StaticMethodOperation[**P, S, T](_BaseOperation[P, T]):
+    def __init__(self, default: staticmethod, **kwargs):
+        super().__init__(default=default.__func__, **kwargs)
+
+    def __get__(self, instance: S, owner: type[S] | None = None) -> Callable[P, T]:
+        return self
+
+
+@defop.register(property)
+class _PropertyOperation[S, T](_BaseOperation[[S], T]):
+    def __init__(self, default: property, **kwargs):  # type: ignore
+        assert not default.fset, "property with setter is not supported"
+        assert not default.fdel, "property with deleter is not supported"
+        super().__init__(default=typing.cast(Callable[[S], T], default.fget), **kwargs)
+
+    @typing.overload
+    def __get__(
+        self, instance: None, owner: type[S] | None = None
+    ) -> "_PropertyOperation[S, T]": ...
+
+    @typing.overload
+    def __get__(self, instance: S, owner: type[S] | None = None) -> T: ...
+
+    def __get__(self, instance, owner: type[S] | None = None):
+        if instance is not None:
+            return self(instance)
+        else:
+            return self
+
+
+@defop.register(functools.singledispatchmethod)
+class _SingleDispatchMethodOperation[**P, S, T](_BaseOperation[Concatenate[S, P], T]):
+    _default: Callable[Concatenate[S, P], T]
+
+    def __init__(self, default: functools.singledispatchmethod, **kwargs):  # type: ignore
+        if isinstance(default.func, classmethod):
+            raise NotImplementedError("Operations as classmethod are not yet supported")
+
+        @functools.wraps(default.func)
+        def _wrapper(obj: S, *args: P.args, **kwargs: P.kwargs) -> T:
+            return default.__get__(obj)(*args, **kwargs)
+
+        self._registry: functools.singledispatchmethod = default
+        super().__init__(_wrapper, **kwargs)
+
+    @typing.overload
+    def __get__(
+        self, instance: None, owner: type[S] | None = None
+    ) -> "_SingleDispatchMethodOperation[P, S, T]": ...
+
+    @typing.overload
+    def __get__(self, instance: S, owner: type[S] | None = None) -> Callable[P, T]: ...
+
+    def __get__(self, instance, owner: type[S] | None = None):
+        if instance is not None:
+            return functools.partial(self, instance)
+        else:
+            return self
+
+    @property
+    def register(self):
+        return self._registry.register
+
+    @property
+    def __isabstractmethod__(self):
+        return self._registry.__isabstractmethod__
+
+
+class _SingleDispatchOperation[**P, S, T](_BaseOperation[Concatenate[S, P], T]):
+    _default: "functools._SingleDispatchCallable[T]"
+
+    @property
+    def register(self):
+        return self._default.register
+
+    @property
+    def dispatch(self):
+        return self._default.dispatch
+
+
+if typing.TYPE_CHECKING:
+    defop.register(functools._SingleDispatchCallable)(_SingleDispatchOperation)
+else:
+
+    @typing.runtime_checkable
+    class _SingleDispatchCallable(typing.Protocol):
+        registry: types.MappingProxyType[object, Callable]
+
+        def dispatch(self, cls: type) -> Callable: ...
+        def register(self, cls: type, func: Callable | None = None) -> Callable: ...
+        def _clear_cache(self) -> None: ...
+        def __call__(self, /, *args, **kwargs): ...
+
+    defop.register(_SingleDispatchCallable)(_SingleDispatchOperation)
+
+
 @defop
-def deffn(
-    body: Annotated[T, Scoped[S]],
-    *args: Annotated[Operation, Scoped[S]],
-    **kwargs: Annotated[Operation, Scoped[S]],
-) -> Callable[..., T]:
+def deffn[T, A, B](
+    body: Annotated[T, Scoped[A | B]],
+    *args: Annotated[Operation, Scoped[A]],
+    **kwargs: Annotated[Operation, Scoped[A]],
+) -> Annotated[Callable[..., T], Scoped[B]]:
     """An operation that represents a lambda function.
 
     :param body: The body of the function.
-    :type body: T
     :param args: Operations representing the positional arguments of the function.
-    :type args: Operation
     :param kwargs: Operations representing the keyword arguments of the function.
-    :type kwargs: Operation
     :returns: A callable term.
-    :rtype: Callable[..., T]
 
     :func:`deffn` terms are eliminated by the :func:`call` operation, which
     performs beta-reduction.
@@ -673,11 +797,13 @@ def deffn(
     Here :func:`deffn` is used to define a term that represents the function
     ``lambda x, y=1: 2 * x + y``:
 
-    >>> import effectful.handlers.operator
+    >>> import random
+    >>> random.seed(0)
+
     >>> x, y = defop(int, name='x'), defop(int, name='y')
     >>> term = deffn(2 * x() + y(), x, y=y)
-    >>> term
-    deffn(add(mul(2, x()), y()), x, y=y)
+    >>> print(str(term))  # doctest: +ELLIPSIS
+    deffn(...)
     >>> term(3, y=4)
     10
 
@@ -688,14 +814,14 @@ def deffn(
       automatically create the right free variables.
 
     """
-    raise NotImplementedError
+    raise NotHandled
 
 
-class _CustomSingleDispatchCallable(Generic[P, Q, S, T]):
+class _CustomSingleDispatchCallable[**P, **Q, S, T]:
     def __init__(
         self, func: Callable[Concatenate[Callable[[type], Callable[Q, S]], P], T]
     ):
-        self._func = func
+        self.func = func
         self._registry = functools.singledispatch(func)
         functools.update_wrapper(self, func)
 
@@ -708,31 +834,32 @@ class _CustomSingleDispatchCallable(Generic[P, Q, S, T]):
         return self._registry.register
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        return self._func(self.dispatch, *args, **kwargs)
+        return self.func(self.dispatch, *args, **kwargs)
 
 
-@_CustomSingleDispatchCallable
-def defterm(__dispatch: Callable[[type], Callable[[T], Expr[T]]], value: T):
-    """Convert a value to a term, using the type of the value to dispatch.
+@defop.register(_CustomSingleDispatchCallable)
+class _CustomSingleDispatchOperation[**P, **Q, S, T](_BaseOperation[P, T]):
+    _default: _CustomSingleDispatchCallable[P, Q, S, T]
 
-    :param value: The value to convert.
-    :type value: T
-    :returns: A term.
-    :rtype: Expr[T]
+    def __init__(self, default: _CustomSingleDispatchCallable[P, Q, S, T], **kwargs):
+        super().__init__(default, **kwargs)
+        self.__signature__ = inspect.signature(functools.partial(default.func, None))  # type: ignore
 
-    **Example usage**:
+    @property
+    def dispatch(self):
+        return self._registry.dispatch
 
-    :func:`defterm` can be passed a function, and it will convert that function
-    to a term by calling it with appropriately typed free variables:
+    @property
+    def register(self):
+        return self._registry.register
 
-    >>> def incr(x: int) -> int:
-    ...     return x + 1
-    >>> term = defterm(incr)
-    >>> term
-    deffn(add(int(), 1), int)
-    >>> term(2)
-    3
 
+@_CustomSingleDispatchCallable
+def defterm[T](__dispatch: Callable[[type], Callable[[T], Expr[T]]], value: T):
+    """Convert a value to a term, using the type of the value to dispatch.
+
+    :param value: The value to convert.
+    :returns: A term.
     """
     if isinstance(value, Term):
         return value
@@ -741,7 +868,7 @@ def defterm(__dispatch: Callable[[type], Callable[[T], Expr[T]]], value: T):
 
 
 @_CustomSingleDispatchCallable
-def defdata(
+def defdata[T](
     __dispatch: Callable[[type], Callable[..., Expr[T]]],
     op: Operation[..., T],
     *args,
@@ -766,7 +893,8 @@ def defdata(
 
     .. code-block:: python
 
-      class _CallableTerm(Generic[P, T], Term[collections.abc.Callable[P, T]]):
+      @defdata.register(collections.abc.Callable)
+      class _CallableTerm[**P, T](Term[collections.abc.Callable[P, T]]):
           def __init__(
               self,
               op: Operation[..., T],
@@ -789,52 +917,40 @@ def defdata(
           def kwargs(self):
               return self._kwargs
 
-          def __call__(self, *args: Expr, **kwargs: Expr) -> Expr[T]:
-              from effectful.ops.semantics import call
-
-              return call(self, *args, **kwargs)
-
-      @defdata.register(collections.abc.Callable)
-      def _(op, *args, **kwargs):
-          return _CallableTerm(op, *args, **kwargs)
+          @defop
+          def __call__(self: collections.abc.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+              ...
 
     When an Operation whose return type is `Callable` is passed to :func:`defdata`,
     it is reconstructed as a :class:`_CallableTerm`, which implements the :func:`__call__` method.
     """
     from effectful.ops.semantics import apply, evaluate, typeof
 
-    arg_ctxs, kwarg_ctxs = op.__fvs_rule__(*args, **kwargs)
+    bindings: inspect.BoundArguments = op.__fvs_rule__(*args, **kwargs)
     renaming = {
         var: defop(var)
-        for bound_vars in (*arg_ctxs, *kwarg_ctxs.values())
+        for bound_vars in (*bindings.args, *bindings.kwargs.values())
         for var in bound_vars
     }
 
-    args_, kwargs_ = list(args), dict(kwargs)
-    for i, (v, c) in (
-        *enumerate(zip(args, arg_ctxs)),
-        *{k: (v, kwarg_ctxs[k]) for k, v in kwargs.items()}.items(),
-    ):
-        if c:
-            v = tree.map_structure(
-                lambda a: renaming.get(a, a) if isinstance(a, Operation) else a, v
-            )
-            res = evaluate(
-                v,
-                intp={
-                    apply: lambda _, op, *a, **k: defdata(op, *a, **k),
-                    **{op: renaming[op] for op in c},
-                },
-            )
-            if isinstance(i, int):
-                args_[i] = res
-            elif isinstance(i, str):
-                kwargs_[i] = res
+    renamed_args: inspect.BoundArguments = op.__signature__.bind(*args, **kwargs)
+    renamed_args.apply_defaults()
 
-    tp: Type[T] = typeof(
-        __dispatch(typing.cast(Type[T], object))(op, *args_, **kwargs_)
-    )
-    return __dispatch(tp)(op, *args_, **kwargs_)
+    args_ = [
+        evaluate(
+            arg, intp={apply: defdata, **{v: renaming[v] for v in bindings.args[i]}}
+        )
+        for i, arg in enumerate(renamed_args.args)
+    ]
+    kwargs_ = {
+        k: evaluate(
+            arg, intp={apply: defdata, **{v: renaming[v] for v in bindings.kwargs[k]}}
+        )
+        for k, arg in renamed_args.kwargs.items()
+    }
+
+    base_term = __dispatch(typing.cast(type[T], object))(op, *args_, **kwargs_)
+    return __dispatch(typeof(base_term))(op, *args_, **kwargs_)
 
 
 @defterm.register(object)
@@ -842,12 +958,12 @@ def defdata(
 @defterm.register(Term)
 @defterm.register(type)
 @defterm.register(types.BuiltinFunctionType)
-def _(value: T) -> T:
+def _[T](value: T) -> T:
     return value
 
 
 @defdata.register(object)
-class _BaseTerm(Generic[T], Term[T]):
+class _BaseTerm[T](Term[T]):
     _op: Operation[..., T]
     _args: collections.abc.Sequence[Expr]
     _kwargs: collections.abc.Mapping[str, Expr]
@@ -881,17 +997,55 @@ class _BaseTerm(Generic[T], Term[T]):
 
 
 @defdata.register(collections.abc.Callable)
-class _CallableTerm(Generic[P, T], _BaseTerm[collections.abc.Callable[P, T]]):
-    def __call__(self, *args: Expr, **kwargs: Expr) -> Expr[T]:
-        from effectful.ops.semantics import call
+class _CallableTerm[**P, T](_BaseTerm[collections.abc.Callable[P, T]]):
+    @defop
+    def __call__(
+        self: collections.abc.Callable[P, T], *args: P.args, **kwargs: P.kwargs
+    ) -> T:
+        from effectful.ops.semantics import evaluate, fvsof, handler
+
+        if isinstance(self, Term) and self.op is deffn:
+            body: Expr[Callable[P, T]] = self.args[0]
+            argvars: tuple[Operation, ...] = self.args[1:]
+            kwvars: dict[str, Operation] = self.kwargs
+            subs = {
+                **{v: functools.partial(lambda x: x, a) for v, a in zip(argvars, args)},
+                **{
+                    kwvars[k]: functools.partial(lambda x: x, kwargs[k]) for k in kwargs
+                },
+            }
+            with handler(subs):
+                return evaluate(body)
+        elif not fvsof((self, args, kwargs)):
+            return self(*args, **kwargs)
+        else:
+            raise NotHandled
+
+
+def trace[**P, T](value: Callable[P, T]) -> Callable[P, T]:
+    """Convert a callable to a term by calling it with appropriately typed free variables.
+
+    **Example usage**:
+
+    :func:`trace` can be passed a function, and it will convert that function to
+    a term by calling it with appropriately typed free variables:
 
-        return call(self, *args, **kwargs)  # type: ignore
+    >>> def incr(x: int) -> int:
+    ...     return x + 1
+    >>> term = trace(incr)
 
+    >>> print(str(term))
+    deffn(__add__(int(), 1), int)
 
-@defterm.register(collections.abc.Callable)
-def _(value: Callable[P, T]) -> Expr[Callable[P, T]]:
+    >>> term(2)
+    3
+
+    """
     from effectful.internals.runtime import interpreter
-    from effectful.ops.semantics import apply, call
+    from effectful.ops.semantics import apply
+
+    call = defdata.dispatch(collections.abc.Callable).__call__
+    assert isinstance(call, Operation)
 
     assert not isinstance(value, Term)
 
@@ -912,12 +1066,7 @@ def _(value: Callable[P, T]) -> Expr[Callable[P, T]]:
     )
     bound_sig.apply_defaults()
 
-    with interpreter(
-        {
-            apply: lambda _, op, *a, **k: defdata(op, *a, **k),
-            call: call.__default_rule__,
-        }
-    ):
+    with interpreter({apply: defdata, call: call.__default_rule__}):
         body = value(
             *[a() for a in bound_sig.args],
             **{k: v() for k, v in bound_sig.kwargs.items()},
@@ -926,38 +1075,115 @@ def _(value: Callable[P, T]) -> Expr[Callable[P, T]]:
     return deffn(body, *bound_sig.args, **bound_sig.kwargs)
 
 
-def syntactic_eq(x: Expr[T], other: Expr[T]) -> bool:
+@defop
+def defstream[S, T, A, B](
+    body: Annotated[T, Scoped[A | B]],
+    streams: Annotated[Mapping[Operation[[], S], Iterable[S]], Scoped[B]],
+) -> Annotated[Iterable[T], Scoped[A]]:
+    """A higher-order operation that represents a for-expression."""
+    raise NotHandled
+
+
+@defdata.register(collections.abc.Iterable)
+class _IterableTerm[T](_BaseTerm[collections.abc.Iterable[T]]):
+    @defop
+    def __iter__(self: collections.abc.Iterable[T]) -> collections.abc.Iterator[T]:
+        if not isinstance(self, Term):
+            return iter(self)
+        else:
+            raise NotHandled
+
+
+@defdata.register(collections.abc.Iterator)
+class _IteratorTerm[T](_IterableTerm[T]):
+    @defop
+    def __next__(self: collections.abc.Iterator[T]) -> T:
+        if not isinstance(self, Term):
+            return next(self)
+        else:
+            raise NotHandled
+
+
+iter_ = _IterableTerm.__iter__
+next_ = _IteratorTerm.__next__
+
+
+@_CustomSingleDispatchCallable
+def syntactic_eq(
+    __dispatch: Callable[[type], Callable[[Any, Any], bool]], x, other
+) -> bool:
     """Syntactic equality, ignoring the interpretation of the terms.
 
     :param x: A term.
-    :type x: Expr[T]
     :param other: Another term.
-    :type other: Expr[T]
     :returns: ``True`` if the terms are syntactically equal and ``False`` otherwise.
     """
-    if isinstance(x, Term) and isinstance(other, Term):
-        op, args, kwargs = x.op, x.args, x.kwargs
-        op2, args2, kwargs2 = other.op, other.args, other.kwargs
-        try:
-            tree.assert_same_structure(
-                (op, args, kwargs), (op2, args2, kwargs2), check_types=True
-            )
-        except (TypeError, ValueError):
-            return False
-        return all(
-            tree.flatten(
-                tree.map_structure(
-                    syntactic_eq, (op, args, kwargs), (op2, args2, kwargs2)
-                )
-            )
+    if (
+        dataclasses.is_dataclass(x)
+        and not isinstance(x, type)
+        and dataclasses.is_dataclass(other)
+        and not isinstance(other, type)
+    ):
+        return type(x) == type(other) and syntactic_eq(
+            {field.name: getattr(x, field.name) for field in dataclasses.fields(x)},
+            {
+                field.name: getattr(other, field.name)
+                for field in dataclasses.fields(other)
+            },
         )
-    elif isinstance(x, Term) or isinstance(other, Term):
+    else:
+        return __dispatch(type(x))(x, other)
+
+
+@syntactic_eq.register
+def _(x: Term, other) -> bool:
+    if not isinstance(other, Term):
         return False
+
+    op, args, kwargs = x.op, x.args, x.kwargs
+    op2, args2, kwargs2 = other.op, other.args, other.kwargs
+    return (
+        op == op2
+        and len(args) == len(args2)
+        and set(kwargs) == set(kwargs2)
+        and all(syntactic_eq(a, b) for a, b in zip(args, args2))
+        and all(syntactic_eq(kwargs[k], kwargs2[k]) for k in kwargs)
+    )
+
+
+@syntactic_eq.register
+def _(x: collections.abc.Mapping, other) -> bool:
+    return isinstance(other, collections.abc.Mapping) and all(
+        k in x and k in other and syntactic_eq(x[k], other[k])
+        for k in set(x) | set(other)
+    )
+
+
+@syntactic_eq.register
+def _(x: collections.abc.Sequence, other) -> bool:
+    if (
+        isinstance(x, tuple)
+        and hasattr(x, "_fields")
+        and all(hasattr(x, f) for f in x._fields)
+    ):
+        return type(other) == type(x) and all(
+            syntactic_eq(getattr(x, f), getattr(other, f)) for f in x._fields
+        )
     else:
-        return x == other
+        return (
+            isinstance(other, collections.abc.Sequence)
+            and len(x) == len(other)
+            and all(syntactic_eq(a, b) for a, b in zip(x, other))
+        )
+
 
+@syntactic_eq.register(object)
+@syntactic_eq.register(str | bytes)
+def _(x: object, other) -> bool:
+    return x == other
 
-class ObjectInterpretation(Generic[T, V], Interpretation[T, V]):
+
+class ObjectInterpretation[T, V](collections.abc.Mapping):
     """A helper superclass for defining an ``Interpretation`` of many
     :class:`~effectful.ops.types.Operation` instances with shared state or behavior.
 
@@ -1034,8 +1260,8 @@ class ObjectInterpretation(Generic[T, V], Interpretation[T, V]):
         return self.implementations[item].__get__(self, type(self))
 
 
-class _ImplementedOperation(Generic[P, Q, T, V]):
-    impl: Optional[Callable[Q, V]]
+class _ImplementedOperation[**P, **Q, T, V]:
+    impl: Callable[Q, V] | None
     op: Operation[P, T]
 
     def __init__(self, op: Operation[P, T]):
@@ -1059,7 +1285,7 @@ class _ImplementedOperation(Generic[P, Q, T, V]):
         owner._temporary_implementations[self.op] = self.impl
 
 
-def implements(op: Operation[P, V]):
+def implements[**P, V](op: Operation[P, V]):
     """Marks a method in an :class:`ObjectInterpretation` as the implementation of a
     particular abstract :class:`Operation`.
 
@@ -1068,3 +1294,348 @@ def implements(op: Operation[P, V]):
 
     """
     return _ImplementedOperation(op)
+
+
+@defdata.register(numbers.Number)
+@functools.total_ordering
+class _NumberTerm[T: numbers.Number](_BaseTerm[T], numbers.Number):
+    def __hash__(self):
+        return id(self)
+
+    def __complex__(self) -> complex:
+        raise ValueError("Cannot convert term to complex number")
+
+    def __float__(self) -> float:
+        raise ValueError("Cannot convert term to float")
+
+    def __int__(self) -> int:
+        raise ValueError("Cannot convert term to int")
+
+    def __bool__(self) -> bool:
+        raise ValueError("Cannot convert term to bool")
+
+    @defop  # type: ignore[prop-decorator]
+    @property
+    def real(self) -> float:
+        if not isinstance(self, Term):
+            return self.real
+        else:
+            raise NotHandled
+
+    @defop  # type: ignore[prop-decorator]
+    @property
+    def imag(self) -> float:
+        if not isinstance(self, Term):
+            return self.imag
+        else:
+            raise NotHandled
+
+    @defop
+    def conjugate(self) -> complex:
+        if not isinstance(self, Term):
+            return self.conjugate()
+        else:
+            raise NotHandled
+
+    @defop  # type: ignore[prop-decorator]
+    @property
+    def numerator(self) -> int:
+        if not isinstance(self, Term):
+            return self.numerator
+        else:
+            raise NotHandled
+
+    @defop  # type: ignore[prop-decorator]
+    @property
+    def denominator(self) -> int:
+        if not isinstance(self, Term):
+            return self.denominator
+        else:
+            raise NotHandled
+
+    @defop
+    def __abs__(self) -> float:
+        """Return the absolute value of the term."""
+        if not isinstance(self, Term):
+            return self.__abs__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __neg__(self: T) -> T:
+        if not isinstance(self, Term):
+            return self.__neg__()  # type: ignore
+        else:
+            raise NotHandled
+
+    @defop
+    def __pos__(self: T) -> T:
+        if not isinstance(self, Term):
+            return self.__pos__()  # type: ignore
+        else:
+            raise NotHandled
+
+    @defop
+    def __trunc__(self) -> int:
+        if not isinstance(self, Term):
+            return self.__trunc__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __floor__(self) -> int:
+        if not isinstance(self, Term):
+            return self.__floor__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __ceil__(self) -> int:
+        if not isinstance(self, Term):
+            return self.__ceil__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __round__(self, ndigits: int | None = None) -> numbers.Real:
+        if not isinstance(self, Term) and not isinstance(ndigits, Term):
+            return self.__round__(ndigits)
+        else:
+            raise NotHandled
+
+    @defop
+    def __invert__(self) -> int:
+        if not isinstance(self, Term):
+            return self.__invert__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __index__(self) -> int:
+        if not isinstance(self, Term):
+            return self.__index__()
+        else:
+            raise NotHandled
+
+    @defop
+    def __eq__(self, other) -> bool:  # type: ignore[override]
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return self.__eq__(other)
+        else:
+            return syntactic_eq(self, other)
+
+    @defop
+    def __lt__(self, other) -> bool:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return self.__lt__(other)
+        else:
+            raise NotHandled
+
+    @defop
+    def __add__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__add__(self, other)
+        else:
+            raise NotHandled
+
+    def __radd__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__add__(self)
+        elif not isinstance(other, Term):
+            return type(self).__add__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __sub__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__sub__(self, other)
+        else:
+            raise NotHandled
+
+    def __rsub__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__sub__(self)
+        elif not isinstance(other, Term):
+            return type(self).__sub__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __mul__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__mul__(self, other)
+        else:
+            raise NotHandled
+
+    def __rmul__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__mul__(self)
+        elif not isinstance(other, Term):
+            return type(self).__mul__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __truediv__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__truediv__(self, other)
+        else:
+            raise NotHandled
+
+    def __rtruediv__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__truediv__(self)
+        elif not isinstance(other, Term):
+            return type(self).__truediv__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __floordiv__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__floordiv__(self, other)
+        else:
+            raise NotHandled
+
+    def __rfloordiv__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__floordiv__(self)
+        elif not isinstance(other, Term):
+            return type(self).__floordiv__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __mod__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__mod__(self, other)
+        else:
+            raise NotHandled
+
+    def __rmod__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__mod__(self)
+        elif not isinstance(other, Term):
+            return type(self).__mod__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __pow__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__pow__(self, other)
+        else:
+            raise NotHandled
+
+    def __rpow__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__pow__(self)
+        elif not isinstance(other, Term):
+            return type(self).__pow__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __lshift__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__lshift__(self, other)
+        else:
+            raise NotHandled
+
+    def __rlshift__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__lshift__(self)
+        elif not isinstance(other, Term):
+            return type(self).__lshift__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __rshift__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__rshift__(self, other)
+        else:
+            raise NotHandled
+
+    def __rrshift__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__rshift__(self)
+        elif not isinstance(other, Term):
+            return type(self).__rshift__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __and__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__and__(self, other)
+        else:
+            raise NotHandled
+
+    def __rand__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__and__(self)
+        elif not isinstance(other, Term):
+            return type(self).__and__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __xor__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__xor__(self, other)
+        else:
+            raise NotHandled
+
+    def __rxor__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__xor__(self)
+        elif not isinstance(other, Term):
+            return type(self).__xor__(other, self)
+        else:
+            return NotImplemented
+
+    @defop
+    def __or__(self, other: T) -> T:
+        if not isinstance(self, Term) and not isinstance(other, Term):
+            return operator.__or__(self, other)
+        else:
+            raise NotHandled
+
+    def __ror__(self, other):
+        if isinstance(other, Term) and isinstance(other, type(self)):
+            return other.__or__(self)
+        elif not isinstance(other, Term):
+            return type(self).__or__(other, self)
+        else:
+            return NotImplemented
+
+
+@defdata.register(numbers.Complex)
+@numbers.Complex.register
+class _ComplexTerm[T: numbers.Complex](_NumberTerm[T]):
+    pass
+
+
+@defdata.register(numbers.Real)
+@numbers.Real.register
+class _RealTerm[T: numbers.Real](_ComplexTerm[T]):
+    pass
+
+
+@defdata.register(numbers.Rational)
+@numbers.Rational.register
+class _RationalTerm[T: numbers.Rational](_RealTerm[T]):
+    pass
+
+
+@defdata.register(numbers.Integral)
+@numbers.Integral.register
+class _IntegralTerm[T: numbers.Integral](_RationalTerm[T]):
+    pass
+
+
+@defdata.register(bool)
+class _BoolTerm[T: bool](_IntegralTerm[T]):  # type: ignore
+    pass