curryparty 0.3.1__tar.gz → 0.3.3__tar.gz

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

@@ -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.1 → curryparty-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "curryparty"
-version = "0.3.1"
+version = "0.3.3"
 description = "Python playground to learn lambda calculus"
 readme = "README.md"
 authors = [

{curryparty-0.3.1 → curryparty-0.3.3}/src/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-0.3.3/src/curryparty/core.py

@@ -0,0 +1,326 @@
+"""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, "prev": pl.Struct(PREV_ID_SCHEMA)},
+)
+
+
+def _shift(nodes: pl.DataFrame, offset: int):
+    return nodes.with_columns(
+        pl.col("id") + offset,
+        pl.col("ref") + offset,
+        pl.col("arg") + offset,
+        prev=None,
+    )
+
+
+NodeId = NewType("NodeId", int)
+
+
+@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:
+
+            - 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)
+
+        previous_stump:
+            If the node has been created by a beta-reduction, the `Stump` it originates from (see 4.3)
+    """
+
+    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 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)
+
+
+class AbstractTerm:
+    nodes: pl.DataFrame
+
+    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
+
+    def root(self) -> NodeId:
+        return NodeId(0)
+
+    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,
+        )
+
+    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),
+                ],
+            )
+        )
+
+    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")
+        )
+
+        # 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),
+        )
+
+        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-0.3.3/src/curryparty/display.py

@@ -0,0 +1,305 @@
+from typing import Iterable, List, Optional, Tuple, TypeAlias
+
+import svg
+
+from .core import AbstractTerm, NodeId
+from .utils import Interval, ShapeAnimFrame
+
+
+def compute_height(term: AbstractTerm):
+    _, y = compute_layout(term)
+    return max(interval[1] for interval in y.values() if interval) + 1
+
+
+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(
+    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 = term.node(node_id).get_left()
+        assert child is not None
+        if arg is not None:
+            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, None] = y[node_id, None].shift(1)
+
+    next_var_x = count_variables(term) - 1
+
+    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_id, None] = Interval((next_var_x - width + 1, next_var_x))
+            next_var_x -= width
+            x[ref, None] = x[node_id, None] | x.get((ref, None), Interval(None))
+
+        else:
+            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[Loc, Interval],
+    y: dict[Loc, Interval],
+    i_node: Loc,
+    ref: Optional[Loc],
+    arg: Optional[Loc],
+    key: Loc,
+    idx: int,
+    replaced=False,
+    removed=False,
+    hide_arg=False,
+) -> Iterable[ShapeAnimFrame]:
+    x_node = x[i_node]
+    y_node = y[i_node]
+    if arg is not None or removed:
+        color = "transparent"
+    elif replaced or removed:
+        color = "green"
+    elif ref is not None:
+        color = "red"
+    else:
+        color = "blue"
+
+    r = svg.Rect(
+        height=0.8,
+        stroke_width=0.05,
+        stroke="gray",
+    )
+
+    yield ShapeAnimFrame(
+        element=r,
+        key=("r", key),
+        idx=idx,
+        attrs={
+            "x": 0.1 + x_node[0],
+            "y": 0.1 + y_node[0] + (1 if replaced else 0),
+            "width": 0.8 + x_node[1] - x_node[0],
+            "fill_opacity": 1 if arg is None else 0,
+            "fill": color,
+        },
+        zindex=0,
+    )
+    if arg is not None and not hide_arg:
+        r = svg.Rect(
+            height=0.8,
+            stroke_width=0.1,
+            stroke="orange",
+        )
+
+        yield ShapeAnimFrame(
+            element=r,
+            key=("a", key),
+            idx=idx,
+            attrs={
+                "x": 0.1 + x_node[0],
+                "y": 0.1 + y_node[0],
+                "width": 0.8 + x_node[1] - x_node[0],
+                "fill_opacity": 1 if arg is None else 0,
+                "fill": color,
+            },
+            zindex=1,
+        )
+
+    if ref is not None:
+        y_ref = y[ref]
+        e = svg.Line(
+            stroke_width=0.2,
+            stroke="gray",
+        )
+        yield ShapeAnimFrame(
+            element=e,
+            key=("l", key),
+            idx=idx,
+            attrs={
+                "x1": x_node[0] + 0.5,
+                "y1": y_ref[0] + 0.9,
+                "x2": x_node[0] + 0.5,
+                "y2": y_node[0] + 0.1 + (1 if replaced else 0),
+                "stroke": "green" if replaced else "gray",
+            },
+            zindex=2,
+        )
+
+    if arg is not None:
+        x_arg = x[arg]
+        e1 = svg.Line(
+            stroke="black",
+            stroke_width=0.05,
+        )
+        e2 = svg.Circle(fill="black", r=0.1)
+        if not removed:
+            yield ShapeAnimFrame(
+                element=e1,
+                key=("b", key),
+                idx=idx,
+                attrs={
+                    "x1": 0.5 + x_node[1],
+                    "y1": 0.5 + y_node[0],
+                    "x2": 0.5 + x_arg[0],
+                    "y2": 0.5 + y_node[0],
+                },
+                zindex=3,
+            )
+            yield ShapeAnimFrame(
+                element=e2,
+                key=("c", key),
+                idx=idx,
+                attrs={
+                    "cx": 0.5 + x_node[1],
+                    "cy": 0.5 + y_node[0],
+                },
+                zindex=3,
+            )
+
+
+def compute_svg_frame_init(
+    term: AbstractTerm, idx: int = 0
+) -> Iterable[ShapeAnimFrame]:
+    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(
+    term: AbstractTerm,
+    redex: NodeId,
+    b_subtree: List[NodeId],
+    vars: List[NodeId],
+    idx: int,
+) -> Iterable[ShapeAnimFrame]:
+    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,
+            (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=(node_id == lamb or node_id == redex),
+        )
+
+    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(
+    term: AbstractTerm,
+    redex: NodeId,
+    b_subtree: List[NodeId],
+    reduced: AbstractTerm,
+    idx: int,
+) -> Iterable[ShapeAnimFrame]:
+    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=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: AbstractTerm, idx: int
+) -> Iterable[ShapeAnimFrame]:
+    x, y = compute_layout(reduced)
+    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/src/curryparty/core.py

