curryparty 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

curryparty/__init__.py

@@ -1,3 +1,8 @@
+"""The `curryparty` library, a playground to learn lambda-calculus.
+
+This library is intended to be used in an interactive
+"""
+
 from typing import Iterable, List, Optional, Union
 
 try:
@@ -8,9 +13,9 @@ except ImportError:
     )
 import uuid
 
-from svg import SVG, Rect
+from svg import SVG, Length, Rect, ViewBoxSpec
 
-from .core import SCHEMA, beta_reduce, compose, find_redexes, find_variables, subtree
+from .core import AbstractTerm
 from .display import (
     compute_height,
     compute_svg_frame_final,
@@ -33,24 +38,18 @@ def log2(n):
 
 
 class Term:
-    def __init__(self, nodes: pl.DataFrame):
-        assert nodes.schema == SCHEMA, (
-            f"{nodes.schema} is different from expected {SCHEMA}"
-        )
-        self.nodes = nodes
-        self.lamb = None
+    def __init__(self, data: AbstractTerm):
+        self.data = data
 
     def __call__(self, other: "Term") -> "Term":
-        return Term(compose(self.nodes, other.nodes))
+        return Term((self.data)(other.data))
 
     def beta(self) -> Optional["Term"]:
-        candidates = find_redexes(self.nodes).first().collect()
-        if len(candidates) == 0:
+        candidates = self.data.find_redexes()
+        redex = next(candidates, None)
+        if redex is None:
             return None
-        _redex, lamb, b = candidates.row(0)
-        self.lamb = lamb
-        self.b = b
-        reduced = beta_reduce(self.nodes, lamb, b)
+        reduced = self.data.beta_reduce(redex)
         return Term(reduced)
 
     def reduce(self):
@@ -61,41 +60,44 @@ class Term:
 
     def reduction_chain(self) -> Iterable["Term"]:
         term = self
-        while True:
+        while term is not None:
             yield term
             term = term.beta()
-            if term is None:
-                break
 
     def show_beta(self, duration=7):
         """
         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).first().collect()
-        if len(candidates) == 0:
+
+        candidates = self.data.find_redexes()
+        redex = next(candidates, None)
+        if redex is None:
             return self._repr_html_()
 
-        _redex, lamb, b = candidates.row(0)
-        new_nodes = beta_reduce(self.nodes, lamb, 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:
+        lamb = self.data.node(redex).get_left()
+        assert lamb is not None
+        b = self.data.node(redex).get_arg()
+        assert b is not None
+        new_nodes = self.data.beta_reduce(redex)
+        vars = list(self.data.find_variables(lamb))
+        b_subtree = list(self.data.get_subtree(b))
+        height = min(compute_height(self.data), compute_height(new_nodes)) * 2
+        if count_variables(self.data) == 0:
             return "no width"
-        raw_width = max(count_variables(self.nodes), count_variables(new_nodes))
+        raw_width = max(count_variables(self.data), count_variables(new_nodes))
         width = 1 << (1 + log2(raw_width))
         frame_data: list[ShapeAnimFrame] = []
         N_STEPS = 6
 
         for t in range(N_STEPS):
             if t == 0:
-                items = compute_svg_frame_init(self.nodes, t)
+                items = compute_svg_frame_init(self.data, t)
             elif t == 1 or t == 2:
-                items = compute_svg_frame_phase_a(self.nodes, lamb, b_subtree, vars, t)
+                items = compute_svg_frame_phase_a(self.data, redex, b_subtree, vars, t)
             elif t == 3 or t == 4:
                 items = compute_svg_frame_phase_b(
-                    self.nodes, lamb, b_subtree, new_nodes, t
+                    self.data, redex, b_subtree, new_nodes, t
                 )
             else:
                 items = compute_svg_frame_final(new_nodes, t)
@@ -114,10 +116,10 @@ class Term:
         anim_elements.append(
             Rect(
                 id=box_id,
-                x=f"{-width}",
-                y="0",
-                width="100%",
-                height="100%",
+                x=-width,
+                y=0,
+                width=Length(100, "%"),
+                height=Length(100, "%"),
                 fill="transparent",
             )
         )
@@ -126,7 +128,7 @@ class Term:
         H = height * 40
         anim_svg = SVG(
             xmlns="http://www.w3.org/2000/svg",
-            viewBox=f"{-width} 0 {2 * width} {height}",
+            viewBox=ViewBoxSpec(-width, 0, 2 * width, height),
             style=f"max-height:{H}px",
             elements=anim_elements,
         ).as_str()
@@ -140,11 +142,11 @@ class Term:
             "</div>"
         )
 
-    def _repr_html_(self, x0=-10):
-        frame = sorted(compute_svg_frame_init(self.nodes), key=lambda x: x.zindex)
+    def _repr_html_(self):
+        frame = sorted(compute_svg_frame_init(self.data), key=lambda x: x.zindex)
 
-        width = (1 << (1 + log2(count_variables(self.nodes)))) + 4
-        height = compute_height(self.nodes) + 1
+        width = (1 << (1 + log2(count_variables(self.data)))) + 4
+        height = compute_height(self.data) + 1
 
         elements = [ShapeAnim.from_single_frame(x) for x in frame]
 
@@ -152,13 +154,12 @@ class Term:
         H = height * 40
         W = width * 40
 
-        svg_element = SVG(
+        return SVG(
             xmlns="http://www.w3.org/2000/svg",
-            viewBox=f"{-1} 0 {width} {height}",  # type: ignore
+            viewBox=ViewBoxSpec(-1, 0, width, height),
             elements=elements,
             style=f"max-height:{H}px; margin-left: clamp(0px, calc(100% - {W}px), 100px)",
         ).as_str()
-        return f"<div>{svg_element}</div>"
 
 
 def offset_var(x: Union[int, str], offset: int) -> Union[int, str]:
@@ -190,11 +191,12 @@ class L:
                 self.args.append((offset + i, offset + x))
             self.n += t.n
         elif isinstance(t, Term):
-            for i, x in t.nodes.select("id", "ref").drop_nulls().iter_rows():
+            # fixme: encapsulate
+            for i, x in t.data.nodes.select("id", "ref").drop_nulls().iter_rows():
                 self.refs.append((offset + i, offset + x))
-            for i, x in t.nodes.select("id", "arg").drop_nulls().iter_rows():
+            for i, x in t.data.nodes.select("id", "arg").drop_nulls().iter_rows():
                 self.args.append((offset + i, offset + x))
-            self.n += len(t.nodes)
+            self.n += len(t.data.nodes)
         else:
             assert isinstance(t, str)
             self.refs.append((self.n, t))
@@ -242,8 +244,8 @@ class L:
             .to_frame()
             .join(ref, on="id", how="left")
             .join(arg, on="id", how="left")
-        ).with_columns(bid=pl.struct(major="id", minor="id"))
-        return Term(data)
+        ).with_columns(prev=None)
+        return Term(AbstractTerm(data))
 
 
 def V(name: str) -> L:

curryparty/core.py

@@ -1,13 +1,72 @@
+"""Core engine of lambda-calculus.
+
+This file defines 2 main types:
+- `AbstractTerm`, a Lambda-calculus term
+- `NodeId`, a node in the term.
+
+Because this is the most complex module of the library, it is useful to define some terms.
+I will refer to these terms in the above comments for concision.
+
+# 1. Term
+
+A `Term` is a complete Lambda-calculus expression.
+
+# 2. Node
+
+A `Node` is what constitutes a `Term`. There are 3 types of Nodes.
+
+2.1 There is `Lambda` Node, that has a single children
+2.2 There is a `Variable` Node. It has no children and refers to a `Lambda` Node.
+    We say the variable is `bound` to the corresponding Lambda.
+2.3 There is an `Application` Node. It has 2 children.
+    The first children is the function and the second children is the argument.
+
+# 3. Subtrees
+
+Each `Node` in the `Term` has a subtree. It is made up of itself, his children, his grandchildren ... and so on.
+    The **strict** subtree of a node is its subtree but without the node itself.
+
+# 4. Redex
+
+A "Redex Node" is a `Node` in the `Term` that we can reduce. It must have the following properties:
+
+4.1 A "Redex Node" is a `Node` of type "Application". The subtree of the "Redex node" is called simply the "Redex".
+4.2 The first children of the Redex node must be a lambda. The trunk node is the child of the lambda node.
+    The "Trunk" is defined as the strict subtree of the lambda node (i.e the subtree of the trunk).
+4.3 The variables that are bound to the "trunk node" are called the "Stumps".
+4.4 The second children of the Redex node can be anything. We call it the **Substitute node** of the Redex.
+    The "Subsitute" is simply the subtree of the "substitute node" of the Redex.
+
+# 5. Beta-reduction
+
+The operation of "beta-reduction" transforms a Redex inside the Term, leaving the rest of the term unchanged.
+    The beta-reduction of a Term on a Redex R consists in 2 steps:
+
+5.1 Beta-reduction replaces all stumps by a copy of the substitute
+5.1.1 If an application had a stump node as one of its children, the stump node is replaced by a copy of the substitute.
+5.1.2 All variables in the substitute are now bound to the corresponding duplicated lambda in their duplicated substitute.
+    But if a variable was bound to a lambda higher in the tree (not in the substitute), the bound remains
+5.2 Beta-reduction removes the redex node and the lambda node
+5.3 Beta-reduction removes the substitute (it has already been duplicated for each stump)
+5.4 All we have left is the trunk, and it is placed where the original redex was.
+
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Generator, List, NewType, Optional
+
 import polars as pl
 from polars import Schema, UInt32
 
+__all__ = ["AbstractTerm", "NodeId"]
+
+# See `Node`
+PREV_ID_SCHEMA = {"stump": UInt32, "local": UInt32}
+
 SCHEMA = Schema(
-    {
-        "id": UInt32,
-        "ref": UInt32,
-        "arg": UInt32,
-        "bid": pl.Struct({"major": UInt32, "minor": UInt32}),
-    },
+    {"id": UInt32, "ref": UInt32, "arg": UInt32, "prev": pl.Struct(PREV_ID_SCHEMA)},
 )
 
 
@@ -16,121 +75,252 @@ def _shift(nodes: pl.DataFrame, offset: int):
         pl.col("id") + offset,
         pl.col("ref") + offset,
         pl.col("arg") + offset,
-        bid=None,
+        prev=None,
     )
 
 
