fixpoints 0.4.0.post85.dev0__tar.gz → 0.5.0.post1.dev0__tar.gz

{fixpoints-0.4.0.post85.dev0 → fixpoints-0.5.0.post1.dev0}/.gitignore

@@ -211,6 +211,12 @@ __marimo__/
 .devenv/
 result
 
+# devenv/nixago scaffolding regenerated by running `nix develop` in a paper subdirectory
+# (the canonical copies live at the repository root)
+/papers/co-lambda/.envrc
+/papers/co-lambda/.gitattributes
+/papers/co-lambda/.vscode/
+
 # LaTeX
 *.pdf
 *.aux
@@ -236,6 +242,6 @@ experiment_results.db
 # nixago: ignore-linked-files
 /.vscode/extensions.json
 
-/inheritance-calculus/arxiv-submission.tar.gz
+arxiv-submission.tar.gz
 node_modules/
-inheritance-calculus/comment.cut
+comment.cut

{fixpoints-0.4.0.post85.dev0 → fixpoints-0.5.0.post1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixpoints
-Version: 0.4.0.post85.dev0
+Version: 0.5.0.post1.dev0
 Summary: Least-fixpoint cached-property infrastructure for mutual recursion
 Project-URL: Repository, https://github.com/Atry/MIXINv2
 Author-email: "Yang, Bo" <yang-bo@yang-bo.com>
@@ -9,7 +9,7 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 # fixpoints

{fixpoints-0.4.0.post85.dev0 → fixpoints-0.5.0.post1.dev0}/pyproject.toml

@@ -18,7 +18,7 @@ dynamic = ["version"]
 description = "Least-fixpoint cached-property infrastructure for mutual recursion"
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.13"
+requires-python = ">=3.11"
 authors = [{ name = "Yang, Bo", email = "yang-bo@yang-bo.com" }]
 classifiers = [
     "Development Status :: 3 - Alpha",

{fixpoints-0.4.0.post85.dev0 → fixpoints-0.5.0.post1.dev0}/src/fixpoints/_core.py

@@ -52,10 +52,9 @@ class _FixpointContext:
         when they encounter reentry.
         """
         for instance in self.participant_refs:
-            instance_dict = instance.__dict__
             instance_id = id(instance)
             for attr_name in self._clearable_attr_names:
-                value = instance_dict.pop(attr_name, None)
+                value = _clear_fixpoint_attr(instance, attr_name)
                 if value is not None:
                     self.approximations[(instance_id, attr_name)] = value
 
@@ -82,6 +81,110 @@ class FixpointRecursionError(RecursionError):
 
 _FIXPOINT_SENTINEL = object()
 
+_CACHE_SLOT_PREFIX = "_fpc_"
+
+
+def _make_slot_accessors(slot_name: str) -> "tuple[Callable, Callable, Callable]":
+    """Generate compiled per-property slot accessors via AST compilation.
+
+    Returns ``(cache_get, cache_set, cache_pop)`` with the slot name baked into bytecode:
+    direct slot access, no dict indirection.
+    """
+    ns: dict = {"_sentinel": _FIXPOINT_SENTINEL}
+    exec(compile(
+        f"def _cache_get(instance, _sentinel=_sentinel):\n"
+        f"    try:\n"
+        f"        return instance.{slot_name}\n"
+        f"    except AttributeError:\n"
+        f"        return _sentinel\n"
+        f"def _cache_set(instance, value):\n"
+        f"    instance.{slot_name} = value\n"
+        f"def _cache_pop(instance):\n"
+        f"    try:\n"
+        f"        value = instance.{slot_name}\n"
+        f"    except AttributeError:\n"
+        f"        return None\n"
+        f"    del instance.{slot_name}\n"
+        f"    return value\n",
+        f"<fixpoint-slot-{slot_name}>", "exec",
+    ), ns)
+    return ns["_cache_get"], ns["_cache_set"], ns["_cache_pop"]
+
+
+def _make_dict_accessors(attr_name: str) -> "tuple[Callable, Callable, Callable]":
+    """Generate compiled per-property dict accessors via AST compilation.
+
+    Returns ``(cache_get, cache_set, cache_pop)`` with the attribute name baked into bytecode.
+    """
+    ns: dict = {"_sentinel": _FIXPOINT_SENTINEL}
+    exec(compile(
+        f"def _cache_get(instance, _sentinel=_sentinel):\n"
+        f"    return instance.__dict__.get({attr_name!r}, _sentinel)\n"
+        f"def _cache_set(instance, value):\n"
+        f"    instance.__dict__[{attr_name!r}] = value\n"
+        f"def _cache_pop(instance):\n"
+        f"    return instance.__dict__.pop({attr_name!r}, None)\n",
+        f"<fixpoint-dict-{attr_name}>", "exec",
+    ), ns)
+    return ns["_cache_get"], ns["_cache_set"], ns["_cache_pop"]
+
+
+def fixpoint_slotted(cls: type) -> type:
+    """Class decorator: add ``_fpc_*`` cache slots for each ``fixpoint_cached_property`` on ``cls``.
+
+    Scans ``cls`` for ``fixpoint_cached_property`` descriptors, adds a dedicated cache slot
+    for each one (named ``_fpc_{property_name}``), and rebuilds the class with augmented
+    ``__slots__``. This removes the need to manually declare cache slots.
+
+    Usage::
+
+        @fixpoint_slotted
+        class Thunk:
+            __slots__ = ("callee", "argument")
+
+            @fixpoint_cached_property(bottom=lambda: _BOTTOM)
+            def weak_head_normal_form(self) -> object: ...
+    """
+    extra_slots = []
+    for name, value in vars(cls).items():
+        if isinstance(value, (fixpoint_cached_property, _fixpoint_dependent_property)):
+            extra_slots.append(_CACHE_SLOT_PREFIX + name)
+    if not extra_slots:
+        return cls
+    existing_slots = getattr(cls, "__slots__", ())
+    new_slots = tuple(existing_slots) + tuple(extra_slots)
+    member_descriptor_type = type(type.__dict__["__module__"]) if "__module__" not in existing_slots else None
+    ns = {}
+    for key, value in vars(cls).items():
+        if key in ("__slots__", "__dict__", "__weakref__"):
+            continue
+        if isinstance(value, type) and issubclass(value, type):
+            continue
+        if member_descriptor_type is not None and type(value).__name__ == "member_descriptor":
+            continue
+        ns[key] = value
+    ns["__slots__"] = new_slots
+    ns["__qualname__"] = cls.__qualname__
+    new_cls = type(cls)(cls.__name__, cls.__bases__, ns)
+    for name, value in vars(new_cls).items():
+        if isinstance(value, (fixpoint_cached_property, _fixpoint_dependent_property)):
+            value._bind_accessors(new_cls)
+    return new_cls
+
+
+def _clear_fixpoint_attr(instance: object, attr_name: str) -> object | None:
+    """Pop a cached fixpoint value from an instance, handling both dict and slot modes."""
+    if type(instance).__dictoffset__ != 0:
+        return instance.__dict__.pop(attr_name, None)
+    slot_name = _CACHE_SLOT_PREFIX + attr_name
+    try:
+        value = getattr(instance, slot_name)
+    except AttributeError:
+        return None
+    delattr(instance, slot_name)
+    return value
+
+
 # Registry of attribute names that need clearing during fixpoint digest cycles.
 # Populated by fixpoint_cached_property and fixpoint_dependent decorators.
 _fixpoint_clearable_attrs: set[str] = set()
@@ -144,10 +247,15 @@ class fixpoint_cached_property:
         *,
         bottom: Callable[[], object],
         accumulate: Callable[[object, object], bool] | None = None,
+        merge: Callable[[object, object], object] | None = None,
     ) -> None:
         # Support both @fixpoint_cached_property(bottom=...) and direct call
+        if accumulate is not None and merge is not None:
+            raise ValueError("fixpoint_cached_property: pass at most one of accumulate / merge")
         self._bottom = bottom
         self._accumulate = accumulate
+        self._merge = merge
+        self._cache_get = self._cache_set = self._cache_pop = None
         if func is not None:
             self.func: Callable = func
             self.attrname: str = func.__name__
@@ -166,6 +274,21 @@ class fixpoint_cached_property:
         if not hasattr(self, "attrname"):
             self.attrname = name
         _fixpoint_clearable_attrs.add(self.attrname)
+        self._bind_accessors(owner)
+
+    def _bind_accessors(self, owner: type) -> None:
+        """Generate compiled cache accessors, dispatching by slot vs dict."""
+        slot_name = _CACHE_SLOT_PREFIX + self.attrname
+        if slot_name in getattr(owner, "__slots__", ()):
+            self._cache_get, self._cache_set, self._cache_pop = _make_slot_accessors(slot_name)
+        else:
+            self._cache_get, self._cache_set, self._cache_pop = _make_dict_accessors(self.attrname)
+
+    def _ensure_accessors(self, instance: object) -> None:
+        """Lazily bind accessors when __set_name__ was not called (e.g. manually defined classes)."""
+        if self._cache_get is not None:
+            return
+        self._bind_accessors(type(instance))
 
     @classmethod
     def _get_max_iterations(cls) -> int | float:
@@ -178,16 +301,16 @@ class fixpoint_cached_property:
         if instance is None:
             return self
 
+        self._ensure_accessors(instance)
+        cache_get = self._cache_get
+        cache_set = self._cache_set
+
         # Fast path: already cached
-        cache = instance.__dict__
-        value = cache.get(self.attrname, _FIXPOINT_SENTINEL)
+        value = cache_get(instance)
         if value is not _FIXPOINT_SENTINEL:
             max_iterations = self._get_max_iterations()
             if max_iterations == 0:
                 return value
-            # Detect reentry: if this key is currently being computed
-            # (on the call stack), accessing its cached approximation
-            # means the fixpoint has not converged yet.
             context = _fixpoint_context_var.get()
             if context is not None:
                 key = (id(instance), self.attrname)
@@ -202,18 +325,15 @@ class fixpoint_cached_property:
         key = (instance_id, self.attrname)
 
         if context is None:
-            # I am the driver — start a digest loop (or single-pass for max_iterations=0)
             context = _FixpointContext(
                 clearable_attr_names=frozenset(_fixpoint_clearable_attrs)
             )
             token = _fixpoint_context_var.set(context)
             try:
                 if max_iterations == 0:
-                    # Zero-iteration mode: compute once with reentry detection.
-                    # Reentry raises FixpointRecursionError instead of infinite recursion.
                     context.computing.add(key)
                     result = self.func(instance)
-                    cache[self.attrname] = result
+                    cache_set(instance, result)
                     return result
 
                 approximation = self._bottom()
@@ -225,35 +345,31 @@ class fixpoint_cached_property:
                     result = self.func(instance)
 
                     if not context.reentrant:
-                        # No reentry this round — fixpoint reached
-                        cache[self.attrname] = result
+                        cache_set(instance, result)
                         return result
 
                     if self._accumulate is not None:
-                        # Monotonic accumulation: merge each iteration's
-                        # result into an accumulator that only grows.
-                        # This prevents oscillation when intermediate
-                        # computations encounter cycles in varying order.
                         changed = self._accumulate(accumulator, result)
                         if not changed and iteration > 0:
-                            cache[self.attrname] = accumulator
+                            cache_set(instance, accumulator)
                             return accumulator
-                        # Use the accumulator as next round's approximation
                         approximation = accumulator
+                    elif self._merge is not None:
+                        merged = self._merge(approximation, result)
+                        if merged == approximation and iteration > 0:
+                            cache_set(instance, merged)
+                            return merged
+                        approximation = merged
                     else:
-                        # Exact equality convergence (original behavior)
                         if result == previous_result:
-                            cache[self.attrname] = result
+                            cache_set(instance, result)
                             return result
                         previous_result = result
                         approximation = result
 
-                    # Cache current approximation, clear all intermediate
-                    # caches, and re-run
-                    cache[self.attrname] = approximation
+                    cache_set(instance, approximation)
                     context.clear_participant_caches()
-                    # Restore driver's own approximation
-                    cache[self.attrname] = approximation
+                    cache_set(instance, approximation)
                     context.computing.clear()
                     context.reentrant = False
 
@@ -266,7 +382,6 @@ class fixpoint_cached_property:
             finally:
                 _fixpoint_context_var.reset(token)
         elif key in context.computing:
-            # Reentry detected — return previous approximation or bottom.
             context.reentrant = True
             context.add_participant(instance)
             if max_iterations == 0:
@@ -275,9 +390,7 @@ class fixpoint_cached_property:
                     f"reentry detected with max_fixpoint_iterations=0",
                     incomplete_result=self._bottom(),
                 )
-            # Check the instance cache first, then fall back to saved
-            # approximations from the previous iteration.
-            approximation = cache.get(self.attrname, _FIXPOINT_SENTINEL)
+            approximation = cache_get(instance)
             if approximation is not _FIXPOINT_SENTINEL:
                 return approximation
             saved = context.approximations.get(key, _FIXPOINT_SENTINEL)
@@ -285,22 +398,17 @@ class fixpoint_cached_property:
                 return saved
             return self._bottom()
         else:
-            # Inside a fixpoint context but this is a fresh (instance, attr)
-            # pair — compute normally.  Keep the key in ``computing`` only
-            # while ``self.func`` runs so that cycles through this key are
-            # detected by the ``elif`` branch above.  Once computation
-            # finishes, remove the key so the fast-path cache check does
-            # not misidentify a later read of this cached value as reentry.
             context.computing.add(key)
             context.add_participant(instance)
             result = self.func(instance)
             context.computing.discard(key)
-            cache[self.attrname] = result
+            cache_set(instance, result)
             return result
 
     def __set__(self, instance: object, value: object) -> None:
         """Data descriptor setter to ensure __get__ is always called."""
-        instance.__dict__[self.attrname] = value
+        self._ensure_accessors(instance)
+        self._cache_set(instance, value)
 
 
 class _fixpoint_dependent_property:
@@ -317,31 +425,43 @@ class _fixpoint_dependent_property:
         self.func = func
         self.attrname = func.__name__
         self.__doc__ = func.__doc__
+        self._cache_get = self._cache_set = self._cache_pop = None
         _fixpoint_clearable_attrs.add(self.attrname)
 
     def __set_name__(self, owner: type, name: str) -> None:
         if not hasattr(self, "attrname"):
             self.attrname = name
         _fixpoint_clearable_attrs.add(self.attrname)
+        self._bind_accessors(owner)
+
+    def _bind_accessors(self, owner: type) -> None:
+        slot_name = _CACHE_SLOT_PREFIX + self.attrname
+        if slot_name in getattr(owner, "__slots__", ()):
+            self._cache_get, self._cache_set, self._cache_pop = _make_slot_accessors(slot_name)
+        else:
+            self._cache_get, self._cache_set, self._cache_pop = _make_dict_accessors(self.attrname)
+
+    def _ensure_accessors(self, instance: object) -> None:
+        if self._cache_get is not None:
+            return
+        self._bind_accessors(type(instance))
 
     def __get__(self, instance: object, owner: type = None) -> object:
         if instance is None:
             return self
 
-        cache = instance.__dict__
-        value = cache.get(self.attrname)
-        if value is not None:
+        self._ensure_accessors(instance)
+        value = self._cache_get(instance)
+        if value is not _FIXPOINT_SENTINEL:
             return value
 
         if fixpoint_cached_property._get_max_iterations() > 0:
-            # Register as participant so clear_participant_caches can
-            # invalidate this cached value between fixpoint iterations.
             context = _fixpoint_context_var.get()
             if context is not None:
                 context.add_participant(instance)
 
         value = self.func(instance)
-        cache[self.attrname] = value
+        self._cache_set(instance, value)
         return value