effectful 0.2.0__tar.gz → 0.2.2__tar.gz

{effectful-0.2.0 → effectful-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effectful
-Version: 0.2.0
+Version: 0.2.2
 Summary: Metaprogramming infrastructure
 Author: Basis
 License-Expression: Apache-2.0
@@ -15,7 +15,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.12
+Requires-Python: <3.14,>=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Provides-Extra: torch

{effectful-0.2.0 → effectful-0.2.2}/effectful/handlers/indexed.py

@@ -233,7 +233,8 @@ def gather(value: torch.Tensor, indexset: IndexSet) -> torch.Tensor:
         if k in indexset_vars
     }
 
-    return deffn(value, *binding.keys())(*[v() for v in binding.values()])
+    args = [v() for v in binding.values()]
+    return deffn(value, *binding.keys())(*args)
 
 
 def stack(

effectful-0.2.2/effectful/internals/product_n.py

@@ -0,0 +1,163 @@
+import dataclasses
+import functools
+from collections.abc import Callable, Mapping
+from typing import Any
+
+import tree
+
+from effectful.ops.semantics import apply, coproduct, handler
+from effectful.ops.syntax import defop
+from effectful.ops.types import Interpretation, Operation
+
+
+@dataclasses.dataclass
+class CallByNeed[**P, T]:
+    func: Callable[P, T]
+    args: Any  # P.args
+    kwargs: Any  # P.kwargs
+    value: T | None = None
+    initialized: bool = False
+
+    def __init__(self, func, *args, **kwargs):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self):
+        if not self.initialized:
+            self.value = self.func(*self.args, **self.kwargs)
+            self.initialized = True
+        return self.value
+
+
+@defop
+def argsof(op: Operation) -> tuple[list, dict]:
+    raise RuntimeError("Prompt argsof not bound.")
+
+
+@dataclasses.dataclass
+class Product[S, T]:
+    values: object
+
+
+def _pack(intp):
+    from effectful.internals.runtime import interpreter
+
+    return Product(interpreter(intp)(lambda x: x()))
+
+
+def _unpack(x, prompt):
+    if isinstance(x, Product):
+        return x.values(prompt)
+    return x
+
+
+def productN(intps: Mapping[Operation, Interpretation]) -> Interpretation:
+    # The resulting interpretation supports ops that exist in at least one input
+    # interpretation
+    result_ops = set(op for intp in intps.values() for op in intp)
+    if result_ops is None:
+        return {}
+
+    renaming = {(prompt, op): defop(op) for prompt in intps for op in result_ops}
+
+    # We enforce isolation between the named interpretations by giving every
+    # operation a fresh name and giving each operation a translation from
+    # the fresh names back to the names from their interpretation.
+    #
+    # E.g. { a: { f, g }, b: { f, h } } =>
+    # { handler({f: f_a, g: g_a, h: h_default})(f_a), handler({f: f_a, g: g_a})(g_a),
+    #   handler({f: f_b, h: h_b})(f_b), handler({f: f_b, h: h_b})(h_b) }
+    translation_intps: dict[Operation, Interpretation] = {
+        prompt: {op: renaming[(prompt, op)] for op in result_ops} for prompt in intps
+    }
+
+    # For every prompt, build an isolated interpretation that binds all operations.
+    isolated_intps = {
+        prompt: {
+            renaming[(prompt, op)]: handler(translation_intps[prompt])(func)
+            for op, func in intp.items()
+        }
+        for prompt, intp in intps.items()
+    }
+
+    def product_op(op, *args, **kwargs):
+        """Compute the product of operation `op` in named interpretations
+        `intps`. The product operation consumes product arguments and
+        returns product results. These products are represented as
+        interpretations.
+
+        """
+        assert isinstance(op, Operation)
+
+        result_intp = {}
+
+        def argsof_direct_call(prompt):
+            return result_intp[prompt].args, result_intp[prompt].kwargs
+
+        def argsof_apply(prompt):
+            return result_intp[prompt].args[2:], result_intp[prompt].kwargs
+
+        # Every prompt gets an argsof implementation. The implementation is
+        # either for a direct call to a handler or for a call to an apply
+        # handler.
+        argsof_prompts = {}
+
+        for prompt, intp in intps.items():
+            # Args and kwargs are expected to be either interpretations with
+            # bindings for each named analysis in intps or concrete values.
+            # `get_for_intp` extracts the value that corresponds to this
+            # analysis.
+            #
+            # TODO: `get_for_intp` has to guess whether a dict value is an
+            # interpretation or not. This is probably a latent bug.
+            intp_args, intp_kwargs = tree.map_structure(
+                lambda x: _unpack(x, prompt), (args, kwargs)
+            )
+
+            # Making result a CallByNeed has two functions. It avoids some
+            # work when the result is not requested and it delays evaluation
+            # so that when the result is requested in `get_for_intp`, it
+            # evaluates in a context that binds the results of the other
+            # named interpretations.
+            isolated_intp = isolated_intps[prompt]
+            renamed_op = renaming[(prompt, op)]
+            if op in intp:
+                result = CallByNeed(
+                    handler(isolated_intp)(renamed_op), *intp_args, **intp_kwargs
+                )
+                argsof_impl = argsof_direct_call
+            elif apply in intp:
+                result = CallByNeed(
+                    handler(isolated_intp)(renaming[(prompt, apply)]),
+                    renamed_op,
+                    *intp_args,
+                    **intp_kwargs,
+                )
+                argsof_impl = argsof_apply
+            else:
+                # TODO: If an intp does not handle an operation and has no apply
+                # handler, use the default rule. In the future, we would like to
+                # instead defer to the enclosing interpretation. This is
+                # difficult right now, because the output interpretation handles
+                # all operations with product handlers which would have to be
+                # skipped over.
+                result = CallByNeed(
+                    handler(coproduct(isolated_intp, translation_intps[prompt]))(
+                        op.__default_rule__
+                    ),
+                    *intp_args,
+                    **intp_kwargs,
+                )
+                argsof_impl = argsof_direct_call
+
+            result_intp[prompt] = result
+            argsof_prompts[prompt] = argsof_impl
+
+        result_intp[argsof] = lambda prompt: argsof_prompts[prompt](prompt)
+        return _pack(result_intp)
+
+    product_intp: Interpretation = {
+        op: functools.partial(product_op, op) for op in result_ops
+    }
+    return product_intp