-def compose(f: pl.DataFrame, x: pl.DataFrame) -> pl.DataFrame:
-    n = len(f)
-    return pl.concat(
-        [
-            pl.DataFrame(
-                [{"id": 0, "arg": n + 1}],
-                schema=SCHEMA,
-            ),
-            _shift(f, 1),
-            _shift(x, n + 1),
-        ],
-    )
+NodeId = NewType("NodeId", int)
 
 
-def find_redexes(nodes: pl.DataFrame) -> pl.LazyFrame:
-    return (
-        nodes.lazy()
-        .filter(
-            pl.col("arg").is_not_null(),
-            pl.col("arg").shift(-1).is_null(),
-            pl.col("ref").shift(-1).is_null(),
-        )
-        .select("id", lamb=pl.col("id") + 1, arg="arg")
-    )
+@dataclass
+class Node[NodeId]:
+    """
+    Represents a node in the lambda calculus abstract syntax tree.
 
+    Attributes:
+        ref:
+            The lambda this variable is bound to, or None if this node is not a variable.
+        children:
+            Tuple containing either:
 
-def find_variables(nodes: pl.DataFrame, lamb: int) -> pl.LazyFrame:
-    return nodes.lazy().filter(pl.col("ref") == lamb).select("id", replaced=True)
+            - Single id: child of lambda node
+            - Two ids: function and argument of application node
+            - Empty tuple: no children (in this case, this is a variable)
 
+        previous:
+            If this NodeId comes from a beta-reduction, corresponds to the id of the node in the term before reduction.
+            If the node has been created by the reduction, `previous` is the id in the "Substitute" (see 5.1)
 
-def subtree(nodes: pl.DataFrame, root: int) -> pl.LazyFrame:
-    refs = nodes["ref"]
-    args = nodes["arg"]
-    rightmost = root
-    while True:
-        ref = refs[rightmost]
-        if ref is not None:
-            return nodes.lazy().filter(pl.col("id").is_between(root, rightmost))
+        previous_stump:
+            If the node has been created by a beta-reduction, the `Stump` it originates from (see 4.3)
+    """
 
