llist: FrozenAttributeError shim, raised by cons

Technologicat · claude · Technologicat · commit 2798d86e3319 · 2026-05-06T09:17:40.000+03:00
New `FrozenAttributeError` multiply-inherits from `TypeError` (legacy unpythonic <= 2.x base) and `dataclasses.FrozenInstanceError` (stdlib convention since Python 3.7, itself an `AttributeError`). All three `except` clauses catch it, so existing user code keeps working *and* new code can use the standard idiom. This closes the part of #35 that was previously held back as #102 (the TypeError → FrozenInstanceError swap). The shim provides stdlib alignment now without breaking 2.x compatibility. The TypeError base will be dropped in 3.0.0 (issue #102 retained for that step). CHANGELOG: New entry for the shim, Fixed entry updated to reflect the new exception type. Brief updated to record the resolution. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,11 +9,12 @@
 - `unpythonic.dialects.bf`: a dialect that accepts a brainfuck program in place of Python source. Compiles `bf` to Python and runs it, or — via `bf_compile(src)` — returns the generated Python as a string for inspection. The tape is a `defaultdict[int, int]` subclass with 8-bit wrapping cells; comments in the `bf` source are preserved as Python comments; a `reset` line clears the tape between programs.
   - Demonstrates the `mcpyrate` `Dialect.transform_source` hook (full-module source-to-source transformer), which the other dialects in this package do not use.
   - Uses the new `mcpyrate.dialects.split_at_dialectimport` helper (requires `mcpyrate >= 4.1.0`), which correctly handles the case where the bf dialect-import shares a `from X import dialects, A, B` line with other dialects.
+- `unpythonic.llist.FrozenAttributeError`: compatibility shim that multiply-inherits from `TypeError` (legacy unpythonic <= 2.x) and `dataclasses.FrozenInstanceError` (Python 3.7+ stdlib convention). Raised by `cons` on attribute write/delete attempts. Either `except TypeError` or `except FrozenInstanceError` catches it. The `TypeError` base will be dropped in 3.0.0; new code should catch `FrozenInstanceError` (or `AttributeError`).
 
 **Fixed**:
 
 - `unpythonic.misc.callsite_filename`: walks the call stack via `sys._getframe` instead of `inspect.stack()`. Latent PyPy-3.11 / macOS / Windows bug: `inspect.stack()` reads source context around `f_lineno` for every frame, and on those targets at least one frame reachable from a `test[]` invocation reports `f_lineno = None`, which raises `TypeError` from `inspect.getframeinfo`. The new path reads only `f_code.co_filename`. CPython unaffected; PyPy on Linux unaffected.
-- `unpythonic.llist.cons`: `__delattr__` now raises `TypeError`. Latent bug: `del c.car` previously worked and corrupted the cell; only `__setattr__` was intercepted. The error message for `__setattr__` also now correctly says "attribute" (not "item") assignment.
+- `unpythonic.llist.cons`: `__delattr__` now raises `FrozenAttributeError` (catchable as `TypeError`, `FrozenInstanceError`, or `AttributeError`). Latent bug: `del c.car` previously worked and corrupted the cell; only `__setattr__` was intercepted. The error message for `__setattr__` also now correctly says "attribute" (not "item") assignment.
 - `unpythonic.assignonce`: `del e.foo` on a defined name now raises `AttributeError`. Latent bug: the assign-once contract could be bypassed via `del e.foo; e.foo = new_value`, since `__delattr__` was inherited unrestricted from `env`. Use `e.set("foo", value)` for explicit rebinding instead.
 
 **Changed**:
diff --git a/briefs/2.2.0-remaining-issues.md b/briefs/2.2.0-remaining-issues.md
@@ -128,10 +128,12 @@ to 3.0.0 and remains the tracking ticket; no new issue needed.
   `e._env = ...` is now rejected. Test added.
 - `frozendict` docstring clarifies that "frozen" refers to the mapping,
   not instance attributes.
-- **Held back**: `TypeError` → `dataclasses.FrozenInstanceError` swap
-  for `cons` mutation errors. `FrozenInstanceError` subclasses
-  `AttributeError`, which would break user code catching `TypeError`.
-  Spun off as **#102** against the 3.0.0 milestone.
+- Stdlib alignment achieved via shim: `cons` now raises
+  `FrozenAttributeError`, which multiply-inherits from `TypeError`
+  (legacy) and `dataclasses.FrozenInstanceError` (stdlib convention).
+  Either catch path works. `TypeError` base scheduled for removal
+  in 3.0.0 (issue **#102** still tracks that step; closed for now
+  with the shim resolution).
 
 ## #80 — Document multi-shot generators
 
