curryparty 0.3.0__tar.gz → 0.3.1__tar.gz

{curryparty-0.3.0 → curryparty-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: curryparty
-Version: 0.3.0
+Version: 0.3.1
 Summary: Python playground to learn lambda calculus
 Author: Antonin P
 Author-email: Antonin P <antonin.peronnet@telecom-paris.fr>

{curryparty-0.3.0 → curryparty-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "curryparty"
-version = "0.3.0"
+version = "0.3.1"
 description = "Python playground to learn lambda calculus"
 readme = "README.md"
 authors = [
@@ -20,4 +20,5 @@ dev = [
     "marimo>=0.18.4",
     "polars>=1.36.1",
     "ruff>=0.14.8",
+    "tuna>=0.5.11",
 ]

{curryparty-0.3.0 → curryparty-0.3.1}/src/curryparty/__init__.py

@@ -44,7 +44,7 @@ class Term:
         return Term(compose(self.nodes, other.nodes))
 
     def beta(self) -> Optional["Term"]:
-        candidates = find_redexes(self.nodes)
+        candidates = find_redexes(self.nodes).first().collect()
         if len(candidates) == 0:
             return None
         _redex, lamb, b = candidates.row(0)
@@ -72,14 +72,14 @@ class Term:
         Generates an HTML representation that toggles visibility between
         a static state and a SMIL animation on hover using pure CSS.
         """
-        candidates = find_redexes(self.nodes)
+        candidates = find_redexes(self.nodes).first().collect()
         if len(candidates) == 0:
             return self._repr_html_()
 
         _redex, lamb, b = candidates.row(0)
         new_nodes = beta_reduce(self.nodes, lamb, b)
-        vars = find_variables(self.nodes, lamb)["id"]
-        b_subtree = subtree(self.nodes, b)
+        vars = find_variables(self.nodes, lamb).collect()["id"]
+        b_subtree = subtree(self.nodes, b).collect()
         height = min(compute_height(self.nodes), compute_height(new_nodes)) * 2
         if count_variables(self.nodes) == 0:
             return "no width"

{curryparty-0.3.0 → curryparty-0.3.1}/src/curryparty/core.py

@@ -1,6 +1,5 @@
 import polars as pl
 from polars import Schema, UInt32
-from polars.functions.lazy import coalesce
 
 SCHEMA = Schema(
     {
@@ -21,7 +20,7 @@ def _shift(nodes: pl.DataFrame, offset: int):
     )
 
 
-def compose(f: pl.DataFrame, x: pl.DataFrame):
+def compose(f: pl.DataFrame, x: pl.DataFrame) -> pl.DataFrame:
     n = len(f)
     return pl.concat(
         [
@@ -35,31 +34,32 @@ def compose(f: pl.DataFrame, x: pl.DataFrame):
     )
 
 
-def find_redexes(nodes: pl.DataFrame):
-    parents = nodes.filter(pl.col("ref").is_null())
+def find_redexes(nodes: pl.DataFrame) -> pl.LazyFrame:
     return (
-        parents.join(nodes, left_on="id", right_on=pl.col("id") - 1, suffix="_child")
+        nodes.lazy()
         .filter(
             pl.col("arg").is_not_null(),
-            pl.col("ref_child").is_null(),
-            pl.col("arg_child").is_null(),
+            pl.col("arg").shift(-1).is_null(),
+            pl.col("ref").shift(-1).is_null(),
         )
-        .select(redex="id", lamb="id_child", b="arg")
+        .select("id", lamb=pl.col("id") + 1, arg="arg")
     )
 
 
-def find_variables(nodes: pl.DataFrame, lamb: int):
-    return nodes.filter(pl.col("ref") == lamb).select("id", replaced=True)
+def find_variables(nodes: pl.DataFrame, lamb: int) -> pl.LazyFrame:
+    return nodes.lazy().filter(pl.col("ref") == lamb).select("id", replaced=True)
 
 
-def subtree(nodes: pl.DataFrame, root: int) -> pl.DataFrame:
+def subtree(nodes: pl.DataFrame, root: int) -> pl.LazyFrame:
+    refs = nodes["ref"]
+    args = nodes["arg"]
     rightmost = root
     while True:
-        ref = nodes["ref"][rightmost]
-        arg = nodes["arg"][rightmost]
+        ref = refs[rightmost]
         if ref is not None:
-            return nodes.filter(pl.col("id").is_between(root, rightmost))
+            return nodes.lazy().filter(pl.col("id").is_between(root, rightmost))
 
+        arg = args[rightmost]
         rightmost = arg if arg is not None else rightmost + 1
 
 
@@ -77,52 +77,60 @@ def beta_reduce(nodes: pl.DataFrame, lamb: int, b: int) -> pl.DataFrame:
     a = lamb + 1
 
     vars = find_variables(nodes, lamb)
+
     b_subtree = subtree(nodes, b)
 
     b_subtree_duplicated = b_subtree.join(vars, how="cross", suffix="_major")
-    rest_of_nodes = nodes.join(b_subtree, on="id", how="anti").with_columns(
-        arg=pl.col("arg").replace(redex, a)
+    rest_of_nodes = (
+        nodes.lazy()
+        .join(b_subtree, on="id", how="anti")
+        .with_columns(arg=pl.col("arg").replace(redex, a))
     )
 
     new_nodes = (
         pl.concat(
             [b_subtree_duplicated, rest_of_nodes],
-            how="diagonal_relaxed",
+            how="diagonal",
         )
         .join(vars, left_on="id", right_on="id", how="anti")
         .join(vars, left_on="arg", right_on="id", how="left", suffix="_arg")
         .join(vars, left_on="ref", right_on="id", how="left", suffix="_ref")
         .filter(
-            ~pl.col("id").is_between(redex, lamb),
+            ~(pl.col("id").eq(redex) | pl.col("id").eq(lamb)),
         )
         .select(
             bid=_generate_bi_identifier("id_major", "id"),
             bid_ref=_generate_bi_identifier("id_major", "ref"),
             bid_ref_fallback=pl.struct(major="ref", minor="ref"),
             bid_arg=_generate_bi_identifier(
-                "id_major", "arg", minor_replacement=pl.when("replaced_arg").then(b)
+                # TODO: document and simplify to avoid "minor_replacement"
+                "id_major",
+                "arg",
+                minor_replacement=pl.when("replaced_arg").then(b),
             ),
         )
         .sort("bid")
         .with_row_index("id")
-    )
+    ).cache()
 
     return (
         new_nodes.join(
             new_nodes.select(bid_ref="bid", ref="id"),
             on="bid_ref",
             how="left",
+            maintain_order="left",
         )
         .join(
             new_nodes.select(bid_ref_fallback="bid", ref_fallback="id"),
             on="bid_ref_fallback",
             how="left",
+            maintain_order="left",
         )
         .join(
             new_nodes.select(bid_arg="bid", arg="id"),
             on="bid_arg",
             how="left",
+            maintain_order="left",
         )
         .select("id", ref=pl.coalesce("ref", "ref_fallback"), arg="arg", bid="bid")
-        .sort("id")
-    )
+    ).collect()