-        arg = args[rightmost]
-        rightmost = arg if arg is not None else rightmost + 1
+    ref: Optional[NodeId]
+    children: List[NodeId]
+    previous_local: NodeId
+    previous_stump: NodeId
 
+    def get_arg(self) -> Optional[NodeId]:
+        if len(self.children) == 2:
+            return self.children[1]
+        return None
 
-def _generate_bi_identifier(
-    major_name: str, minor_name: str, minor_replacement=pl.lit(None)
-):
-    return pl.struct(
-        major=pl.col(major_name).fill_null(pl.col(minor_name)),
-        minor=minor_replacement.fill_null(pl.col(minor_name)),
-    )
+    def get_left(self) -> Optional[NodeId]:
+        if len(self.children) == 0:
+            return None
+        return self.children[0]
 
+    def previous(self):
+        return (self.previous_local, self.previous_stump)
 
-def beta_reduce(nodes: pl.DataFrame, lamb: int, b: int) -> pl.DataFrame:
-    redex = lamb - 1
-    a = lamb + 1
 
-    vars = find_variables(nodes, lamb)
+class AbstractTerm:
+    nodes: pl.DataFrame
 
-    b_subtree = subtree(nodes, b)
+    def __init__(self, nodes: pl.DataFrame | pl.LazyFrame):
+        nodes = nodes.match_to_schema(SCHEMA)
+        if isinstance(nodes, pl.LazyFrame):
+            self.nodes = nodes.collect()
+        else:
+            self.nodes = nodes
 