diff --git a/unpythonic/llist.py b/unpythonic/llist.py
@@ -6,6 +6,7 @@
 
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable, Generator, Iterable, Iterator
+from dataclasses import FrozenInstanceError
 from itertools import zip_longest
 from typing import Any
 
@@ -18,7 +19,8 @@
 _fill = gensym("fill")
 
 # explicit list better for tooling support
-_exports = ["cons", "nil",
+_exports = ["FrozenAttributeError",
+            "cons", "nil",
             "LinkedListIterator", "LinkedListOrCellIterator", "TailIterator",
             "BinaryTreeIterator", "ConsIterator",
             "car", "cdr",
@@ -37,6 +39,20 @@
 #_exports.extend(_c4r)
 __all__ = _exports
 
+class FrozenAttributeError(TypeError, FrozenInstanceError):
+    """Raised on a write/delete attempt against a frozen-instance type.
+
+    Multiply-inherits from `TypeError` (the legacy unpythonic <= 2.x base)
+    and `dataclasses.FrozenInstanceError` (the standard-library convention
+    since Python 3.7, itself a subclass of `AttributeError`). Either
+    `except` clause catches it.
+
+    Compatibility shim: lets unpythonic align with the stdlib idiom
+    without breaking user code that catches `TypeError`. The `TypeError`
+    base will be dropped in 3.0.0 (see issue #35), at which point this
+    class becomes a plain `FrozenInstanceError` and likely goes away.
+    """
+
 class Nil(Singleton):
     """The empty linked list. Singleton."""
     # support the iterator protocol so we can say tuple(nil) --> ()
@@ -220,9 +236,9 @@ def __init__(self, v1: Any, v2: Any) -> None:
         object.__setattr__(self, "car", v1)
         object.__setattr__(self, "cdr", v2)
     def __setattr__(self, k: str, v: Any) -> None:
-        raise TypeError(f"'cons' object does not support attribute assignment; tried to set {k!r}")
+        raise FrozenAttributeError(f"'cons' object does not support attribute assignment; tried to set {k!r}")
     def __delattr__(self, k: str) -> None:
-        raise TypeError(f"'cons' object does not support attribute deletion; tried to delete {k!r}")
+        raise FrozenAttributeError(f"'cons' object does not support attribute deletion; tried to delete {k!r}")
     def __iter__(self) -> LinkedListOrCellIterator:
         """Return iterator with default iteration scheme: single cell or list."""
         return LinkedListOrCellIterator(self)
diff --git a/unpythonic/tests/test_llist.py b/unpythonic/tests/test_llist.py
@@ -5,7 +5,10 @@
 
 from pickle import dumps, loads
 
-from ..llist import (cons, car, cdr, nil, ll, llist,
+from dataclasses import FrozenInstanceError
+
+from ..llist import (FrozenAttributeError,
+                     cons, car, cdr, nil, ll, llist,
                      caar, cdar, cadr, cddr, caddr, cdddr,
                      member, lreverse, lappend, lzip,
                      BinaryTreeIterator, JackOfAllTradesIterator,
@@ -28,6 +31,15 @@ def runtests():
             del c.car
         with test_raises[TypeError, "cons cells should be immutable (no new attributes)"]:
             c.extra = "nope"
+        # The exception is `FrozenAttributeError`, a shim that inherits from both
+        # `TypeError` (legacy unpythonic <= 2.x) and `dataclasses.FrozenInstanceError`
+        # (stdlib convention). All three `except` clauses catch.
+        with test_raises[FrozenAttributeError, "should be a FrozenAttributeError"]:
+            cons(1, 2).car = 3
+        with test_raises[FrozenInstanceError, "should also be catchable as the stdlib FrozenInstanceError"]:
+            cons(1, 2).car = 3
+        with test_raises[AttributeError, "should also be catchable as AttributeError (via FrozenInstanceError)"]:
+            cons(1, 2).car = 3
 
         test[the[c == c]]
         test[the[cons(1, 2) == cons(1, 2)]]