{effectful-0.2.0 → effectful-0.2.2}/effectful/internals/unification.py

@@ -440,9 +440,10 @@ def _(typ: type | abc.ABCMeta):
         return typ
     elif types.get_original_bases(typ):
         for base in types.get_original_bases(typ):
-            cbase = canonicalize(base)
-            if cbase != object:
-                return cbase
+            if typing.get_origin(base) is not typing.Generic:
+                cbase = canonicalize(base)
+                if cbase != object:
+                    return cbase
         return typ
     else:
         raise TypeError(f"Cannot canonicalize type {typ}.")

{effectful-0.2.0 → effectful-0.2.2}/effectful/ops/semantics.py

@@ -250,6 +250,14 @@ def evaluate[T](expr: Expr[T], *, intp: Interpretation | None = None) -> Expr[T]
     elif isinstance(expr, collections.abc.Sequence):
         if isinstance(expr, str | bytes):
             return typing.cast(T, expr)  # mypy doesnt like ignore here, so we use cast
+        elif (
+            isinstance(expr, tuple)
+            and hasattr(expr, "_fields")
+            and all(hasattr(expr, field) for field in getattr(expr, "_fields"))
+        ):  # namedtuple
+            return type(expr)(
+                **{field: evaluate(getattr(expr, field)) for field in expr._fields}
+            )
         else:
             return type(expr)(evaluate(item) for item in expr)  # type: ignore
     elif isinstance(expr, collections.abc.Set):
@@ -274,6 +282,21 @@ def evaluate[T](expr: Expr[T], *, intp: Interpretation | None = None) -> Expr[T]
         return typing.cast(T, expr)
 
 
