curryparty 0.1.0__tar.gz

curryparty-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.3
+Name: curryparty
+Version: 0.1.0
+Summary: Python playground to learn lambda calculus
+Author: Antonin P
+Author-email: Antonin P <antonin.peronnet@telecom-paris.fr>
+Requires-Dist: polars>=1.36.1
+Requires-Dist: svg-py>=1.9.2
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Curry party
+
+`curryparty` is a library created to explore, visualize and teach lambda-calculus concepts.
+
+# Install
+
+Run `pip install curryparty` or `uv add curryparty` depending on your package manager.
+
+# How to use
+
+```python
+from curryparty import L, V
+
+# build expressions idiomatically
+identity = L("x")._("x").build()
+
+zero = L("f", "x")._("x").build()
+
+omega = L("x")._("x").call("x").build()
+
+# you can create more complex terms:
+
+succ = L("n", "f", "x")._("f").call(
+    V("n").call("f").call("x")
+)
+
+# If you try to combine them, nothing will happen:
+bomb = omega(omega)
+one = s(zero)
+
+# You need to beta-reduce them:
+bomb.beta()
+one_with_first_reduction = one.beta()
+
+# if you want the final form:
+term = s(zero)
+while term is not None:
+    term = term.beta()
+    print(term)
+
+# this is equivalent to:
+for x in term.reduction_chain():
+    print(x)
+```
+
+But the main point of this library is the svg-based display system.
+If you use a notebook such as jupyternotebook or marimo, you will see something like this:
+
+![](./assets/notebook_display.png)
+
+
+You can also use `term.show_reduction` to get an animated version.
+
+# How it works
+
+Under the wood, all the terms are converted into a list of nodes, that can either be a `lambda`, an `application` (with 2 arguments) or a `variable` (with 0 arguments).
+
+For efficiency, they are converted to a [polars](https://github.com/pola-rs/polars) dataframe in prefix traversal order.
+If you want to understand how it works, start by looking at the `.nodes` attribute of any term.

curryparty-0.1.0/README.md

@@ -0,0 +1,59 @@
+# Curry party
+
+`curryparty` is a library created to explore, visualize and teach lambda-calculus concepts.
+
+# Install
+
+Run `pip install curryparty` or `uv add curryparty` depending on your package manager.
+
+# How to use
+
+```python
+from curryparty import L, V
+
+# build expressions idiomatically
+identity = L("x")._("x").build()
+
+zero = L("f", "x")._("x").build()
+
+omega = L("x")._("x").call("x").build()
+
+# you can create more complex terms:
+
+succ = L("n", "f", "x")._("f").call(
+    V("n").call("f").call("x")
+)
+
+# If you try to combine them, nothing will happen:
+bomb = omega(omega)
+one = s(zero)
+
+# You need to beta-reduce them:
+bomb.beta()
+one_with_first_reduction = one.beta()
+
+# if you want the final form:
+term = s(zero)
+while term is not None:
+    term = term.beta()
+    print(term)
+
+# this is equivalent to:
+for x in term.reduction_chain():
+    print(x)
+```
+
+But the main point of this library is the svg-based display system.
+If you use a notebook such as jupyternotebook or marimo, you will see something like this:
+
+![](./assets/notebook_display.png)
+
+
+You can also use `term.show_reduction` to get an animated version.
+
+# How it works
+
+Under the wood, all the terms are converted into a list of nodes, that can either be a `lambda`, an `application` (with 2 arguments) or a `variable` (with 0 arguments).
+
+For efficiency, they are converted to a [polars](https://github.com/pola-rs/polars) dataframe in prefix traversal order.
+If you want to understand how it works, start by looking at the `.nodes` attribute of any term.

curryparty-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "curryparty"
+version = "0.1.0"
+description = "Python playground to learn lambda calculus"
+readme = "README.md"
+authors = [
+    { name = "Antonin P", email = "antonin.peronnet@telecom-paris.fr" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "polars>=1.36.1",
+    "svg-py>=1.9.2",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.13,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "marimo>=0.18.4",
+    "ruff>=0.14.8",
+]

curryparty-0.1.0/src/curryparty/__init__.py

@@ -0,0 +1,172 @@
+from typing import Iterable, List, Optional, Union
+
+import polars as pl
+from svg import SVG
+
+from .core import SCHEMA, beta_reduce, compose, find_redexes, find_variables, subtree
+from .display import (
+    compute_svg_frame_final,
+    compute_svg_frame_init,
+    compute_svg_frame_phase_a,
+    compute_svg_frame_phase_b,
+)
+from .utils import ShapeAnim
+
+__all__ = ["L", "V"]
+
+
+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 __call__(self, other: "Term") -> "Term":
+        return Term(compose(self.nodes, other.nodes))
+
+    def beta(self) -> Optional["Term"]:
+        candidates = find_redexes(self.nodes)
+        if len(candidates) == 0:
+            return None
+        _redex, lamb, b = candidates.row(0)
+        self.lamb = lamb
+        self.b = b
+        reduced = beta_reduce(self.nodes, lamb, b)
+        return Term(reduced)
+
+    def reduction_chain(self) -> Iterable["Term"]:
+        term = self
+        while True:
+            yield term
+            term = term.beta()
+            if term is None:
+                break
+
+    def show_reduction(self):
+        candidates = find_redexes(self.nodes)
+        if len(candidates) == 0:
+            return None
+        _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)
+        shapes: dict[int, ShapeAnim] = {}
+        N_STEPS = 8
+
+        for t in range(N_STEPS):
+            if t < 2:
+                items = compute_svg_frame_init(self.nodes)
+            elif t == 2 or t == 3:
+                items = compute_svg_frame_phase_a(self.nodes, lamb, b_subtree, vars)
+            elif t == 4 or t == 5:
+                items = compute_svg_frame_phase_b(
+                    self.nodes, lamb, b_subtree, new_nodes
+                )
+            else:
+                items = compute_svg_frame_final(new_nodes)
+            for k, e, attributes in items:
+                if k not in shapes:
+                    shapes[k] = ShapeAnim(e)
+                shapes[k].append_frame(t, attributes.items())
+
+        elements = [x.to_element(N_STEPS) for x in shapes.values()]
+        height = 2 + int(0.6 * len(self.nodes))
+        return Html(
+            SVG(
+                xmlns="http://www.w3.org/2000/svg",
+                viewBox=f"-10 0 30 {height}",  # type: ignore
+                height=f"{35 * height}px",  # type: ignore
+                elements=elements,
+            ).as_str()
+        )
+
+    def _repr_html_(self):
+        frame = compute_svg_frame_init(self.nodes)
+        elements = []
+        height = 2 + int(0.6 * len(self.nodes))
+        for _, e, attributes in frame:
+            for name, v in attributes.items():
+                e.__setattr__(name, v)
+            elements.append(e)
+        return SVG(
+            xmlns="http://www.w3.org/2000/svg",
+            viewBox=f"-10 0 30 {height}",  # type: ignore
+            height=f"{35 * height}px",  # type: ignore
+            elements=elements,
+        ).as_str()
+
+
+class L:
+    def __init__(self, *lambda_names):
+        self.n = len(lambda_names)
+        self.lambdas = {x: i for (i, x) in enumerate(lambda_names)}
+        self.refs: List[tuple[int, Union[int, str]]] = []
+        self.args = []
+        self.last_ = None
+
+    def lamb(self, name: str) -> "L":
+        self.n += 1
+        self.lambdas[name] = self.n
+        return self
+
+    def _append_subtree_or_subexpression(self, t: Union[str, "L"]):
+        if isinstance(t, L):
+            offset = self.n
+            for i, x in t.refs:
+                self.refs.append((offset + i, t.lambdas.get(x, x)))
+
+            for i, x in t.args:
+                self.args.append((offset + i, offset + x))
+            self.n += t.n
+        else:
+            assert isinstance(t, str)
+            self.refs.append((self.n, t))
+            self.n += 1
+
+    def _(self, x: Union[str, "L"]) -> "L":
+        self.last_ = self.n
+        self._append_subtree_or_subexpression(x)
+        return self
+
+    def call(self, arg: Union[str, "L"]) -> "L":
+        assert self.last_ is not None
+        self.refs = [(i + 1, x) if i >= self.last_ else (i, x) for (i, x) in self.refs]
+        self.args = [
+            (i + 1, x + 1) if i >= self.last_ else (i, x) for (i, x) in self.args
+        ]
+
+        self.n += 1
+        self.args.append((self.last_, self.n))
+        self._append_subtree_or_subexpression(arg)
+
+        return self
+
+    def build(self) -> "Term":
+        self.refs = [(i, self.lambdas.get(x, x)) for i, x in self.refs]
+        ref = pl.from_records(
+            self.refs, orient="row", schema={"id": pl.UInt32, "ref": pl.UInt32}
+        )
+        arg = pl.from_records(
+            self.args, orient="row", schema={"id": pl.UInt32, "arg": pl.UInt32}
+        )
+        data = (
+            pl.Series("id", range(self.n), dtype=pl.UInt32)
+            .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)
+
+
+def V(name: str) -> L:
+    return L()._(name)
+
+
+class Html:
+    def __init__(self, content: str):
+        self.content = content
+
+    def _repr_html_(self):
+        return self.content

curryparty-0.1.0/src/curryparty/core.py

@@ -0,0 +1,128 @@
+import polars as pl
+from polars import Schema, UInt32
+from polars.functions.lazy import coalesce
+
+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):
+    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):
+    parents = nodes.filter(pl.col("ref").is_null())
+    return (
+        parents.join(nodes, left_on="id", right_on=pl.col("id") - 1, suffix="_child")
+        .filter(
+            pl.col("arg").is_not_null(),
+            pl.col("ref_child").is_null(),
+            pl.col("arg_child").is_null(),
+        )
+        .select(redex="id", lamb="id_child", b="arg")
+    )
+
+
+def find_variables(nodes: pl.DataFrame, lamb: int):
+    return nodes.filter(pl.col("ref") == lamb).select("id", replaced=True)
+
+
+def subtree(nodes: pl.DataFrame, root: int) -> pl.DataFrame:
+    rightmost = root
+    while True:
+        ref = nodes["ref"][rightmost]
+        arg = nodes["arg"][rightmost]
+        if ref is not None:
+            return nodes.filter(pl.col("id").is_between(root, 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.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",
+        )
+        .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),
+        )
+        .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)
+            ),
+        )
+        .sort("bid")
+        .with_row_index("id")
+    )
+
+    return (
+        new_nodes.join(
+            new_nodes.select(bid_ref="bid", ref="id"),
+            on="bid_ref",
+            how="left",
+        )
+        .join(
+            new_nodes.select(bid_ref_fallback="bid", ref_fallback="id"),
+            on="bid_ref_fallback",
+            how="left",
+        )
+        .join(
+            new_nodes.select(bid_arg="bid", arg="id"),
+            on="bid_arg",
+            how="left",
+        )
+        .select("id", ref=pl.coalesce("ref", "ref_fallback"), arg="arg", bid="bid")
+        .sort("id")
+    )

