fix bug

Author: eb8680

effectful/ops/semantics.py

@@ -302,20 +302,28 @@ def _evaluate_iterator(expr, **kwargs):
     except (TypeError, AttributeError):
         return expr  # un-reducible iterators are opaque, like any object we can't recurse into
 
-    if ctor is iter:
-        result = ctor(*evaluate(args))
-    else:
-        from effectful.internals.unification import nested_type
+    from effectful.internals.unification import nested_type
 
-        ExprType = nested_type(expr).value
+    ExprType = nested_type(expr).value
 
-        @Operation.define
-        def ctor_op(*args) -> ExprType:
-            return ctor(*args)
+    @Operation.define
+    def ctor_op(*args) -> ExprType:
+        return ctor(*args)
 
-        result = ctor_op(*evaluate(args))
+    # Reify through ``ctor_op`` rather than calling the live constructor: when
+    # the evaluated args contain a ``Term`` the result is a structural ``Term``
+    # node whose source iterables stay traversable (so ``fvsof`` finds their
+    # free variables and term-reconstruction interpretations can rewrite them).
+    # For fully concrete args ``ctor_op``'s default rule rebuilds the live
+    # iterator, preserving laziness.
+    result = ctor_op(*evaluate(args))
 
-    if state and state[0] is not None and hasattr(result, "__setstate__"):
+    if (
+        not isinstance(result, Term)
+        and state
+        and state[0] is not None
+        and hasattr(result, "__setstate__")
+    ):
         result.__setstate__(
             evaluate(state[0])
         )  # preserve position so advanced iterators don't reset

tests/test_ops_syntax.py

@@ -525,6 +525,36 @@ def cons_iterable(*args: int) -> Iterable[int]:
     assert list(tm.args) == [1, 2, 3]
 
 
+def test_defdata_preserves_free_vars_in_iterator_arg():
+    """Free variables inside a builtin iterator argument must survive term
+    construction.
+
+    A ``map`` object is a lazy iterator that can close over free variables --
+    here ``x`` via the element ``x()``. When such an iterator is passed as an
+    argument to an operation, ``defdata`` reconstructs the term and should
+    preserve those free variables. Currently the iterator is reconstructed as an
+    opaque iterator that no longer references ``x``, so ``x`` is silently dropped
+    from the constructed term's free variables (and can no longer be
+    substituted).
+    """
+
+    @defop
+    def g(xs: Iterable[int]) -> int:
+        raise NotHandled
+
+    x = defop(int, name="x")
+
+    def keep(v: int) -> int:
+        return v
+
+    # Sanity: the raw map closes over ``x``.
+    assert x in fvsof(map(keep, [x()]))
+
+    # Passing it to ``g`` must not drop ``x`` from the term's free variables.
+    term = g(map(keep, [x()]))
+    assert x in fvsof(term)
+
+
 def test_defstream_1():
     x = defop(int, name="x")
     y = defop(int, name="y")