-    b_subtree_duplicated = b_subtree.join(vars, how="cross", suffix="_major")
-    rest_of_nodes = (
-        nodes.lazy()
-        .join(b_subtree, on="id", how="anti")
-        .with_columns(arg=pl.col("arg").replace(redex, a))
-    )
+    def root(self) -> NodeId:
+        return NodeId(0)
 
-    new_nodes = (
-        pl.concat(
-            [b_subtree_duplicated, rest_of_nodes],
-            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").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(
-                # TODO: document and simplify to avoid "minor_replacement"
-                "id_major",
-                "arg",
-                minor_replacement=pl.when("replaced_arg").then(b),
-            ),
+    def node(self, node_id: NodeId):
+        """
+        Get a node in the expression tree by id
+        """
+
+        id, ref, arg, prev = self.nodes.row(node_id)
+        children = []
+        if ref is None:
+            children.append(id + 1)
+        if arg is not None:
+            children.append(arg)
+
+        return Node(
+            ref=ref,
+            children=children,
+            previous_local=prev["local"] if prev else None,
+            previous_stump=prev["stump"] if prev else None,
         )
-        .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",
+
+    def find_variables(self, lamb: NodeId) -> Generator[NodeId]:
+        """
+        Find all variables bound to a specific lambda.
+
+        Args:
+            lamb: the id of the lambda to consider
+        """
+        return self.nodes.filter(pl.col("ref") == lamb)["id"].__iter__()
+
+    def find_redexes(self) -> Generator[NodeId]:
+        """
+        Find all candidate redex nodes (see 4.)
+
+        The first redex must be the leftmost-outermost redex.
+        """
+        return self.nodes.filter(
+            pl.col("arg").is_not_null(),
+            pl.col("arg").shift(-1).is_null(),
+            pl.col("ref").shift(-1).is_null(),
+        )["id"].__iter__()
+
+    def _get_subtree(self, root: NodeId) -> range:
+        """
+        Get the subtree of the node in a postfix left -> right order (see 3.)
+
+        Args:
+            root: the ancestor to consider
+        """
+        refs = self.nodes["ref"]
+        args = self.nodes["arg"]
+        rightmost = root
+        while True:
+            ref = refs[rightmost]
+            if ref is not None:
+                return range(NodeId(root), NodeId(rightmost + 1))
+
+            arg = args[rightmost]
+            rightmost = arg if arg is not None else rightmost + 1
+
+    def get_subtree(self, root: NodeId) -> Generator[NodeId]:
+        return (NodeId(x) for x in self._get_subtree(root))
+
+    def __call__(self, other: AbstractTerm) -> AbstractTerm:
+        r"""
+        Compose this term with another one with an application.
+        ```
+         application
+            /   \
+           /     \
+        self     other
+        ```
+        """
+        n = len(self.nodes)
+        return AbstractTerm(
+            pl.concat(
+                [
+                    pl.DataFrame(
+                        [{"id": 0, "arg": n + 1}],
+                        schema=SCHEMA,
+                    ),
+                    _shift(self.nodes, 1),
+                    _shift(other.nodes, n + 1),
+                ],
+            )
         )
-        .join(
-            new_nodes.select(bid_ref_fallback="bid", ref_fallback="id"),
-            on="bid_ref_fallback",
-            how="left",
-            maintain_order="left",
+
+    def beta_reduce(self, redex: NodeId) -> AbstractTerm:
+        """
+        Compute the beta-reduction of this term on this redex.
+        """
+        lamb = redex + 1
+        a = redex + 2
+        id_subst = self.node(redex).get_arg()
+        assert id_subst is not None
+
+        # see 4.3
+        stumps = self.nodes.lazy().filter(pl.col("ref") == lamb).select("id")
+
+        # see 4.4
+        subst_range = self._get_subtree(id_subst)
+        subst = self.nodes.lazy().filter(
+            pl.col("id").is_between(subst_range.start, subst_range.stop, closed="left")
         )
-        .join(
-            new_nodes.select(bid_arg="bid", arg="id"),
-            on="bid_arg",
-            how="left",
-            maintain_order="left",
+
+        # we start duplicating
+        new_trunks = subst.join(stumps, how="cross", suffix="_stump").select(
+            "id",
+            "id_stump",
+            prev=pl.struct(stump="id_stump", local="id"),
+            prev_arg=pl.struct(stump="id_stump", local="arg"),
+            prev_ref=pl.struct(stump="id_stump", local="ref"),
+            # TODO: explain the logic for variables that are not bound inside the redex
+            prev_ref_unbound=pl.struct(stump=None, local="ref", schema=PREV_ID_SCHEMA),
         )
-        .select("id", ref=pl.coalesce("ref", "ref_fallback"), arg="arg", bid="bid")
-    ).collect()
+
+        new_nodes = (
+            self.nodes.lazy()
+            # remove the information about the previous iteration
+            .select(pl.exclude("prev"))
+            # See 5.2
+            .filter(
+                ~(pl.col("id").eq(redex) | pl.col("id").eq(lamb)),
+            )
+            # See 5.3
+            .join(subst, left_on="id", right_on="id", how="anti")
+            # See 5.4
+            .with_columns(arg=pl.col("arg").replace(redex, a))
+            .join(
+                # 5.1.1 we check if the argument is a stump
+                stumps.select("id", arg_is_stump=True),
+                left_on="arg",
+                right_on="id",
+                how="left",
+                maintain_order="left",
+            )
+            # See 5.1
+            .join(
+                new_trunks,
+                left_on="id",
+                right_on="id_stump",
+                how="left",
+                maintain_order="left",
+            )
+            .select(
+                pl.col("prev").fill_null(pl.struct(stump=None, local="id")),
+                pl.col("prev_ref").fill_null(pl.struct(stump=None, local="ref")),
+                pl.col("prev_ref_unbound"),
+                # 5.1.1
+                pl.col("prev_arg").fill_null(
+                    pl.when(pl.col("arg_is_stump"))
+                    .then(pl.struct(stump="arg", local=id_subst))
+                    .otherwise(pl.struct(stump=None, local="arg"))
+                ),
+            )
+            .with_row_index("id")
+        ).cache()
+
+        # renumbering step: we replace each "previous location" with the new id
+        out = (
+            new_nodes.join(
+                new_nodes.select(prev_ref="prev", ref="id"),
+                on="prev_ref",
+                how="left",
+                maintain_order="left",
+                nulls_equal=True,
+            )
+            .join(
+                new_nodes.select(prev_ref_unbound="prev", ref_unbound="id"),
+                on="prev_ref_unbound",
+                how="left",
+                maintain_order="left",
+                nulls_equal=True,
+            )
+            .join(
+                new_nodes.select(prev_arg="prev", arg="id"),
+                on="prev_arg",
+                how="left",
+                maintain_order="left",
+                nulls_equal=True,
+            )
+            .select(
+                "id",
+                ref=pl.coalesce("ref", "ref_unbound"),  # 5.1.2
+                arg="arg",
+                prev="prev",
+            )
+        ).collect()
+        return AbstractTerm(out)

curryparty/display.py

@@ -1,60 +1,73 @@
-from typing import Any, Iterable, Optional, Union
+from typing import Iterable, List, Optional, Tuple, TypeAlias
 
-import polars as pl
 import svg
 
+from .core import AbstractTerm, NodeId
 from .utils import Interval, ShapeAnimFrame
 
 
-def compute_height(nodes: pl.DataFrame):
-    _, y = compute_layout(nodes)
+def compute_height(term: AbstractTerm):
+    _, y = compute_layout(term)
     return max(interval[1] for interval in y.values() if interval) + 1
 
 
-def count_variables(nodes: pl.DataFrame):
-    return nodes["ref"].count()
+def count_variables(term: AbstractTerm):
+    return sum(1 for x in term.get_subtree(term.root()) if term.node(x).ref is not None)
+
+
+Loc: TypeAlias = Tuple[NodeId, Optional[NodeId]]
 
 
 def compute_layout(
-    nodes: pl.DataFrame, lamb=None, replaced_var_width=1
-) -> tuple[dict[int, int], dict[int, int]]:
-    y = {0: Interval((0, 0))}
-    x = {}
-    for node, ref, arg in nodes.select("id", "ref", "arg").iter_rows():
+    term: AbstractTerm, lamb: Optional[NodeId] = None, replaced_var_width=1
+) -> tuple[dict[Loc, Interval], dict[Loc, Interval]]:
+    y: dict[Loc, Interval] = {(term.root(), None): Interval((0, 0))}
+    x: dict[Loc, Interval] = {}
+    nodes = list(term.get_subtree(term.root()))
+    for node_id in nodes:
+        node = term.node(node_id)
+        ref = node.ref
+        arg = node.get_arg()
         if ref is not None:
             continue
-        child = node + 1
+        child = term.node(node_id).get_left()
+        assert child is not None
         if arg is not None:
-            y[child] = y[node].shift(0 if nodes["arg"][child] is None else 1)
-            y[arg] = y[node].shift(0)
+            y[child, None] = y[node_id, None].shift(
+                0 if term.node(child).get_arg() is None else 1
+            )
+            y[arg, None] = y[node_id, None].shift(0)
         else:
-            y[child] = y[node].shift(1)
+            y[child, None] = y[node_id, None].shift(1)
 
-    next_var_x = count_variables(nodes) - 1
+    next_var_x = count_variables(term) - 1
 
-    for node, ref, arg in (
-        nodes.sort("id", descending=True).select("id", "ref", "arg").iter_rows()
-    ):
+    for node_id in reversed(nodes):
+        node = term.node(node_id)
+        ref = node.ref
+        arg = node.get_arg()
         if ref is not None:
             width = replaced_var_width if ref == lamb else 1
-            x[node] = Interval((next_var_x - width + 1, next_var_x))
+            x[node_id, None] = Interval((next_var_x - width + 1, next_var_x))
             next_var_x -= width
-            x[ref] = x[node] | x.get(ref, Interval(None))
+            x[ref, None] = x[node_id, None] | x.get((ref, None), Interval(None))
 
         else:
-            child = node + 1
-            x[node] = x[child] | x.get(node, Interval(None))
-            y[node] = y[child] | y[node]
+            child = term.node(node_id).get_left()
+            assert child is not None
+            x[node_id, None] = x[child, None] | x.get((node_id, None), Interval(None))
+            y[node_id, None] = y[child, None] | y[node_id, None]
+
     return x, y
 
 
 def draw(
-    x: dict[Union[int, tuple[int, int]], Interval],
-    y: dict[Union[int, tuple[int, int]], Interval],
-    i_node: Union[int, tuple[int, int]],
-    ref: Optional[int],
-    arg: Optional[int],
-    key: Any,
+    x: dict[Loc, Interval],
+    y: dict[Loc, Interval],
+    i_node: Loc,
+    ref: Optional[Loc],
+    arg: Optional[Loc],
+    key: Loc,
     idx: int,
     replaced=False,
     removed=False,
@@ -164,108 +177,129 @@ def draw(
 
 
 def compute_svg_frame_init(
-    nodes: pl.DataFrame, idx: int = 0
+    term: AbstractTerm, idx: int = 0
 ) -> Iterable[ShapeAnimFrame]:
-    x, y = compute_layout(nodes)
-    for target_id, ref, arg in (
-        nodes.select("id", "ref", "arg").sort("id", descending=True).iter_rows()
-    ):
-        yield from draw(x, y, target_id, ref, arg, key=target_id, idx=idx)
+    x, y = compute_layout(term)
+    for node_id in term.get_subtree(term.root()):
+        node = term.node(node_id)
+        ref = node.ref
+        arg = node.get_arg()
+        yield from draw(
+            x,
+            y,
+            (node_id, None),
+            (ref, None) if ref is not None else None,
+            (arg, None) if arg is not None else None,
+            key=(node_id, None),
+            idx=idx,
+        )
 
 
 def compute_svg_frame_phase_a(
-    nodes: pl.DataFrame, lamb: int, b_subtree: pl.DataFrame, vars: pl.Series, idx: int
+    term: AbstractTerm,
+    redex: NodeId,
+    b_subtree: List[NodeId],
+    vars: List[NodeId],
+    idx: int,
 ) -> Iterable[ShapeAnimFrame]:
-    redex = lamb - 1 if lamb is not None else None
-    b_width = b_subtree.count()["ref"].item()
-    x, y = compute_layout(nodes, lamb=lamb, replaced_var_width=b_width)
-    for target_id, ref, arg in (
-        nodes.select("id", "ref", "arg").sort("id", descending=True).iter_rows()
-    ):
-        replaced = ref is not None and ref == lamb
+    lamb = term.node(redex).get_left()
+    assert lamb is not None
+    b_width = sum(1 for x in b_subtree if term.node(x).ref is not None)
+    x, y = compute_layout(term, lamb=lamb, replaced_var_width=b_width)
+    for node_id in term.get_subtree(term.root()):
+        if node_id in b_subtree:
+            continue
+        node = term.node(node_id)
+        ref = node.ref
+        arg = node.get_arg()
+        replaced = ref == lamb
         yield from draw(
             x,
             y,
-            target_id,
-            ref,
-            arg,
-            key=target_id,
+            (node_id, None),
+            (ref, None) if ref is not None else None,
+            (arg, None) if arg is not None else None,
+            key=(node_id, None),
             idx=idx,
             replaced=replaced,
-            removed=(target_id == lamb or target_id == redex),
+            removed=(node_id == lamb or node_id == redex),
         )
 
-    for v in vars:
-        for minor, ref, arg in (
-            b_subtree.select("id", "ref", "arg").sort("id", descending=True).iter_rows()
-        ):
-            yield from draw(x, y, minor, ref, arg, key=(v, minor), idx=idx)
+    for stump in vars:
+        for local_id in b_subtree:
+            local_node = term.node(local_id)
+            ref = local_node.ref
+            arg = local_node.get_arg()
+            key = (local_id, stump)
+            yield from draw(
+                x,
+                y,
+                (local_id, None),
+                (ref, None) if ref is not None else None,
+                (arg, None) if arg is not None else None,
+                key=key,
+                idx=idx,
+            )
 
 
 def compute_svg_frame_phase_b(
-    nodes: pl.DataFrame,
-    lamb: int,
-    b_subtree: pl.DataFrame,
-    new_nodes: pl.DataFrame,
+    term: AbstractTerm,
+    redex: NodeId,
+    b_subtree: List[NodeId],
+    reduced: AbstractTerm,
     idx: int,
 ) -> Iterable[ShapeAnimFrame]:
-    b_width = b_subtree.count()["ref"].item()
-    b = b_subtree["id"][0]
-    x, y = compute_layout(nodes, lamb=lamb, replaced_var_width=b_width)
-    b_x = x[b][0]
-    b_y = y[b][0]
-    for bid, arg in new_nodes.select("bid", "arg").iter_rows():
-        if bid["minor"] != bid["major"]:
-            v = bid["major"]
-            minor = bid["minor"]
-            delta_x = x[v][0] - b_x
-            delta_y = y[v][0] - b_y + 1
-            x[(v, minor)] = x[minor].shift(delta_x)
-            y[(v, minor)] = y[minor].shift(delta_y)
-
-    for bid, new_ref, new_arg in new_nodes.select("bid", "ref", "arg").iter_rows():
-        v = bid["major"]
-        minor = bid["minor"]
-        if new_ref is None:
-            ref = None
-        else:
-            bid_ref = new_nodes["bid"][new_ref]
-            ref = (
-                (bid_ref["major"], bid_ref["minor"])
-                if bid_ref["major"] != bid_ref["minor"]
-                else bid_ref["minor"]
-            )
-        if new_arg is None:
-            arg = None
-        else:
-            bid_arg = new_nodes["bid"][new_arg]
-            arg = (
-                (bid_arg["major"], bid_arg["minor"])
-                if bid_arg["major"] != bid_arg["minor"]
-                else bid_arg["minor"]
-            )
-        key = (v, minor) if minor != v else minor
+    lamb = term.node(redex).get_left()
+    assert lamb is not None
+    b_width = sum(1 for x in b_subtree if term.node(x).ref is not None)
+    b = term.node(redex).get_arg()
+    assert b is not None
+    x, y = compute_layout(term, lamb=lamb, replaced_var_width=b_width)
+    b_x = x[b, None][0]
+    b_y = y[b, None][0]
+    for node_id in reduced.get_subtree(reduced.root()):
+        node = reduced.node(node_id)
+        local = node.previous_local
+        stump = node.previous_stump
+        if stump is not None:
+            delta_x = x[stump, None][0] - b_x
+            delta_y = y[stump, None][0] - b_y + 1
+            x[local, stump] = x[local, None].shift(delta_x)
+            y[local, stump] = y[local, None].shift(delta_y)
+
+    for node_id in reduced.get_subtree(reduced.root()):
+        node = reduced.node(node_id)
+        new_ref = node.ref
+        new_arg = node.get_arg()
+
+        key = node.previous()
+
         yield from draw(
             x,
             y,
             key,
-            ref,
-            arg,
+            ref=reduced.node(new_ref).previous() if new_ref else None,
+            arg=reduced.node(new_arg).previous() if new_arg else None,
             key=key,
             idx=idx,
         )
 
 
 def compute_svg_frame_final(
-    reduced: pl.DataFrame, idx: int
+    reduced: AbstractTerm, idx: int
 ) -> Iterable[ShapeAnimFrame]:
     x, y = compute_layout(reduced)
-    for target_id, bid, ref, arg in (
-        reduced.select("id", "bid", "ref", "arg")
-        .sort("id", descending=True)
-        .iter_rows()
-    ):
-        minor = bid["minor"]
-        major = bid["major"]
-        key = (major, minor) if minor != major else minor
-        yield from draw(x, y, target_id, ref, arg, key, idx=idx)
+    for node_id in reduced.get_subtree(reduced.root()):
+        node = reduced.node(node_id)
+        ref = node.ref
+        arg = node.get_arg()
+        key = node.previous()
+        yield from draw(
+            x,
+            y,
+            (node_id, None),
+            (ref, None) if ref is not None else None,
+            (arg, None) if arg is not None else None,
+            key,
+            idx=idx,
+        )

{curryparty-0.3.1.dist-info → curryparty-0.3.3.dist-info}/METADATA

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

curryparty-0.3.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+curryparty/__init__.py,sha256=uxHe9q_6L8yqQcgwZpm8WMLCdroBNliGJWRwcheFi3k,8152
+curryparty/core.py,sha256=CkJi2MpolY22WisJ-0DBmaM5Y25Kt2kfYmaiAX5Ykdk,10972
+curryparty/display.py,sha256=21pqOwembQ1Mx-OjT3woy1UFpVlnZK02E5f6Zz7Yd4c,8809
+curryparty/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+curryparty/utils.py,sha256=56rRpMiDXbEQjFEwoKxuGb3Nch4qJd8OgwmNxkfl-oE,4937
+curryparty-0.3.3.dist-info/WHEEL,sha256=iHtWm8nRfs0VRdCYVXocAWFW8ppjHL-uTJkAdZJKOBM,80
+curryparty-0.3.3.dist-info/METADATA,sha256=EOM6X4YoY0cYRhFsF0O5UclSdawkbvVJFgVU3OtDkMo,2259
+curryparty-0.3.3.dist-info/RECORD,,

{curryparty-0.3.1.dist-info → curryparty-0.3.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.29
+Generator: uv 0.9.30
 Root-Is-Purelib: true
 Tag: py3-none-any

curryparty-0.3.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-curryparty/__init__.py,sha256=_55oknmsS2Z8BRfs_OYD_rwj_INJ7FEBfDhiSpYnAtk,8243
-curryparty/core.py,sha256=nqHU0ZntZdymudC6jR6WYck80xFwcvymwjwUfh0UIWo,3852
-curryparty/display.py,sha256=fstY7lCPjQjvSgaTJGnoYOqrbXHbXytNTqPJ5EZ2h1E,7833
-curryparty/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-curryparty/utils.py,sha256=56rRpMiDXbEQjFEwoKxuGb3Nch4qJd8OgwmNxkfl-oE,4937
-curryparty-0.3.1.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
-curryparty-0.3.1.dist-info/METADATA,sha256=ChdqiQ4zzQtr_i8ey_EUxanWhF0WlJM173j_YqhFs88,2259
-curryparty-0.3.1.dist-info/RECORD,,