curryparty-0.1.0/src/curryparty/display.py

@@ -0,0 +1,232 @@
+from typing import Any, Iterable, Optional, Union
+
+import polars as pl
+import svg
+
+from .utils import Interval
+
+
+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 = nodes.select(pl.col("ref").count()).item()
+
+    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,
+    replaced=False,
+    removed=False,
+) -> Iterable[tuple[Any, svg.Element, dict]]:
+    x_node = x[i_node]
+    y_node = y[i_node]
+    if True:
+        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"
+
+        stroke_width = 0.05
+        stroke = "gray"
+        if arg is not None:
+            stroke_width = 0.1
+            stroke = "orange"
+        r = svg.Rect(
+            height=0.8,
+            stroke_width=stroke_width,
+            stroke=stroke,
+        )
+
+        yield (
+            ("r", key),
+            r,
+            {
+                "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,
+            },
+        )
+
+    if ref is not None:
+        y_ref = y[ref]
+        e = svg.Line(
+            stroke_width=0.2,
+            stroke="gray",
+        )
+        yield (
+            ("l", key),
+            e,
+            {
+                "x1": x_node[0] + 0.5,
+                "y1": y_node[0] + 0.1,
+                "x2": x_node[0] + 0.5,
+                "y2": y_ref[0] + 0.9,
+                "stroke": "green" if replaced else "gray",
+            },
+        )
+
+    if arg is not None:
+        x_arg = x[arg]
+        y_arg = y[arg]
+        e1 = svg.Line(
+            stroke="black",
+            stroke_width=0.05,
+        )
+        e2 = svg.Circle(fill="black", r=0.1)
+        if not removed:
+            yield (
+                ("b", key),
+                e1,
+                {
+                    "x1": 0.5 + x_node[1],
+                    "y1": 0.5 + y_node[0],
+                    "x2": 0.5 + x_arg[0],
+                    "y2": 0.5 + y_arg[0],
+                },
+            )
+            yield (
+                ("c", key),
+                e2,
+                {
+                    "cx": 0.5 + x_node[1],
+                    "cy": 0.5 + y_node[0],
+                },
+            )
+
+
+def compute_svg_frame_init(
+    nodes: pl.DataFrame,
+) -> Iterable[tuple[Any, svg.Element, dict[str, Any]]]:
+    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, target_id)
+
+
+def compute_svg_frame_phase_a(
+    nodes: pl.DataFrame,
+    lamb: int,
+    b_subtree: pl.DataFrame,
+    vars: pl.Series,
+):
+    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,
+            target_id,
+            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))
+
+
+def compute_svg_frame_phase_b(
+    nodes: pl.DataFrame,
+    lamb: int,
+    b_subtree: pl.DataFrame,
+    new_nodes: pl.DataFrame,
+):
+    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
+            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"]
+            )
+            if bid_arg["minor"] == b:
+                arg = bid_arg["major"]
+        key = (v, minor) if minor != v else minor
+        yield from draw(x, y, key, ref, arg, key=key)
+
+
+def compute_svg_frame_final(reduced: pl.DataFrame):
+    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)

