egglog 7.0.0__cp311-none-win_amd64.whl → 7.2.0__cp311-none-win_amd64.whl

egglog/runtime.py

@@ -11,7 +11,8 @@ so they are not mangled by Python and can be accessed by the user.
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from collections.abc import Callable
+from dataclasses import dataclass, replace
 from inspect import Parameter, Signature
 from itertools import zip_longest
 from typing import TYPE_CHECKING, NoReturn, TypeVar, Union, cast, get_args, get_origin
@@ -22,7 +23,7 @@ from .thunk import Thunk
 from .type_constraint_solver import *
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable
+    from collections.abc import Iterable
 
     from .egraph import Expr
 
@@ -60,6 +61,8 @@ REFLECTED_BINARY_METHODS = {
 # Set this globally so we can get access to PyObject when we have a type annotation of just object.
 # This is the only time a type annotation doesn't need to include the egglog type b/c object is top so that would be redundant statically.
 _PY_OBJECT_CLASS: RuntimeClass | None = None
+# Same for functions
+_UNSTABLE_FN_CLASS: RuntimeClass | None = None
 
 T = TypeVar("T")
 
@@ -67,6 +70,8 @@ T = TypeVar("T")
 def resolve_type_annotation(decls: Declarations, tp: object) -> TypeOrVarRef:
     """
     Resolves a type object into a type reference.
+
+    Any runtime type object decls will be add to those passed in.
     """
     if isinstance(tp, TypeVar):
         return ClassTypeVarRef(tp.__name__)
@@ -79,6 +84,11 @@ def resolve_type_annotation(decls: Declarations, tp: object) -> TypeOrVarRef:
     if tp == object:
         assert _PY_OBJECT_CLASS
         return resolve_type_annotation(decls, _PY_OBJECT_CLASS)
+    # If the type is a `Callable` then convert it into a UnstableFn
+    if get_origin(tp) == Callable:
+        assert _UNSTABLE_FN_CLASS
+        args, ret = get_args(tp)
+        return resolve_type_annotation(decls, _UNSTABLE_FN_CLASS[(ret, *args)])
     if isinstance(tp, RuntimeClass):
         decls |= tp
         return tp.__egg_tp__
@@ -95,9 +105,11 @@ class RuntimeClass(DelayedDeclerations):
     __egg_tp__: TypeRefWithVars
 
     def __post_init__(self) -> None:
-        global _PY_OBJECT_CLASS
-        if self.__egg_tp__.name == "PyObject":
+        global _PY_OBJECT_CLASS, _UNSTABLE_FN_CLASS
+        if (name := self.__egg_tp__.name) == "PyObject":
             _PY_OBJECT_CLASS = self
+        elif name == "UnstableFn" and not self.__egg_tp__.args:
+            _UNSTABLE_FN_CLASS = self
 
     def verify(self) -> None:
         if not self.__egg_tp__.args:
@@ -113,26 +125,46 @@ class RuntimeClass(DelayedDeclerations):
         Create an instance of this kind by calling the __init__ classmethod
         """
         # If this is a literal type, initializing it with a literal should return a literal
-        if self.__egg_tp__.name == "PyObject":
+        if (name := self.__egg_tp__.name) == "PyObject":
             assert len(args) == 1
             return RuntimeExpr.__from_value__(
                 self.__egg_decls__, TypedExprDecl(self.__egg_tp__.to_just(), PyObjectDecl(args[0]))
             )
-        if self.__egg_tp__.name in UNARY_LIT_CLASS_NAMES:
+        if name == "UnstableFn":
+            assert not kwargs
+            fn_arg, *partial_args = args
+            del args
+            # Assumes we don't have types set for UnstableFn w/ generics, that they have to be inferred
+
+            # 1. Create a runtime function for the first arg
+            assert isinstance(fn_arg, RuntimeFunction)
+            # 2. Call it with the partial args, and use untyped vars for the rest of the args
+            res = fn_arg(*partial_args, _egg_partial_function=True)
+            assert res is not None, "Mutable partial functions not supported"
+            # 3. Use the inferred return type and inferred rest arg types as the types of the function, and
+            #    the partially applied args as the args.
+            call = (res_typed_expr := res.__egg_typed_expr__).expr
+            return_tp = res_typed_expr.tp
+            assert isinstance(call, CallDecl), "partial function must be a call"
+            n_args = len(partial_args)
+            value = PartialCallDecl(replace(call, args=call.args[:n_args]))
+            remaining_arg_types = [a.tp for a in call.args[n_args:]]
+            type_ref = JustTypeRef("UnstableFn", (return_tp, *remaining_arg_types))
+            return RuntimeExpr.__from_value__(Declarations.create(self, res), TypedExprDecl(type_ref, value))
+
+        if name in UNARY_LIT_CLASS_NAMES:
             assert len(args) == 1
             assert isinstance(args[0], int | float | str | bool)
             return RuntimeExpr.__from_value__(
                 self.__egg_decls__, TypedExprDecl(self.__egg_tp__.to_just(), LitDecl(args[0]))
             )
-        if self.__egg_tp__.name == UNIT_CLASS_NAME:
+        if name == UNIT_CLASS_NAME:
             assert len(args) == 0
             return RuntimeExpr.__from_value__(
                 self.__egg_decls__, TypedExprDecl(self.__egg_tp__.to_just(), LitDecl(None))
             )
-
-        return RuntimeFunction(
-            Thunk.value(self.__egg_decls__), ClassMethodRef(self.__egg_tp__.name, "__init__"), self.__egg_tp__.to_just()
-        )(*args, **kwargs)
+        fn = RuntimeFunction(Thunk.value(self.__egg_decls__), InitRef(name), self.__egg_tp__.to_just())
+        return fn(*args, **kwargs)  # type: ignore[arg-type]
 
     def __dir__(self) -> list[str]:
         cls_decl = self.__egg_decls__.get_class_decl(self.__egg_tp__.name)
@@ -184,6 +216,12 @@ class RuntimeClass(DelayedDeclerations):
             return RuntimeFunction(
                 Thunk.value(self.__egg_decls__), ClassMethodRef(self.__egg_tp__.name, name), self.__egg_tp__.to_just()
             )
+        # allow referencing properties and methods as class variables as well
+        if name in cls_decl.properties:
+            return RuntimeFunction(Thunk.value(self.__egg_decls__), PropertyRef(self.__egg_tp__.name, name))
+        if name in cls_decl.methods:
+            return RuntimeFunction(Thunk.value(self.__egg_decls__), MethodRef(self.__egg_tp__.name, name))
+
         msg = f"Class {self.__egg_tp__.name} has no method {name}"
         if name == "__ne__":
             msg += ". Did you mean to use the ne(...).to(...)?"
@@ -207,24 +245,50 @@ class RuntimeFunction(DelayedDeclerations):
     # bound methods need to store RuntimeExpr not just TypedExprDecl, so they can mutate the expr if required on self
     __egg_bound__: JustTypeRef | RuntimeExpr | None = None
 
-    def __call__(self, *args: object, **kwargs: object) -> RuntimeExpr | None:
+    def __call__(self, *args: object, _egg_partial_function: bool = False, **kwargs: object) -> RuntimeExpr | None:
         from .conversion import resolve_literal
 
         if isinstance(self.__egg_bound__, RuntimeExpr):
             args = (self.__egg_bound__, *args)
-        fn_decl = self.__egg_decls__.get_callable_decl(self.__egg_ref__).to_function_decl()
+        signature = self.__egg_decls__.get_callable_decl(self.__egg_ref__).to_function_decl().signature
+        decls = self.__egg_decls__.copy()
+        # Special case function application bc we dont support variadic generics yet generally
+        if signature == "fn-app":
+            fn, *rest_args = args
+            args = tuple(rest_args)
+            assert not kwargs
+            assert isinstance(fn, RuntimeExpr)
+            decls.update(fn)
+            function_value = fn.__egg_typed_expr__
+            fn_tp = function_value.tp
+            assert fn_tp.name == "UnstableFn"
+            fn_return_tp, *fn_arg_tps = fn_tp.args
+            signature = FunctionSignature(
+                tuple(tp.to_var() for tp in fn_arg_tps),
+                tuple(f"_{i}" for i in range(len(fn_arg_tps))),
+                (None,) * len(fn_arg_tps),
+                fn_return_tp.to_var(),
+            )
+        else:
+            function_value = None
+            assert isinstance(signature, FunctionSignature)
+
         # Turn all keyword args into positional args
-        bound = callable_decl_to_signature(fn_decl, self.__egg_decls__).bind(*args, **kwargs)
+        py_signature = to_py_signature(signature, self.__egg_decls__, _egg_partial_function)
+        try:
+            bound = py_signature.bind(*args, **kwargs)
+        except TypeError as err:
+            raise TypeError(f"Failed to call {self} with args {args} and kwargs {kwargs}") from err
+        del kwargs
         bound.apply_defaults()
         assert not bound.kwargs
-        del args, kwargs
+        args = bound.args
 
         upcasted_args = [
             resolve_literal(cast(TypeOrVarRef, tp), arg)
-            for arg, tp in zip_longest(bound.args, fn_decl.arg_types, fillvalue=fn_decl.var_arg_type)
+            for arg, tp in zip_longest(args, signature.arg_types, fillvalue=signature.var_arg_type)
         ]
-
-        decls = Declarations.create(self, *upcasted_args)
+        decls.update(*upcasted_args)
 
         tcs = TypeConstraintSolver(decls)
         bound_tp = (
@@ -234,19 +298,29 @@ class RuntimeFunction(DelayedDeclerations):
             if isinstance(self.__egg_bound__, RuntimeExpr)
             else self.__egg_bound__
         )
-        if bound_tp and bound_tp.args:
+        if (
+            bound_tp
+            and bound_tp.args
+            # Don't  bind class if we have a first class function arg, b/c we don't support that yet
+            and not function_value
+        ):
             tcs.bind_class(bound_tp)
         arg_exprs = tuple(arg.__egg_typed_expr__ for arg in upcasted_args)
         arg_types = [expr.tp for expr in arg_exprs]
         cls_name = bound_tp.name if bound_tp else None
         return_tp = tcs.infer_return_type(
-            fn_decl.arg_types, fn_decl.return_type or fn_decl.arg_types[0], fn_decl.var_arg_type, arg_types, cls_name
+            signature.arg_types, signature.semantic_return_type, signature.var_arg_type, arg_types, cls_name
         )
-        bound_params = cast(JustTypeRef, bound_tp).args if isinstance(self.__egg_ref__, ClassMethodRef) else None
+        bound_params = (
+            cast(JustTypeRef, bound_tp).args if isinstance(self.__egg_ref__, ClassMethodRef | InitRef) else None
+        )
+        # If we were using unstable-app to call a funciton, add that function back as the first arg.
+        if function_value:
+            arg_exprs = (function_value, *arg_exprs)
         expr_decl = CallDecl(self.__egg_ref__, arg_exprs, bound_params)
         typed_expr_decl = TypedExprDecl(return_tp, expr_decl)
         # If there is not return type, we are mutating the first arg
-        if not fn_decl.return_type:
+        if not signature.return_type:
             first_arg = upcasted_args[0]
             first_arg.__egg_thunk__ = Thunk.value((decls, typed_expr_decl))
             return None
@@ -262,19 +336,26 @@ class RuntimeFunction(DelayedDeclerations):
         return pretty_callable_ref(self.__egg_decls__, self.__egg_ref__, first_arg, bound_tp_params)
 
 
-def callable_decl_to_signature(
-    decl: FunctionDecl,
-    decls: Declarations,
-) -> Signature:
+def to_py_signature(sig: FunctionSignature, decls: Declarations, optional_args: bool) -> Signature:
+    """
+    Convert to a Python signature.
+
+    If optional_args is true, then all args will be treated as optional, as if a default was provided that makes them
+    a var with that arg name as the value.
+
+    Used for partial application to try binding a function with only some of its args.
+    """
     parameters = [
         Parameter(
             n,
             Parameter.POSITIONAL_OR_KEYWORD,
-            default=RuntimeExpr.__from_value__(decls, TypedExprDecl(t.to_just(), d)) if d else Parameter.empty,
+            default=RuntimeExpr.__from_value__(decls, TypedExprDecl(t.to_just(), d if d is not None else VarDecl(n)))
+            if d is not None or optional_args
+            else Parameter.empty,
         )
-        for n, d, t in zip(decl.arg_names, decl.arg_defaults, decl.arg_types, strict=True)
+        for n, d, t in zip(sig.arg_names, sig.arg_defaults, sig.arg_types, strict=True)
     ]
-    if isinstance(decl, FunctionDecl) and decl.var_arg_type is not None:
+    if isinstance(sig, FunctionSignature) and sig.var_arg_type is not None:
         parameters.append(Parameter("__rest", Parameter.VAR_POSITIONAL))
     return Signature(parameters)
 
@@ -412,10 +493,14 @@ for name in list(BINARY_METHODS) + list(UNARY_METHODS) + ["__getitem__", "__call
             try:
                 return call_method_min_conversion(self, args[0], __name)
             except ConvertError:
-                return NotImplemented
+                # Defer raising not imeplemented in case the dunder method is not symmetrical, then
+                # we use the standard process
+                pass
         if __name in class_decl.methods:
             fn = RuntimeFunction(Thunk.value(self.__egg_decls__), MethodRef(class_name, __name), self)
-            return fn(*args, **kwargs)
+            return fn(*args, **kwargs)  # type: ignore[arg-type]
+        if __name in PARTIAL_METHODS:
+            return NotImplemented
         raise TypeError(f"{class_name!r} object does not support {__name}")
 
     setattr(RuntimeExpr, name, _special_method)
@@ -436,8 +521,8 @@ def call_method_min_conversion(slf: object, other: object, name: str) -> Runtime
     # find a minimum type that both can be converted to
     # This is so so that calls like `-0.1 * Int("x")` work by upcasting both to floats.
     min_tp = min_convertable_tp(slf, other, name)
-    slf = resolve_literal(min_tp.to_var(), slf)
-    other = resolve_literal(min_tp.to_var(), other)
+    slf = resolve_literal(TypeRefWithVars(min_tp), slf)
+    other = resolve_literal(TypeRefWithVars(min_tp), other)
     method = RuntimeFunction(Thunk.value(slf.__egg_decls__), MethodRef(slf.__egg_class_name__, name), slf)
     return method(other)
 

egglog/thunk.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Generic, TypeVar
 
-from typing_extensions import ParamSpec, TypeVarTuple, Unpack
+from typing_extensions import TypeVarTuple, Unpack
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -12,7 +12,6 @@ if TYPE_CHECKING:
 __all__ = ["Thunk"]
 
 T = TypeVar("T")
-P = ParamSpec("P")
 TS = TypeVarTuple("TS")
 
 
@@ -22,7 +21,7 @@ class Thunk(Generic[T, Unpack[TS]]):
     Cached delayed function call.
     """
 
-    state: Resolved[T] | Unresolved[T, Unpack[TS]] | Resolving[T]
+    state: Resolved[T] | Unresolved[T, Unpack[TS]] | Resolving[T] | Error
 
     @classmethod
     def fn(
@@ -45,14 +44,21 @@ class Thunk(Generic[T, Unpack[TS]]):
                 return value
             case Unresolved(fn, args, fallback):
                 self.state = Resolving(fallback)
-                res = fn(*args)
-                self.state = Resolved(res)
-                return res
+                try:
+                    res = fn(*args)
+                except Exception as e:
+                    self.state = Error(e)
+                    raise
+                else:
+                    self.state = Resolved(res)
+                    return res
             case Resolving(fallback):
                 if fallback is None:
                     msg = "Recursively resolving thunk without fallback"
                     raise ValueError(msg)
                 return fallback()
+            case Error(e):
+                raise e
 
 
 @dataclass
@@ -70,3 +76,8 @@ class Unresolved(Generic[T, Unpack[TS]]):
 @dataclass
 class Resolving(Generic[T]):
     fallback: Callable[[], T] | None
+
+
+@dataclass
+class Error:
+    e: Exception

egglog/type_constraint_solver.py

@@ -79,9 +79,10 @@ class TypeConstraintSolver:
         Also returns the bound type params if the class name is passed in.
         """
         self._infer_typevars(fn_return, return_, cls_name)
-        arg_types = (
-            self._subtitute_typevars(a, cls_name) for a in chain(fn_args, repeat(fn_var_args) if fn_var_args else [])
-        )
+        arg_types: Iterable[JustTypeRef] = [self._subtitute_typevars(a, cls_name) for a in fn_args]
+        if fn_var_args:
+            # Need to be generator so it can be infinite for variable args
+            arg_types = chain(arg_types, repeat(self._subtitute_typevars(fn_var_args, cls_name)))
         bound_typevars = (
             tuple(
                 v
@@ -132,8 +133,8 @@ class TypeConstraintSolver:
     def _subtitute_typevars(self, tp: TypeOrVarRef, cls_name: str | None) -> JustTypeRef:
         match tp:
             case ClassTypeVarRef(name):
+                assert cls_name is not None
                 try:
-                    assert cls_name is not None
                     return self._cls_typevar_index_to_type[cls_name][name]
                 except KeyError as e:
                     raise TypeConstraintError(f"Not enough bound typevars for {tp}") from e

{egglog-7.0.0.dist-info → egglog-7.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: egglog
-Version: 7.0.0
+Version: 7.2.0
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -31,11 +31,6 @@ Requires-Dist: egglog[array]; extra == 'docs'
 Requires-Dist: line-profiler; extra == 'docs'
 Requires-Dist: sphinxcontrib-mermaid; extra == 'docs'
 Requires-Dist: ablog; extra == 'docs'
-Requires-Dist: pre-commit; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: anywidget[dev]; extra == 'dev'
-Requires-Dist: egglog[docs,test]; extra == 'dev'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: mypy; extra == 'test'
 Requires-Dist: syrupy; extra == 'test'
@@ -45,12 +40,17 @@ Requires-Dist: pytest-benchmark; extra == 'test'
 Requires-Dist: pytest-xdist; extra == 'test'
 Requires-Dist: scikit-learn; extra == 'array'
 Requires-Dist: array_api_compat; extra == 'array'
-Requires-Dist: numba==0.59.0rc1; extra == 'array'
-Requires-Dist: llvmlite==0.42.0rc1; extra == 'array'
+Requires-Dist: numba==0.59.1; extra == 'array'
+Requires-Dist: llvmlite==0.42.0; extra == 'array'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: anywidget[dev]; extra == 'dev'
+Requires-Dist: egglog[docs,test]; extra == 'dev'
 Provides-Extra: docs
-Provides-Extra: dev
 Provides-Extra: test
 Provides-Extra: array
+Provides-Extra: dev
 License-File: LICENSE
 Summary: e-graphs in Python built around the the egglog rust library
 License: MIT
@@ -59,7 +59,7 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 # `egglog` Python wrapper
 
-[![Documentation Status](https://readthedocs.org/projects/egglog-python/badge/?version=latest)](https://egglog-python.readthedocs.io/en/latest/?badge=latest) [![Test](https://github.com/egraphs-good/egglog-python/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/egraphs-good/egglog-python/actions/workflows/CI.yml) [![PyPi Package](https://img.shields.io/pypi/v/egglog.svg)](https://pypi.org/project/egglog/) [![License](https://img.shields.io/pypi/l/egglog.svg)](https://pypi.org/project/egglog/) [![Python Versions](https://img.shields.io/pypi/pyversions/egglog.svg)](https://pypi.org/project/egglog/) [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit) [![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/egraphs-good/egglog-python)
+[![Documentation Status](https://readthedocs.org/projects/egglog-python/badge/?version=latest)](https://egglog-python.readthedocs.io/latest/?badge=latest) [![Test](https://github.com/egraphs-good/egglog-python/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/egraphs-good/egglog-python/actions/workflows/CI.yml) [![PyPi Package](https://img.shields.io/pypi/v/egglog.svg)](https://pypi.org/project/egglog/) [![License](https://img.shields.io/pypi/l/egglog.svg)](https://pypi.org/project/egglog/) [![Python Versions](https://img.shields.io/pypi/pyversions/egglog.svg)](https://pypi.org/project/egglog/) [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit) [![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/egraphs-good/egglog-python)
 
 `egglog` is a Python package that provides bindings to the Rust library [`egglog`](https://github.com/egraphs-good/egglog/),
 allowing you to use e-graphs in Python for optimization, symbolic computation, and analysis.

{egglog-7.0.0.dist-info → egglog-7.2.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-egglog-7.0.0.dist-info/METADATA,sha256=Z_hOJtco7EDSXWxJH_L2Sod2Za3dYICl6SaSN-UKVD0,3838
-egglog-7.0.0.dist-info/WHEEL,sha256=PI_yinHuPssCo943lUdZTaSBEwIUzDPKgEICR1imaRE,96
-egglog-7.0.0.dist-info/license_files/LICENSE,sha256=TfaboMVZ81Q6OUaKjU7z6uVjSlcGKclLYcOpgDbm9_s,1091
-egglog/bindings.pyi,sha256=q9gyhu_kTcAPXtyu2IzHhytzjhua4sDEjM1h3XrEw60,11588
-egglog/builtins.py,sha256=lI-WAQGsXYYNvPXBnR6SpRpoTLFQ8u6GaVkrJ8nb-GY,11962
+egglog-7.2.0.dist-info/METADATA,sha256=O3Uq5oIIHWZ-bG2XVILykl-0dYyuNuoR9Dxj38v6bXs,3829
+egglog-7.2.0.dist-info/WHEEL,sha256=PI_yinHuPssCo943lUdZTaSBEwIUzDPKgEICR1imaRE,96
+egglog-7.2.0.dist-info/license_files/LICENSE,sha256=TfaboMVZ81Q6OUaKjU7z6uVjSlcGKclLYcOpgDbm9_s,1091
+egglog/bindings.pyi,sha256=iFdtYHqPjuVt46qh1IE81cOI-lbGgPISKQB-3ERNzhI,11770
+egglog/builtins.py,sha256=p5oZLDleCgQC8G2Zp2EvmqsfVnpgmARqUHqosKSSKnQ,13120
 egglog/config.py,sha256=mALVaxh7zmGrbuyzaVKVmYKcu1lF703QsKJw8AF7gSM,176
-egglog/conversion.py,sha256=9unbL5LYkYQ-Jc9gsWCd1VwdrI_w3mwudAcm-5PDPcc,6143
-egglog/declarations.py,sha256=zTm0TQd7YB3DfxCldONDMg-AH0leCoU4EyQ-pzfUs7A,15454
-egglog/egraph.py,sha256=HwK4vfI5eSndaK4tVinV5bWJ_K4O5Pzq8zA2un2nAcs,63151
-egglog/egraph_state.py,sha256=2UuZ2XOmTXm-D_Ytfw5LjicsjpM52vLevbOF3ucJtyc,17691
+egglog/conversion.py,sha256=4JhocGd1_nwmFMVNCzDDwj6aWfhBFTX2hm_7Xc_DiUM,6328
+egglog/declarations.py,sha256=WpZ1yyw4vlWm3Xi_otPP2IU51IqNcDmJA5y20RcBFBQ,18583
+egglog/egraph.py,sha256=Q3ZJhtzzWcsukuarT0vT48-DkfHe17adLLUHn-pILPE,68657
+egglog/egraph_state.py,sha256=kXCNt4zenG1meRv5T6B8xI5oH_NreA06JMhmqv_F-og,21802
 egglog/examples/bool.py,sha256=pWZTjfXR1cFy3KcihLBU5AF5rn83ImORlhUUJ1YiAXc,733
 egglog/examples/eqsat_basic.py,sha256=ORXFYYEDsEZK2IPhHtoFsd-LdjMiQi1nn7kix4Nam0s,1011
 egglog/examples/fib.py,sha256=wAn-PjazxgHDkXAU4o2xTk_GtM_iGL0biV66vWM1st4,520
+egglog/examples/higher_order_functions.py,sha256=CBZqnqVdYGgztHw5QWtcnUhzs1nnBcw4O-gjSzAxjRc,1203
 egglog/examples/lambda_.py,sha256=hQBOaSw_yorNcbkQVu2EhgSc0IZNWIny7asaOlcUk9s,8496
 egglog/examples/matrix.py,sha256=_zmjgfFr2O_LjTcsTD-45_38Y_M1sP3AV39K6oFxAdw,5136
 egglog/examples/ndarrays.py,sha256=T-wwef-n-3LDSjaO35zA8AZH5DXFFqq0XBSCQKEXV6E,4186
@@ -18,7 +19,7 @@ egglog/examples/README.rst,sha256=QrbfmivODBvUvmY3-dHarcbC6bEvwoqAfTDhiI-aJxU,23
 egglog/examples/resolution.py,sha256=sKkbRI_v9XkQM0DriacKLINqKKDqYGFhvMCAS9tZbTA,2203
 egglog/examples/schedule_demo.py,sha256=iJtIbcLaZ7zK8UalY0z7KAKMqYjQx0MKTsNF24lKtik,652
 egglog/examples/__init__.py,sha256=KuhaJFOyz_rpUvEqZubsgLnv6rhQNE_AVFXA6bUnpdY,34
-egglog/exp/array_api.py,sha256=ClS1kbPq1xY4LwmllCo3wHstmZ7dbSKQP8xZcaah6fQ,41310
+egglog/exp/array_api.py,sha256=b7MoUuH2sIW3KnUX7fGPaflwlCCskgrt1GsidVT-KG4,41474
 egglog/exp/array_api_jit.py,sha256=HIZzd0G17u-u_F4vfRdhoYvRo-ETx5HFO3RBcOfLcco,1287
 egglog/exp/array_api_numba.py,sha256=OjONBLdFRukx4vKiNK_rBxjMzsxbWpMEdD7JcGHJjmY,2924
 egglog/exp/array_api_program_gen.py,sha256=crgUYXXNhQdfTq31FSIpWLIfzNsgQD8ngg3OosCtIgg,19680
@@ -27,13 +28,13 @@ egglog/exp/siu_examples.py,sha256=KZmpkSCgbL4uqHhx2Jh9Adz1_cDbkIlyXPa1Kh_0O_8,78
 egglog/exp/__init__.py,sha256=G9zeKUcPBgIhgUg1meC86OfZVFETYIugyHWseTcCe_0,52
 egglog/graphviz_widget.py,sha256=YtI7LCFWHihDQ1qLvdj2SVYEcuZLSooFUYheunOTxdc,1339
 egglog/ipython_magic.py,sha256=VA19xAb6Sz7-IxlJBbnZW_gVFDqaYNnvdMB9QitndjE,1254
-egglog/pretty.py,sha256=PORBaI1jlPSgySipX8foIS5hBZPlY-W5bv2clD-J1Ps,17051
+egglog/pretty.py,sha256=s5XBIB7kMrxV25aO-F4NW5Jli2DOoc72wwswFYxJPjM,19561
 egglog/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-egglog/runtime.py,sha256=U6fsbTU81hWZdW8chCbnuA3OoOSZ8JnWTDE-M5WF3OM,18722
-egglog/thunk.py,sha256=jsj5lp6qU87GTseYip_shE7ZTYbF9E1GDcB8R1ubQh8,1925
-egglog/type_constraint_solver.py,sha256=0c8oy-sLCVN0XndfAyRxO1AvIgfQuszw0NaRJ9ILysE,5692
+egglog/runtime.py,sha256=s32xdoD_mIdDRi_PJQ5E_kSNyhUkT310osH38kZfCSk,23174
+egglog/thunk.py,sha256=bm1zZUzwey0DijtMZkSulyfiWjCAg_1UmXaSG8qvvjs,2170
+egglog/type_constraint_solver.py,sha256=MW22gwryNOqsYaB__dCCjVvdnB1Km5fovoW2IgUXaVo,5836
 egglog/widget.css,sha256=WJS2M1wQdujhSTCakMa_ZXuoTPre1Uy1lPcvBE1LZQU,102
 egglog/widget.js,sha256=UNOER3sYZ-bS7Qhw9S6qtpR81FuHa5DzXQaWWtQq334,2021
 egglog/__init__.py,sha256=iUrVe5fb0XFyMCS3CwTjwhKEtU8KpIkdTpJpnUhm8o0,247
-egglog/bindings.cp311-win_amd64.pyd,sha256=LBMLfGkUMSR6p16iXtiYRebB5rQcrNDxMAgUHVAKBQA,5108224
-egglog-7.0.0.dist-info/RECORD,,
+egglog/bindings.cp311-win_amd64.pyd,sha256=7EuZkPO4dxLNKrmTWuEZdHrX0eYDKEBwfdYSpgkD-94,4591104
+egglog-7.2.0.dist-info/RECORD,,