@@ -1,136 +0,0 @@
-import polars as pl
-from polars import Schema, UInt32
-
-SCHEMA = Schema(
-    {
-        "id": UInt32,
-        "ref": UInt32,
-        "arg": UInt32,
-        "bid": pl.Struct({"major": UInt32, "minor": UInt32}),
-    },
-)
-
-
-def _shift(nodes: pl.DataFrame, offset: int):
-    return nodes.with_columns(
-        pl.col("id") + offset,
-        pl.col("ref") + offset,
-        pl.col("arg") + offset,
-        bid=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),
-        ],
-    )
-
-
-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")
-    )
-
-
-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.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))
-
-        arg = args[rightmost]
-        rightmost = arg if arg is not None else rightmost + 1
-
-
-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 beta_reduce(nodes: pl.DataFrame, lamb: int, b: int) -> pl.DataFrame:
-    redex = lamb - 1
-    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.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",
-        )
-        .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),
-            ),
-        )
-        .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")
-    ).collect()

curryparty-0.3.1/src/curryparty/display.py

@@ -1,271 +0,0 @@
-from typing import Any, Iterable, Optional, Union
-
-import polars as pl
-import svg
-
-from .utils import Interval, ShapeAnimFrame
-
-
-def compute_height(nodes: pl.DataFrame):
-    _, y = compute_layout(nodes)
-    return max(interval[1] for interval in y.values() if interval) + 1
-
-
-def count_variables(nodes: pl.DataFrame):
-    return nodes["ref"].count()
-
-
-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():
-        if ref is not None:
-            continue
-        child = node + 1
-        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)
-        else:
-            y[child] = y[node].shift(1)
-
-    next_var_x = count_variables(nodes) - 1
-
-    for node, ref, arg in (
-        nodes.sort("id", descending=True).select("id", "ref", "arg").iter_rows()
-    ):
-        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))
-            next_var_x -= width
-            x[ref] = x[node] | x.get(ref, Interval(None))
-
-        else:
-            child = node + 1
-            x[node] = x[child] | x.get(node, Interval(None))
-            y[node] = y[child] | y[node]
-    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,
-    idx: int,
-    replaced=False,
-    removed=False,
-    hide_arg=False,
-) -> Iterable[ShapeAnimFrame]:
-    x_node = x[i_node]
-    y_node = y[i_node]
-    if arg is not None or removed:
-        color = "transparent"
-    elif replaced or removed:
-        color = "green"
-    elif ref is not None:
-        color = "red"
-    else:
-        color = "blue"
-
-    r = svg.Rect(
-        height=0.8,
-        stroke_width=0.05,
-        stroke="gray",
-    )
-
-    yield ShapeAnimFrame(
-        element=r,
-        key=("r", key),
-        idx=idx,
-        attrs={
-            "x": 0.1 + x_node[0],
-            "y": 0.1 + y_node[0] + (1 if replaced else 0),
-            "width": 0.8 + x_node[1] - x_node[0],
-            "fill_opacity": 1 if arg is None else 0,
-            "fill": color,
-        },
-        zindex=0,
-    )
-    if arg is not None and not hide_arg:
-        r = svg.Rect(
-            height=0.8,
-            stroke_width=0.1,
-            stroke="orange",
-        )
-
-        yield ShapeAnimFrame(
-            element=r,
-            key=("a", key),
-            idx=idx,
-            attrs={
-                "x": 0.1 + x_node[0],
-                "y": 0.1 + y_node[0],
-                "width": 0.8 + x_node[1] - x_node[0],
-                "fill_opacity": 1 if arg is None else 0,
-                "fill": color,
-            },
-            zindex=1,
-        )
-
-    if ref is not None:
-        y_ref = y[ref]
-        e = svg.Line(
-            stroke_width=0.2,
-            stroke="gray",
-        )
-        yield ShapeAnimFrame(
-            element=e,
-            key=("l", key),
-            idx=idx,
-            attrs={
-                "x1": x_node[0] + 0.5,
-                "y1": y_ref[0] + 0.9,
-                "x2": x_node[0] + 0.5,
-                "y2": y_node[0] + 0.1 + (1 if replaced else 0),
-                "stroke": "green" if replaced else "gray",
-            },
-            zindex=2,
-        )
-
-    if arg is not None:
-        x_arg = x[arg]
-        e1 = svg.Line(
-            stroke="black",
-            stroke_width=0.05,
-        )
-        e2 = svg.Circle(fill="black", r=0.1)
-        if not removed:
-            yield ShapeAnimFrame(
-                element=e1,
-                key=("b", key),
-                idx=idx,
-                attrs={
-                    "x1": 0.5 + x_node[1],
-                    "y1": 0.5 + y_node[0],
-                    "x2": 0.5 + x_arg[0],
-                    "y2": 0.5 + y_node[0],
-                },
-                zindex=3,
-            )
-            yield ShapeAnimFrame(
-                element=e2,
-                key=("c", key),
-                idx=idx,
-                attrs={
-                    "cx": 0.5 + x_node[1],
-                    "cy": 0.5 + y_node[0],
-                },
-                zindex=3,
-            )
-
-
-def compute_svg_frame_init(
-    nodes: pl.DataFrame, 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)
-
-
-def compute_svg_frame_phase_a(
-    nodes: pl.DataFrame, lamb: int, b_subtree: pl.DataFrame, vars: pl.Series, 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
-        yield from draw(
-            x,
-            y,
-            target_id,
-            ref,
-            arg,
-            key=target_id,
-            idx=idx,
-            replaced=replaced,
-            removed=(target_id == lamb or target_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)
-
-
-def compute_svg_frame_phase_b(
-    nodes: pl.DataFrame,
-    lamb: int,
-    b_subtree: pl.DataFrame,
-    new_nodes: pl.DataFrame,
-    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
-        yield from draw(
-            x,
-            y,
-            key,
-            ref,
-            arg,
-            key=key,
-            idx=idx,
-        )
-
-
-def compute_svg_frame_final(
-    reduced: pl.DataFrame, 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)