curryparty-0.1.0/src/curryparty/utils.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Any, Iterable, Optional
+
+from svg import Animate, Element
+
+
+@dataclass
+class Interval:
+    values: Optional[tuple[int, int]]
+
+    def __or__(self: "Interval", other: "Interval") -> "Interval":
+        if self.values is None:
+            if other.values is None:
+                return Interval(None)
+            else:
+                return other
+        else:
+            if other.values is None:
+                return self
+        return Interval(
+            (min(self.values[0], other.values[0]), max(self.values[1], other.values[1]))
+        )
+
+    def __getitem__(self, index):
+        assert self.values is not None, "interval is empty"
+        return self.values[index]
+
+    def shift(self, offset: int) -> "Interval":
+        if self.values is None:
+            return Interval(None)
+        else:
+            return Interval((self.values[0] + offset, self.values[1] + offset))
+
+
+@dataclass
+class ShapeAnim:
+    shape: Element
+    attributes: set[str]
+    values: dict[tuple[int, str], Any]
+    n: int
+    duration: int
+
+    def __init__(
+        self,
+        shape: Element,
+        duration: int = 7,
+    ):
+        self.shape = shape
+        self.attributes = set()
+        self.values = {}
+        self.duration = duration
+
+    def append_frame(self, i: int, attributes: Iterable[tuple[str, Any]]):
+        for name, v in attributes:
+            self.attributes.add(name)
+            self.values[i, name] = v
+
+    def to_element(self, n: int):
+        elements = []
+
+        visible = [
+            all((i, name) in self.values for name in self.attributes) for i in range(n)
+        ]
+
+        for name in self.attributes:
+            non_nulls = [
+                self.values[i, name] for i in range(n) if (i, name) in self.values
+            ]
+            for i in reversed(range(n)):
+                if (i, name) in self.values:
+                    break
+                self.values[i, name] = non_nulls[-1]
+            for i in range(n):
+                if (i, name) not in self.values:
+                    self.values[i, name] = non_nulls[0]
+            elements.append(
+                Animate(
+                    attributeName=name,
+                    values=";".join(str(self.values[i, name]) for i in range(n)),
+                    dur=timedelta(seconds=self.duration),
+                    repeatCount="indefinite",
+                )
+            )
+        elements.append(
+            Animate(
+                attributeName="opacity",
+                values=";".join("1" if v else "0" for v in visible),
+                dur=timedelta(seconds=self.duration),
+                repeatCount="indefinite",
+            )
+        )
+
+        assert not self.shape.elements
+        self.shape.elements = elements
+        return self.shape