Brummel
ba516b8b39
Decision 9 ships. Through Iter 14e every ADT box, lambda env, and
closure pair was leaked. This iter substitutes GC_malloc for malloc
in all four IR allocation sites and links -lgc. No language change,
no AST change, no schema change.
Diff: 5 files modified, ~30 LOC net.
- codegen/lib.rs: 4 substitutions @malloc -> @GC_malloc.
- ail/main.rs: .arg("-lgc") in the clang invocation.
- 5 IR snapshot files: mechanical s/@malloc/@GC_malloc/, 9
occurrences. IR is bit-identical to pre-14f modulo this
substitution — exactly Decision 9's promise.
- e2e.rs: new test gc_handles_recursive_list_construction.
- examples/gc_stress.{ailx,ail.json}: new fixture, builds a 50-
element list via recursive Cons, sums it (1275).
Hash invariance verified: every existing fixture def hash
unchanged (codegen and link line are downstream of canonical
bytes; AST didn't move).
Tests 79 -> 80, all green. Existing 79 byte-identical stdout.
gc_stress -> 1275. list_map_poly -> 2/3/4 unchanged. sort
sorted-list unchanged. cargo doc 0 warnings.
GC notes (pertinent to future work):
- GC_INIT() not needed on Arch libgc 1.5.6 (auto-init via
__attribute__((constructor))).
- No conservative-scan over-retention observed.
- -lgc alone sufficient for link (pthread/dl transitive).
Pattern-shape note from gc_stress fixture writing: the post-14d
"if-then-else" replacement is `(match (app == n 0) (case
(pat-lit true) ...) (case (pat-wild) ...))`. Three lines for
what `if` used to do in one, but uniform with the language.
Worth flagging for the stdlib brief.
Language is feature-complete enough for stdlib. The three
blockers identified at the 14b boundary (redundancy 14d, tail
calls 14e, GC 14f) are all done. Plan 15a: first stdlib module
std_list.ailx with length/append/reverse/map/filter/fold_left/
fold_right/head/tail/is_empty.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
51 lines
1.4 KiB
Plaintext
51 lines
1.4 KiB
Plaintext
; Iter 14f stress fixture for the Boehm conservative GC integration.
|
|
; Builds a List Int of length 50 by recursive Cons construction,
|
|
; sums it, prints the sum (1275 = 50*51/2).
|
|
;
|
|
; Match-on-Int isn't supported as a pattern shape; we drop into a
|
|
; match-on-Bool against (== n 0), mirroring the sort fixture's
|
|
; (<= y h) idiom. (pat-wild) catches the false case.
|
|
|
|
(module gc_stress
|
|
|
|
(data List (vars a)
|
|
(doc "Polymorphic singly-linked list (re-declared locally).")
|
|
(ctor Nil)
|
|
(ctor Cons a (con List a)))
|
|
|
|
(fn build
|
|
(doc "Build [n, n-1, ..., 1] :: List Int via Cons recursion.")
|
|
(type
|
|
(fn-type
|
|
(params (con Int))
|
|
(ret (con List (con Int)))))
|
|
(params n)
|
|
(body
|
|
(match (app == n 0)
|
|
(case (pat-lit true)
|
|
(term-ctor List Nil))
|
|
(case _
|
|
(term-ctor List Cons
|
|
n
|
|
(app build (app - n 1)))))))
|
|
|
|
(fn sum_list
|
|
(doc "Recursively sum a List Int.")
|
|
(type
|
|
(fn-type
|
|
(params (con List (con Int)))
|
|
(ret (con Int))))
|
|
(params xs)
|
|
(body
|
|
(match xs
|
|
(case (pat-ctor Nil) 0)
|
|
(case (pat-ctor Cons h t)
|
|
(app + h (app sum_list t))))))
|
|
|
|
(fn main
|
|
(doc "Build [50..1], sum, print 1275.")
|
|
(type (fn-type (params) (ret (con Unit)) (effects IO)))
|
|
(params)
|
|
(body
|
|
(do io/print_int (app sum_list (app build 50))))))
|