Brummel/AILang
1
0
Fork 0
Code Issues 29 Pull Requests Actions Packages Projects Releases Wiki Activity

spec: 24-show-print post-mq re-derive (24.2 + 24.3)

Browse Source 
Re-derives the deferred iters 24.2 (class Show + 4 prim instances)
and 24.3 (print free fn + E2E) against the post-mq architecture.
Iter 24.1 shipped at f38bad8 and is unchanged. The supersedes-note
in the spec frontmatter explains the relation to the predecessor at
docs/specs/2026-05-12-24-show-print.md.

Substantive deltas vs. predecessor:
- Dispatch routing through the mq.2/.3 5-step rule; constraint-driven
  filter (mq.tidy T1) is load-bearing for show calls inside print's
  body.
- 24.2 grows to include the 22b-Show -> TShow/tshow migration
  (~14 fixtures + 2 Rust test files) to eliminate post-prelude.Show
  ambiguity, analogous to the existing TEq/TOrd convention.

Grounding-check PASS (re-dispatched after two LBA path corrections;
12 load-bearing assumptions all ratified).
This commit is contained in:
Brummel
2026-05-13 03:09:02 +02:00
parent 89e335a39d
commit d6d70bd06c
1 changed files with 616 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/specs/2026-05-13-24-show-print.md
+616
View File
@@ -0,0 +1,616 @@
# 24 — Show + print rewire (post-mq re-derive) — Design Spec
**Date:** 2026-05-13
**Status:** Draft — awaiting user spec review
**Authors:** Brummel (orchestrator) + Claude
**Supersedes:** `docs/specs/2026-05-12-24-show-print.md` for iters 24.2 +
24.3 only. The earlier spec stays as historical context for the
deferral rationale; iter 24.1 shipped against the earlier spec at
`f38bad8` and is unchanged. This document re-derives 24.2 + 24.3 from
scratch against the post-`mq` architecture (commits `0eb3323` mq.1 →
`2e6a4ca` mq.2 → `99d3968` mq.3 → `1b6cbcb` mq.tidy).
## Goal
Close the prelude story opened by milestone 23 (Eq/Ord) by shipping:
1. The `Show` typeclass with single method `show : (a borrow) -> Str`
in the prelude module.
2. Four primitive instances: `prelude.Show Int`, `prelude.Show Bool`,
`prelude.Show Str`, `prelude.Show Float`.
3. A polymorphic free fn `print : forall a. Show a => (a borrow) -> () !IO`
in the prelude module that routes through `show` and `io/print_str`,
replacing the ad-hoc per-type print idiom for new code.
The runtime + codegen primitives `bool_to_str` and `str_clone` already
shipped in iter 24.1 at `f38bad8`. No runtime work in this re-derive.
Existing per-type effect-ops `io/print_int|bool|float` STAY. Retiring
them and migrating the example corpus (~86 fixtures) is queued as a
separate P2 follow-up, unchanged from the original spec.
The post-mq architecture changes two things compared to the original
spec:
- **Dispatch routing.** mq.2 / mq.3 installed type-driven method
dispatch with a 5-step rule (qualifier → singleton → type-driven
filter → constraint-driven filter → Multi). The original spec
predicated routing on a workspace-global `MethodNameCollision`
pre-pass that has been retired. The new dispatch routes `show` calls
inside `print`'s body via the constraint-driven filter (Step 4 of
the dispatch rule) — `Show a` in `print`'s declared constraints
pins the candidate class to `prelude.Show`.
- **Existing fixture corpus collides at the class name "Show".** Pre-mq,
user-side `class Show` declarations in 14 test fixtures
(`examples/test_22b{1,2,3}_*.ail.json`) were the only `Show` in their
workspaces. Post-mq, shipping `prelude.Show` makes those user-Show
classes coexist with the prelude one — and because the user-Show
methods carry the same method name (`show`), the same arg-type shape
(`(a) -> Str`), AND the same instance head-type for `Int`, the
type-driven filter (Step 3) cannot discriminate at bare call sites.
Every `show x` in those fixtures would become Multi-ambiguous and
require an explicit qualifier. Migration is part of iter 24.2; the
strategy is "rename to `TShow`/`tshow`", analogous to the existing
`TEq`/`teq`, `TOrd`/`tlt` test-internal class-name convention that
pre-empts identical collisions with `prelude.Eq` / `prelude.Ord`.
## Architecture
Three artefacts, in dependency order; iter 24.1 already shipped the
two runtime primitives.
### 1. `class Show` + four primitive instances in `prelude.ail.json`
The prelude module name is literally `"prelude"`. Per the mq.1
canonical-form rule, intra-prelude class refs are bare; cross-module
refs (from user instance / constraint defs) carry the
`"prelude.Show"` qualifier.
`examples/prelude.ail.json` gains five new top-level defs (one class +
four instances):
```jsonc
// class — same-module, bare name
{ "kind": "class",
"name": "Show",
"param": "a",
"methods": [
{ "name": "show",
"type": {
"k": "fn",
"params": [{ "k": "var", "name": "a" }],
"param_modes": ["borrow"],
"ret": { "k": "con", "name": "Str" },
"effects": []
}
}
]
}
// instance — same-module, bare class ref per mq.1 canonical-form
{ "kind": "instance",
"class": "Show", // bare per mq.1
"type": { "k": "con", "name": "Int" },
"methods": [
{ "name": "show",
"body": { "t": "lam",
"params": ["x"],
"body": { "t": "app",
"fn": { "t": "var", "name": "int_to_str" },
"args": [{ "t": "var", "name": "x" }] } } }
]
}
// instance Show Bool — body invokes bool_to_str
// instance Show Str — body invokes str_clone
// instance Show Float — body invokes float_to_str
```
Each instance body is a single-application lambda
`\x -> <primitive_to_str> x`. No codegen intercept (no
`try_emit_primitive_instance_body`-style hook) is needed because the
four primitives are themselves first-class lowered functions. The mono
pass synthesises `show__Int`, `show__Bool`, `show__Str`, `show__Float`;
each body is a direct call to the corresponding primitive.
Float **is** included in Show — unlike Eq/Ord (which exclude Float
because IEEE-754 makes structural equality and total ordering
semantically dubious). Producing a textual representation of a Float
is well-defined modulo the NaN-spelling caveat in DESIGN.md §"Float
semantics" (`printf("%g", nan)` may emit `nan` / `-nan` / `NaN`);
acceptable for a human-readable Show.
### 2. `print` polymorphic free fn
`examples/prelude.ail.json` gains a sixth new top-level def:
```jsonc
{ "kind": "fn",
"name": "print",
"type": {
"k": "forall",
"vars": ["a"],
"constraints": [
{ "class": "Show", // bare per mq.1
"type": { "k": "var", "name": "a" } }
],
"body": {
"k": "fn",
"params": [{ "k": "var", "name": "a" }],
"param_modes": ["borrow"],
"ret": { "k": "con", "name": "Unit" },
"effects": ["IO"]
}
},
"params": ["x"],
"body": {
"t": "let",
"name": "s",
"value": { "t": "app",
"fn": { "t": "var", "name": "show" },
"args": [{ "t": "var", "name": "x" }] },
"body": { "t": "do",
"op": "io/print_str",
"args": [{ "t": "var", "name": "s" }] }
}
}
```
The let-binder for `show x` is **explicit**. Load-bearing for the
heap-Str RC discipline: the Own heap-Str returned by `show x` (every
instance allocates) needs a let-binder so `drop_symbol_for_binder`
fires the heap-Str drop at scope close via the Str carve-out
introduced in `eob.1`. The original spec marked implicit-vs-explicit
as an open commitment for the 24.3 implementer; this re-derive keeps
the same open commitment — if the desugarer auto-introduces a
let-binder for `Term::App` in effect-op-arg position, the source form
may be `\x -> do io/print_str (show x)` with identical post-checker
semantics.
`print` is a free fn, not a class method. Two reasons (unchanged from
the original spec):
- The body is identical for every `a : Show a` — no per-instance
variation. A class method with an identical body for every instance
would be redundant.
- It matches Haskell's Prelude convention (`print :: Show a => a -> IO ()`
is a free fn) and milestone 23's free-fn pattern (`ne`/`lt`/`le`/`gt`/`ge`).
### 3. Dispatch routing through the mq mechanism
Inside `print`'s body the call is `show x`. Bare method name; the
post-mq dispatcher (`resolve_method_dispatch` at synth time,
`refine_multi_candidate_residual` at discharge time) applies the
5-step rule:
1. **Qualifier** — none (bare).
2. **Singleton** — `Env.method_to_candidate_classes["show"]` is a
workspace-global index. Post-24.2-migration, no user class ships a
`show` method (the 22b corpus is renamed to `tshow`); the only
class with `show` is `prelude.Show`. So the candidate set for `show`
reduces to `{prelude.Show}` workspace-globally and Step-2 singleton
resolves directly — Steps 3-4 are not exercised for the bare `show`
inside `print`'s body. The constraint-driven filter (below) becomes
the load-bearing narrower only if a downstream user later
re-introduces their own `class Show` with a separate `show` method.
3. **Type-driven filter** — narrows by which candidate classes have a
registry entry for the residual type (`Show Int` instance check
for `print 42`).
4. **Constraint-driven filter** — `print`'s declared constraint
`Show a` is the load-bearing narrower. At the call site
`show x` inside `print`'s body, `x : a` rigid, and the rigid-var
filter installed by mq.tidy's T1 checks
`dc.class == c && constraint_type_matches(dc.type_, residual.type_)`.
The residual is `Show a` (the rigid type-var), `print`'s declared
constraint is `Show a`; both match → `prelude.Show` is the unique
resolved class.
5. **Multi** — not reached.
At the *outer* user call site `do print 42`, the dispatch on `print`
itself is by name (free fn, single global symbol) and the constraint
`Show Int` is discharged against the workspace registry which contains
`prelude.Show Int`. The dispatcher's behaviour mirrors milestone 23's
`ne`/`lt`/`le`/`gt`/`ge` at the same level.
### 4. Migration of 22b-Show user-class fixtures
Pre-mq, 14 test fixtures under `examples/test_22b{1,2,3}_*.ail.json`
declare a user-side `class Show {methods: ["show"]}` with arg-type
shape `(a) -> Str`. Pre-mq, these were the only `Show` in their
workspaces. Post-`prelude.Show` shipping, the prelude is auto-loaded
into every workspace per 23.1's `check_workspace` extension, so every
22b fixture now has TWO classes named `Show`: `prelude.Show` and (e.g.)
`test_22b1_dup_classmod.Show`. Both ship `(Int) -> Str` instances; the
type-driven filter cannot discriminate at bare `show x` call sites.
Strategy: **rename user-Show → TShow, user-show → tshow**, analogous
to the existing `TEq`/`teq` (vs. `prelude.Eq`/`eq`) and `TOrd`/`tlt`
(vs. `prelude.Ord`/`lt`) convention. The fixtures' intent is
unchanged (they test class-mechanism: orphan detection, dup detection,
xmod instances, missing-constraint diagnostics) — only the literal
class and method name change.
Mechanical scope:
- ~14 fixture `.ail.json` files: `"name": "Show"` → `"name": "TShow"`,
`"name": "show"` → `"name": "tshow"`, `"class": "Show"` →
`"class": "TShow"`, `"class": "<modname>.Show"` →
`"class": "<modname>.TShow"`, fn-body `"name": "show"` →
`"name": "tshow"`. Both `Show`-the-class and `show`-the-method get
renamed.
- 2 Rust test files: `crates/ail/tests/typeclass_22b2.rs` (30
Show/show occurrences) + `crates/ail/tests/typeclass_22b3.rs` (49).
Replace `"Show"` → `"TShow"` and `"show"` → `"tshow"` in expected
diagnostic strings.
The migration is a single mechanical pass within iter 24.2. Aborted-
attempt risk is low because the change is purely string substitution
(no semantic shift).
`mq3_two_show_*` and `mq3_class_eq_vs_fn_eq*` fixtures (created during
mq.3) intentionally do NOT migrate. They simulate the
two-Show-coexisting and class-vs-fn-collision shapes that are now
fully supported by the post-mq dispatcher; renaming them away would
defeat their purpose. These fixtures' Show classes are
`mq3_two_show_ambiguous_a.Show` and `mq3_two_show_ambiguous_b.Show`,
not user-Show analogues of prelude.Show.
After 24.2 lands, the workspace fixture corpus has zero ambiguous
bare-`show` call sites: every `show x` resolves either to `prelude.Show`
(via constraint-driven filter at user call sites with `Show Int`-style
constraints OR via instance singleton when only prelude.Show ships
Show-T for the residual T) or to `prelude.show` / `tshow` /
`mq3_*.Show.show` per their explicit qualifiers.
## Components (iterations)
| Iter | Status | Scope |
|------|--------|-------|
| **24.1** | shipped (`f38bad8`) | Runtime + codegen for `bool_to_str` + `str_clone`. Unchanged from original spec. |
| **24.2** | upcoming | **`class Show` + 4 primitive instances in prelude.** Plus the **22b-Show → TShow/tshow migration**. `examples/prelude.ail.json` gains `class Show a where show : (a borrow) -> Str` and four `instance Show <T>` defs (Int/Bool/Str/Float). ~14 `examples/test_22b*_*.ail.json` fixtures and 2 `crates/ail/tests/typeclass_22b{2,3}.rs` files migrate. DESIGN.md §"Prelude (built-in) classes" amended. Round-trip + mono-synthesis + hash-stability tests; full `cargo test --workspace` green. |
| **24.3** | upcoming | **`print` polymorphic free fn + E2E + DESIGN.md sync.** `examples/prelude.ail.json` gains `fn print : forall a. Show a => (a borrow) -> () !IO`. Three new E2E fixtures (positive 4-prim, user-ADT, negative NoInstance). DESIGN.md §"Prelude (built-in) classes" amended to include `print`; §"Float semantics" gains the Show-Float NaN-spelling cross-reference paragraph. Roadmap P1 "Post-22 Prelude" entry flips to `[x]`; new P2 entry: "retire `io/print_int|bool|float` effect-ops + migrate example corpus to `print`". |
The milestone closes with the standard `audit` pipeline.
## Data flow
Two trajectories show the routing at work.
### `print 42` at type `Int` (user workspace)
1. **Typecheck of user call site.** `print` resolves to the
polymorphic free fn at `prelude.print` via the existing free-fn
global-lookup path (prep1 from 23.4). Constraint `Show Int`
discharged against `prelude.Show Int` (singleton registry hit).
2. **Mono of `print__Int`.** Body taken from `Def::Fn.body`, rigid-var
subst `a → Int`. The body walker detects the nested `show x` call
at concrete `Int` and schedules `show__Int` in the same fixpoint
round. `show__Int` synthesises from `instance prelude.Show Int`'s
body (`\x -> int_to_str x`). The synthesised `print__Int` body is
`\x -> let s = show__Int x in do io/print_str s`.
3. **Codegen.** `print__Int` lowers as any monomorphic fn. The nested
`show__Int x` is a direct call returning Own heap-Str; the
let-binder `s` is RC-tracked at scope close per eob.1's Str
carve-out. `do io/print_str s` walks `s` as `Position::Borrow`; the
let-binder's drop fires after the effect-op call returns, emitting
`@ailang_rc_dec(s_ptr)`. Stdout: `"42\n"`.
### `print x` at user type `IntBox` with `instance prelude.Show IntBox`
1. **Typecheck.** User declares `data IntBox = MkIntBox Int` and
`instance prelude.Show IntBox` (cross-module class ref per
mq.1 — the instance lives in the user-type's defining module per
Decision 11 coherence). Constraint `prelude.Show IntBox` discharged
against the user-module registry entry.
2. **Mono.** `print__IntBox` synthesises with body
`\x -> let s = show__IntBox x in do io/print_str s`. `show__IntBox`
synthesises from the user instance body (e.g.
`\x -> match x with MkIntBox n -> int_to_str n`).
3. **Codegen.** Lowers normally; ADT-pattern-match plus inner
`int_to_str` call produce a heap-Str; outer let-binder drops at
scope close.
## Error handling
- **`NoInstance Show <T>`** — fired at typecheck when `print` is
called on a type without a `Show` instance (most commonly a function
type, or a user type the author forgot to give an instance for). The
diagnostic must cross-reference DESIGN.md §"Prelude (built-in)
classes" so the LLM-author immediately learns which types ship with
built-in Show. Re-uses the existing 22-era diagnostic
infrastructure; only content edit.
- **Class qualifier ambiguity at a user call site** — does NOT fire in
this milestone because the 22b-migration eliminates all current
ambiguous `show` call sites. Post-milestone, if a downstream user
declares their own `class Show` AND ships an instance whose head-type
collides with a prelude.Show instance head-type, the existing mq.3
`MultiClassUnresolved` diagnostic fires (already pinned by
`examples/mq3_two_show_ambiguous*.ail.json`). No new diagnostic
shape.
- **`OrphanInstance Show <UserType>`** — Decision 11 coherence rule
unchanged. User-side `instance prelude.Show <UserType>` MUST live in
the user-type's defining module (the prelude is read-only).
- **`CheckError::Internal` from mono** — if Show-specialisation fails
internally, this is a caller-contract violation per the existing
`mono.rs::synthesise_mono_fn` convention. Mirrors 23.4's free-fn
error handling.
## Testing strategy
### 24.2 — class Show + 4 instances + 22b migration
- **Round-trip:** `examples/prelude.ail.json` parses + canonicalises
bit-stable after the five new defs land. The existing prelude
hash-stability test from milestone 23 stays green (pre-existing
Ordering/Eq/Ord/instances/`ne`/`lt`/`le`/`gt`/`ge` unaffected).
- **Mono synthesis** (unit test in
`crates/ailang-check/src/mono.rs::tests`): for a fixture calling
`show 1`, `show True`, `show "x"`, `show 1.5`, assert the post-mono
workspace contains `show__Int`, `show__Bool`, `show__Str`,
`show__Float` as `Def::Fn` entries. Bodies are direct calls to the
corresponding primitives.
- **Dispatch via constraint-driven filter pin** (unit test in
`crates/ailang-check/src/lib.rs::tests`, building on the existing
`method_dispatch_pin.rs` style): for a workspace with `prelude.Show`
loaded and a user `class TShow {tshow}` declared in a user module,
assert that `show x` (bare) routes to `prelude.Show` and `tshow x`
(bare) routes to user `TShow`. Each method name has exactly one
candidate class globally, so Step-2 singleton resolves without
needing Steps 3-4. The pin covers the post-22b-migration steady
state where user fixtures pick non-`Show` class names.
- **Hash stability of existing mono symbols:** `eq__Int`,
`compare__Str`, and the other class-method mono symbols from
milestone 23 must produce identical bodies (and identical hashes)
under the unified pass after Show defs are added. Pin in the style
of `crates/ailang-core/src/hash.rs`'s milestone-23 fixtures.
- **22b-migration regression check** — `cargo test -p ail
--test typeclass_22b2 --test typeclass_22b3` passes after the
rename. Each migrated fixture parses + canonicalises bit-stable.
### 24.3 — print polymorphic free fn + E2E
- **Positive E2E (`examples/show_print_smoke.ail.json`):** single
fixture exercises all four primitives:
```
fn main = do
print 42 -- "42\n"
print true -- "true\n"
print "hello" -- "hello\n"
print 3.14 -- "3.14\n" (libc-dependent)
```
Asserts compile, run, expected stdout. The Float line uses
`3.14` whose `%g` rendering is stable across all targeted libc
versions.
- **User-ADT E2E (`examples/show_user_adt.ail.json`):**
```
data IntBox = MkIntBox Int
instance prelude.Show IntBox where
show = \x -> match x with MkIntBox n -> int_to_str n
fn main = do print (MkIntBox 7)
```
Stdout `"7\n"`. Confirms mono handles user-defined `prelude.Show`
instances and that `print` composes with them. The qualifier
`prelude.Show` is canonical-form per mq.1 (cross-module class ref
from a user-defining module).
- **Negative E2E (`examples/show_no_instance.ail.json`):**
```
fn main = do print id -- id : forall a. a -> a, no Show instance
```
Typecheck rejects with `NoInstance Show <fn-type>`. Diagnostic
wording finalised by the implementer; gold-standard test pins
the message verbatim post-draft (open commitment carries forward
from original spec).
- **Mono symbol IR-shape pin:** asserts `print__Int` body desugars to
`\x -> let s = show__Int x in do io/print_str s` post-mono. Confirms
the let-binder is preserved (not optimised away — load-bearing for
the heap-Str RC discipline).
- **Round-trip of new fixtures** — every E2E fixture parses +
canonicalises bit-stable.
- **Bench regression check** at milestone close: the three bench
scripts exit 0 or audit-ratified per audit-skill convention.
## Acceptance criteria
The milestone closes when:
1. **24.2 has landed:** `examples/prelude.ail.json` contains
`class Show a where show : (a borrow) -> Str` (bare class name,
bare method name, intra-prelude canonical form) and four primitive
instances Int/Bool/Str/Float. The mono pass synthesises
`show__Int|Bool|Str|Float`. The 22b-Show fixture corpus is migrated
to `TShow`/`tshow`; `cargo test --workspace` green. DESIGN.md
§"Prelude (built-in) classes" amended to include Show with the four
instances.
2. **24.3 has landed:** `examples/prelude.ail.json` contains
`fn print : forall a. Show a => (a borrow) -> () !IO` with the
explicit-let body (or implicit-let if the implementer ratifies the
surface-form simplification per Open Commitment carryforward). The
mono pass synthesises `print__Int|Bool|Str|Float` for each call
site at a primitive type, plus `print__<UserType>` for each
user-instance call site. Positive / user-ADT / negative E2E green.
DESIGN.md §"Prelude (built-in) classes" lists `print` as the
polymorphic helper; §"Float semantics" gains the Show Float
NaN-spelling cross-reference paragraph.
3. **Tests pass:** `cargo test --workspace` green; existing milestone
23 prelude fixtures (`ne`/`lt`/`le`/`gt`/`ge` E2E) unchanged; mq.3
E2E fixtures (`mq3_two_show_*`, `mq3_class_eq_vs_fn_eq*`)
unchanged.
4. **Bench regression ratified:** `bench/check.py && bench/compile_check.py && bench/cross_lang.py`
exit 0 or audit-ratified with journal entry.
5. **Roadmap update:** P1 "Post-22 Prelude — Show + print rewire"
entry flips to `[x]`. New P2 entry: "Retire `io/print_int|bool|float`
effect-ops + migrate example corpus to `print`".
## Out of scope (deferred, with substantive rationale)
Unchanged from the original spec; condensed summary:
- **Retiring `io/print_int|bool|float`.** Queued P2; same call as
milestone 23 made for `==` / `eq`.
- **`io/print_str` retirement.** Stays — load-bearing inside `print`,
plus useful as a bypass when an Str is already in hand.
- **`bool_to_str` as schema-`if`.** Stays as runtime primitive;
phi-of-static-Str through drop-elision is not ratified.
- **`str_clone` as rc_header bump.** Stays as always-copy; runtime
static-Str/heap-Str tagging is deliberately not supported post-hs.2.
- **`Show Ordering` instance.** No demand; user can declare.
- **`Show` for ADTs via `deriving`.** No auto-derivation; substantive
feature in its own right.
- **Higher-kinded Show (`Show [a]`).** Decision 11 axis 5 excludes
higher-kinded class params; LLM-natural pattern is per-type
instances.
- **`print` newline-free variant.** Deferred until a concrete
LLM-author pattern demands it.
- **Operator routing through `Show`.** No commitment; AILang has no
Haskell-style monadic operator surface.
## Open commitments (24.2 / 24.3 implementer)
- **`print` implicit-let vs. explicit-let** — implementer verifies the
desugarer's behaviour during 24.3 Task 1; if implicit-let is the
realised semantics for `Term::App` in effect-op-arg position, the
prelude source form may use the more compact
`\x -> do io/print_str (show x)`. Load-bearing property: "the
heap-Str returned by `show x` has a tracked let-binder when entering
the effect-op call site"; sourcing is surface-level.
- **Negative-test diagnostic wording.** Implementer drafts the
Show-aware `NoInstance Show <T>` message; orchestrator reviews in
spec-compliance phase.
- **22b-migration mechanical-pass scope.** Implementer verifies during
24.2 Task 1 that the rename target set is exactly the 14 fixtures
surfaced by `grep -l '"name": "Show"' examples/test_22b*_*.ail.json`
plus the two `typeclass_22b{2,3}.rs` files. If a 22b fixture turns
out to use `Show` as part of a substring (e.g. inside an ADT
constructor name like `"ShowValue"`), the implementer flags and
spot-checks rather than blindly sed-ing. (Quick visual scan above
shows only class names + method names + cross-module class refs;
no constructor-name false positives.)
- **mq3 fixture preservation.** The 7 `mq3_*` fixtures created in
mq.3 INTENTIONALLY do NOT migrate. Implementer confirms they stay
unchanged and continue to pin two-Show-coexisting and
class-vs-fn-collision behaviour.
## Known costs
- **24.2 prelude additions:** `examples/prelude.ail.json` +40–50 lines
(one class + four instances, JSON shape parallel to existing Eq
Int/Bool/Str instances). DESIGN.md amendment ~10 lines.
- **24.2 22b-migration:** ~14 `.ail.json` files (~3-5 string subs
each), 2 Rust test files (~80 string subs total). Net LOC change
zero (pure rename); review-burden non-trivial because of fixture
count.
- **24.3 prelude additions + tests:** `examples/prelude.ail.json` +30
lines (one polymorphic free fn). Three new E2E `.ail.json` fixtures,
~40 lines each. Diagnostic test ~20 lines Rust. DESIGN.md amendments
~20 lines.
- **Net code reduction:** none. Additive milestone. Reduction comes in
the P2 follow-up (~−150 LOC retiring the three per-type effect-ops).
- **Compile-time shift:** mono pass gains four instance-method
synthesis targets plus one free-fn target per call site. Bounded,
expected within bench tolerance; audit-ratified post-24.3.
- **Runtime cost on `print x`:**
- `x : Int` — one `int_to_str` alloc (~3-20 bytes) + rc_dec.
- `x : Bool` — one `bool_to_str` alloc (5-6 bytes) + rc_dec.
- `x : Str` — one `str_clone` alloc + memcpy + rc_dec. **Strictly
worse** than `do io/print_str x`; redundancy acknowledged.
- `x : Float` — one `float_to_str` alloc + rc_dec.
## Load-bearing assumptions about current behaviour
Each assumption is something this spec relies on as currently-true.
1. **mq.2/.3 dispatcher.** `crates/ailang-check/src/lib.rs::resolve_method_dispatch`
implements the 5-step rule (qualifier → singleton → type-driven
filter → constraint-driven filter → Multi). `refine_multi_candidate_residual`
applies the discharge-time refinement with the rigid-var
type-unification leg added by mq.tidy T1. Bare method names route
correctly through both call sites. Pinned by
`crates/ailang-check/tests/method_dispatch_pin.rs`.
2. **Inverse method index.** `Env.method_to_candidate_classes` is
populated workspace-globally and is the authoritative source for
"which classes declare method M". Pinned by
`crates/ailang-check/tests/method_collision_pin.rs`.
3. **`class_methods` tuple-keyed.** `class_methods` is keyed by
`(QualifiedClass, MethodName)` post-mq.3 retirement of the global
pre-pass; two classes can declare the same method name without
collision. Pinned by `mq3_class_method_shadowed_by_fn_warning_fires`
and `crates/ail/tests/mq3_multi_class_e2e.rs`.
4. **mq.1 canonical-form for class refs.** Class refs in
`InstanceDef.class`, `Constraint.class`, `SuperclassRef.superclass`,
and `Type::Con.name` follow: bare for same-module, `<module>.<Class>`
for cross-module. Pinned by the in-crate `bare_cross_module_class_ref_fires`
and `bad_cross_module_class_ref_fires` tests in
`crates/ailang-core/src/workspace.rs` (the `#[cfg(test)] mod tests`
block around lines 2783-2860) plus the on-disk mq.1 fixture corpus
(`examples/mq1_xmod_constraint_class{,_dep}.ail.json`).
5. **`int_to_str`, `float_to_str`, `bool_to_str`, `str_clone`** —
installed in `builtins.rs` with `ret_mode: Own`, lowered in
`Emitter::lower_app` via direct extern calls, RC-disciplined
end-to-end. The latter two shipped in 24.1 at `f38bad8`. Pinned by
`crates/ail/tests/e2e.rs::{int,bool,str_clone}_*_drop_balances_rc_stats`
plus the builtins-side signature-install tests in
`crates/ailang-check/src/builtins.rs`'s `#[cfg(test)] mod tests`.
6. **`io/print_str`** lowers to `@puts(ptr)` and accepts any Str
realisation via the heap-Str-compatible consumer ABI per
DESIGN.md §"Str ABI". Effect-op args walk in `Position::Borrow`
per eob.1.
7. **`drop_symbol_for_binder` Str carve-out.** Emits the correct
rc-dec for Str let-binders regardless of static-Str / heap-Str
underlying realisation; codegen-time elision ensures static-Str
pointers do not reach `ailang_rc_dec`.
8. **`Type::Forall` round-trip.** Form-A parser + canonicaliser +
printer round-trip `Type::Forall` with `constraints` bit-stable.
Pinned by milestone 23's `ne`/`lt`/`le`/`gt`/`ge` prelude entries.
9. **Mono pass body walker.** `mono.rs::collect_mono_targets`
schedules targets for both class-method residuals and polymorphic
free-fn calls in one fixpoint pass; pinned by 23.4's
`cmp_max_smoke` proof.
10. **Auto-loaded prelude.** `examples/prelude.ail.json` is auto-loaded
per 23.1's `check_workspace` extension; new prelude defs are
visible to every workspace without explicit `import`. The
pre-existing `"prelude" is reserved` loader-side error confirms
auto-injection.
11. **22b user-Show fixtures structurally identical.** All 14
target fixtures declare `class Show {methods: ["show"]}` with
`(a) -> Str` signature, and any instance declarations
use type-shape that collides with prelude.Show's at the
type-driven filter level. Empirical grep above ratifies the
structural-identity assumption.
12. **mq3 fixtures intentionally exercise multi-Show.** `mq3_two_show_*`
and `mq3_class_eq_vs_fn_eq*` fixtures use Show class names in
their own modules deliberately to exercise post-mq dispatch; they
do NOT migrate in 24.2.