+def _simple_type(tp: type) -> type:
+    """Convert a type object into a type that can be dispatched on."""
+    if isinstance(tp, typing.TypeVar):
+        tp = (
+            tp.__bound__
+            if tp.__bound__
+            else tp.__constraints__[0]
+            if tp.__constraints__
+            else object
+        )
+    if isinstance(tp, types.UnionType):
+        raise TypeError(f"Union types are not supported: {tp}")
+    return typing.get_origin(tp) or tp
+
+
 def typeof[T](term: Expr[T]) -> type[T]:
     """Return the type of an expression.
 
@@ -302,19 +325,7 @@ def typeof[T](term: Expr[T]) -> type[T]:
         if isinstance(term, Term):
             # If term is a Term, we evaluate it to get its type
             tp = evaluate(term)
-            if isinstance(tp, typing.TypeVar):
-                tp = (
-                    tp.__bound__
-                    if tp.__bound__
-                    else tp.__constraints__[0]
-                    if tp.__constraints__
-                    else object
-                )
-            if isinstance(tp, types.UnionType):
-                raise TypeError(
-                    f"Cannot determine type of {term} because it is a union type: {tp}"
-                )
-            return typing.get_origin(tp) or tp  # type: ignore
+            return _simple_type(typing.cast(type, tp))
         else:
             return type(term)
 

{effectful-0.2.0 → effectful-0.2.2}/effectful/ops/syntax.py

@@ -924,8 +924,12 @@ def defdata[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
+    from effectful.internals.product_n import productN
+    from effectful.internals.runtime import interpreter
+    from effectful.ops.semantics import _simple_type, apply, evaluate
 
+    # If this operation binds variables, we need to rename them in the
+    # appropriate parts of the child term.
     bindings: inspect.BoundArguments = op.__fvs_rule__(*args, **kwargs)
     renaming = {
         var: defop(var)
@@ -933,24 +937,54 @@ def defdata[T](
         for var in bound_vars
     }
 
-    renamed_args: inspect.BoundArguments = op.__signature__.bind(*args, **kwargs)
+    # Analysis for type computation and term reconstruction
+    typ = defop(object, name="typ")
+    cast = defop(object, name="cast")
+
+    def apply_type(op, *args, **kwargs):
+        assert isinstance(op, Operation)
+        tp = op.__type_rule__(*args, **kwargs)
+        return tp
+
+    def apply_cast(op, *args, **kwargs):
+        assert isinstance(op, Operation)
+        full_type = typ()
+        dispatch_type = _simple_type(full_type)
+        return __dispatch(dispatch_type)(op, *args, **kwargs)
+
+    analysis = productN({typ: {apply: apply_type}, cast: {apply: apply_cast}})
+
+    def evaluate_with_renaming(expr, ctx):
+        """Evaluate an expression with renaming applied."""
+        renaming_ctx = {
+            old_var: new_var for old_var, new_var in renaming.items() if old_var in ctx
+        }
+
+        # Note: coproduct cannot be used to compose these interpretations
+        # because evaluate will only do operation replacement when the handler
+        # is operation typed, which coproduct does not satisfy.
+        with interpreter(analysis | renaming_ctx):
+            result = evaluate(expr)
+
+        return result
+
+    renamed_args = op.__signature__.bind(*args, **kwargs)
     renamed_args.apply_defaults()
 
     args_ = [
-        evaluate(
-            arg, intp={apply: defdata, **{v: renaming[v] for v in bindings.args[i]}}
-        )
-        for i, arg in enumerate(renamed_args.args)
+        evaluate_with_renaming(arg, 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()
+        k: evaluate_with_renaming(v, bindings.kwargs[k])
+        for (k, v) in renamed_args.kwargs.items()
     }
 
-    base_term = __dispatch(typing.cast(type[T], object))(op, *args_, **kwargs_)
-    return __dispatch(typeof(base_term))(op, *args_, **kwargs_)
+    # Build the final term with type analysis
+    with interpreter(analysis):
+        result = op(*args_, **kwargs_)
+
+    return result.values(cast)  # type: ignore
 
 
 @defterm.register(object)
@@ -1161,11 +1195,20 @@ def _(x: collections.abc.Mapping, other) -> bool:
 
 @syntactic_eq.register
 def _(x: collections.abc.Sequence, other) -> bool:
-    return (
-        isinstance(other, collections.abc.Sequence)
-        and len(x) == len(other)
-        and all(syntactic_eq(a, b) for a, b in zip(x, other))
-    )
+    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 (
+            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)

{effectful-0.2.0 → effectful-0.2.2}/effectful.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effectful
-Version: 0.2.0
+Version: 0.2.2
 Summary: Metaprogramming infrastructure
 Author: Basis
 License-Expression: Apache-2.0
@@ -15,7 +15,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.12
+Requires-Python: <3.14,>=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE.md
 Provides-Extra: torch

{effectful-0.2.0 → effectful-0.2.2}/effectful.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ effectful/handlers/jax/numpy/__init__.py
 effectful/handlers/jax/numpy/linalg.py
 effectful/handlers/jax/scipy/special.py
 effectful/internals/__init__.py
+effectful/internals/product_n.py
 effectful/internals/runtime.py
 effectful/internals/tensor_utils.py
 effectful/internals/unification.py
@@ -34,6 +35,7 @@ tests/test_handlers_numpyro.py
 tests/test_handlers_pyro.py
 tests/test_handlers_pyro_dist.py
 tests/test_handlers_torch.py
+tests/test_internals_product_n.py
 tests/test_internals_unification.py
 tests/test_ops_semantics.py
 tests/test_ops_syntax.py

{effectful-0.2.0 → effectful-0.2.2}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "effectful"
-version = "0.2.0"
+version = "0.2.2"
 description = "Metaprogramming infrastructure"
 readme = "README.rst"
 license = "Apache-2.0"
-requires-python = ">=3.12"
+requires-python = ">=3.12,<3.14"
 authors = [
     { name = "Basis" },
 ]

{effectful-0.2.0 → effectful-0.2.2}/tests/test_handlers_jax.py

@@ -375,6 +375,14 @@ def test_array_eq():
     assert syntactic_eq(x + y, x + y)
 
 
+def test_jax_rotation():
+    import jax.scipy.spatial.transform
+
+    x = jax.scipy.spatial.transform.Rotation.from_rotvec(jnp.array([1, 2, 3]))
+    y = evaluate(x)
+    assert syntactic_eq(x, y)
+
+
 def test_arrayterm_all():
     """Test .all() method on _ArrayTerm."""
     i = defop(jax.Array, name="i")

effectful-0.2.2/tests/test_internals_product_n.py

@@ -0,0 +1,155 @@
+from effectful.internals.product_n import argsof, productN
+from effectful.ops.semantics import apply, coproduct, evaluate, handler
+from effectful.ops.syntax import defop
+from effectful.ops.types import Interpretation, NotHandled
+
+
+def test_simul_analysis():
+    @defop
+    def plus1(x: int) -> int:
+        raise NotImplementedError
+
+    @defop
+    def plus2(x: int) -> int:
+        raise NotImplementedError
+
+    @defop
+    def times(x: int, y: int) -> int:
+        raise NotImplementedError
+
+    x, y = defop(int, name="x"), defop(int, name="y")
+
+    typ = defop(Interpretation, name="typ")
+    value = defop(Interpretation, name="value")
+
+    type_rules = {
+        plus1: lambda x: int,
+        plus2: lambda x: int,
+        times: lambda x, y: int,
+        x: lambda: int,
+        y: lambda: int,
+    }
+
+    def plus1_value(x):
+        return x + 1
+
+    def plus2_value(x):
+        return plus1(plus1(x))
+
+    def times_value(x, y):
+        if typ() is int and argsof(typ)[0][0] is int:
+            return x * y
+        raise TypeError("unexpected type!")
+
+    value_rules = {
+        plus1: plus1_value,
+        plus2: plus2_value,
+        times: times_value,
+        x: lambda: 3,
+        y: lambda: 4,
+    }
+
+    analysisN = productN({typ: type_rules, value: value_rules})
+
+    def f1():
+        v1 = x()  # {typ: lambda: int, val: lambda: 3}
+        v2 = y()  # {typ: lambda: int, val: lambda: 4}
+        v3 = plus2(v1)  # {typ: lambda: int, val: lambda: 5}
+        v4 = times(v2, v3)  # {typ: lambda: int, val: lambda: 20}
+        v5 = plus1(v4)  # {typ: lambda: int, val: lambda: 21}
+        return v5  # {typ: lambda: int, val: lambda: 21}
+
+    with handler(analysisN):
+        i = f1()
+        t = i.values(typ)
+        v = i.values(value)
+        assert t is int
+        assert v == 21
+
+
+def test_simul_analysis_apply():
+    @defop
+    def plus1[T](x: T) -> T:
+        raise NotHandled
+
+    @defop
+    def plus2[T](x: T) -> T:
+        raise NotHandled
+
+    @defop
+    def times[T](x: T, y: T) -> T:
+        raise NotHandled
+
+    x, y = defop(int, name="x"), defop(int, name="y")
+
+    typ = defop(Interpretation, name="typ")
+    value = defop(Interpretation, name="value")
+
+    def apply_type(op, *a, **k):
+        return op.__type_rule__(*a, **k)
+
+    type_rules = {apply: apply_type}
+
+    def plus1_value(x):
+        return x + 1
+
+    def plus2_value(x):
+        return plus1(plus1(x))
+
+    def times_value(x, y):
+        if typ() is int and argsof(typ)[0][0] is int:
+            return x * y
+        raise TypeError("unexpected type!")
+
+    value_rules = {
+        plus1: plus1_value,
+        plus2: plus2_value,
+        times: times_value,
+        x: lambda: 3,
+        y: lambda: 4,
+    }
+
+    analysisN = productN({typ: type_rules, value: value_rules})
+
+    def f1():
+        v1 = x()  # {typ: lambda: int, val: lambda: 3}
+        v2 = y()  # {typ: lambda: int, val: lambda: 4}
+        v3 = plus2(v1)  # {typ: lambda: int, val: lambda: 5}
+        v4 = times(v2, v3)  # {typ: lambda: int, val: lambda: 20}
+        v5 = plus1(v4)  # {typ: lambda: int, val: lambda: 21}
+        return v5  # {typ: lambda: int, val: lambda: 21}
+
+    with handler(analysisN):
+        i = f1()
+        t = i.values(typ)
+        v = i.values(value)
+        assert t is int
+        assert v == 21
+
+
+def test_productN_distributive():
+    """Test that productN distributes over coproducts."""
+
+    @defop
+    def add[T](x: T, y: T) -> T:
+        raise NotHandled
+
+    x = defop(object, name="x")
+    i = defop(object, name="i")
+    s = defop(object, name="s")
+
+    intp1 = {add: lambda x, y: x + y}
+    intp2 = {x: lambda: 1}
+    intp3 = {x: lambda: "a"}
+
+    term = add(x(), x())
+
+    prod_intp1 = productN({i: coproduct(intp2, intp1), s: coproduct(intp3, intp1)})
+    prod_intp2 = coproduct(
+        productN({i: intp2, s: intp3}), productN({i: intp1, s: intp1})
+    )
+    result1 = evaluate(term, intp=prod_intp1)
+    result2 = evaluate(term, intp=prod_intp2)
+
+    assert result1.values(i) == result2.values(i) == 2
+    assert result1.values(s) == result2.values(s) == "aa"

{effectful-0.2.0 → effectful-0.2.2}/tests/test_internals_unification.py

@@ -110,6 +110,11 @@ def test_canonicalize_1():
         dict[frozenset[int], frozenset[int]]
     )
 
+    class GenericClass[T]:
+        pass
+
+    assert canonicalize(GenericClass[int]) == GenericClass[int]
+
 
 @pytest.mark.parametrize(
     "typ,subs,expected",

{effectful-0.2.0 → effectful-0.2.2}/tests/test_ops_semantics.py

@@ -1,4 +1,5 @@
 import contextlib
+import functools
 import itertools
 import logging
 from collections.abc import Callable
@@ -741,6 +742,47 @@ def test_typeof_generic():
     assert typeof(box_value(42)) is Box
 
 
+def test_defdata_large(benchmark):
+    """Test defdata with large nested operations that form a binary tree of arbitrary size."""
+    import random
+
+    @defop
+    def f[T, A, B](
+        v: Annotated[Operation[[], int], Scoped[A]],
+        x: Annotated[T, Scoped[A | B]],
+        y: Annotated[T, Scoped[A | B]],
+    ) -> Annotated[T, Scoped[B]]:
+        """Generic operation that takes two arguments of the same type and returns that type."""
+        raise NotHandled
+
+    def build_tree(depth: int) -> Any:
+        """
+        Recursively build a binary tree of f operations with the specified depth.
+
+        Args:
+            depth: The depth of the tree (0 means just a leaf)
+            leaf_type: The type of values at the leaves (int, str, etc.)
+            start_value: The starting value for leaf generation
+
+        Returns:
+            A nested tree of f operations with leaves of the specified type
+        """
+        if depth == 0:
+            if random.random() < 0.5:
+                return 0
+            else:
+                return defop(int)()
+
+        # Recursively build left and right subtrees
+        left = build_tree(depth - 1)
+        right = build_tree(depth - 1)
+
+        return f(defop(int), left, right)
+
+    # Test a very large tree (depth 8 = 255 leaf nodes)
+    benchmark(functools.partial(build_tree, 7))
+
+
 def test_evaluate_deep():
     x, y, z = defop(int), defop(int), defop(int)
     intp = {x: deffn(1), y: deffn(2), z: deffn(x() + y())}
@@ -756,7 +798,7 @@ def test_evaluate_deep():
 
 
 def test_fvsof_binder():
-    x, y, z = defop(int), defop(int), defop(int)
+    x, y, z = defop(int, name="x"), defop(int, name="y"), defop(int, name="z")
 
     @defop
     def add(a: int, b: int) -> int:

{effectful-0.2.0 → effectful-0.2.2}/tests/test_ops_syntax.py

@@ -219,6 +219,27 @@ def test_term_str():
     assert str(deffn(x1() + x2(), x1)) == "deffn(__add__(x(), x!1()), x)"
 
 
+def test_defdata_renaming():
+    @defop
+    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 NotHandled
+
+    x, y = defop(int, name="x"), defop(int, name="y")
+
+    # Constructing the term should rename the bound variable x in the right hand
+    # side of the let only.
+    let2 = Let(x, y() + x(), x() + y())
+    assert let2.args[0] != x
+    assert let2.args[1].args[0].op == y
+    assert let2.args[1].args[1].op == x
+    assert let2.args[2].args[0].op == let2.args[0]
+    assert let2.args[2].args[1].op == y
+
+
 def test_defop_singledispatch():
     """Test that defop can be used with singledispatch functions."""
 
@@ -594,6 +615,31 @@ def test_eval_dataclass() -> None:
     )
 
 
+def test_eval_namedtuple() -> None:
+    Point = collections.namedtuple("Point", ["x", "y"])
+    Line = collections.namedtuple("Line", ["start", "end"])
+    Lines = collections.namedtuple("Lines", ["origin", "lines"])
+
+    x, y = defop(int, name="x"), defop(int, name="y")
+    p1 = Point(x(), y())
+    p2 = Point(x() + 1, y() + 1)
+    line = Line(p1, p2)
+    lines = Lines(p1, [line])
+
+    assert {x, y} <= fvsof(lines)
+
+    assert p1 == lines.origin
+
+    with handler({x: lambda: 3, y: lambda: 4}):
+        evaluated_lines = evaluate(lines)
+
+    assert isinstance(evaluated_lines, Lines)
+    assert evaluated_lines == Lines(
+        origin=Point(3, 4),
+        lines=[Line(Point(3, 4), Point(4, 5))],
+    )
+
+
 def test_lambda_calculus_1():
     x, y = defop(int), defop(int)