effectful 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effectful
-Version: 0.2.0
+Version: 0.2.1
 Summary: Metaprogramming infrastructure
 Author: Basis
 License-Expression: Apache-2.0

{effectful-0.2.0 → effectful-0.2.1}/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.1}/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):

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

@@ -1161,11 +1161,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.1}/effectful.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effectful
-Version: 0.2.0
+Version: 0.2.1
 Summary: Metaprogramming infrastructure
 Author: Basis
 License-Expression: Apache-2.0

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "effectful"
-version = "0.2.0"
+version = "0.2.1"
 description = "Metaprogramming infrastructure"
 readme = "README.rst"
 license = "Apache-2.0"

{effectful-0.2.0 → effectful-0.2.1}/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.0 → effectful-0.2.1}/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.1}/tests/test_ops_syntax.py

@@ -594,6 +594,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)