Brummel
ca507c9f52
Drops the direct-call-only restriction on the LetRec name when it
appears in `in_term`. No new ABI: the lift wraps the in-term in
`(let f (lam P (app f$lr_N P CAPTURES)) in_term')` so codegen's
existing Iter-8b closure-pair machinery handles it. Body-position
name-as-value still rejected (deferred — eta-of-self is harder).
- desugar.rs / lift.rs: split find_non_callee_use into body
(panic) and in_term (wrap).
- examples/local_rec_as_value.{ailx,ail.json}: no-capture path
(factorial passed to apply5 → 120).
- examples/local_rec_as_value_capture.{ailx,ail.json}: capture
path; lifted fn has captures, eta-Lam picks them up via 8b.
- e2e + desugar tests: 113 → 116 (+3).
Codegen Lam machinery handled the wrapped form on the first try.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
44 lines
1.7 KiB
Plaintext
44 lines
1.7 KiB
Plaintext
; Iter 16b.5 — LetRec name as value, with capture. A recursive
|
|
; helper `factorial_plus` captures the outer fn-param `base` and is
|
|
; passed as a VALUE to a higher-order combinator. The lifted fn has
|
|
; signature `factorial_plus$lr_N(n: Int, base: Int) -> Int`. The
|
|
; eta-Lam wrap binds `factorial_plus` in the in-clause to a
|
|
; `(lam (n) (app factorial_plus$lr_N n base))` — the Lam's free var
|
|
; `base` becomes a closure-env capture under the standard 8b ABI.
|
|
; This exercises the dynamic-env path (lifted fn has extra params,
|
|
; the eta-Lam captures them).
|
|
;
|
|
; Expected stdout (one per line):
|
|
; apply5(factorial_plus[base=10]) = 5*4*3*2*(1+10) = 1320
|
|
; apply5(factorial_plus[base=100]) = 5*4*3*2*(1+100) = 12120
|
|
|
|
(module local_rec_as_value_capture
|
|
|
|
(fn apply5
|
|
(doc "Higher-order: applies its fn argument to 5.")
|
|
(type (fn-type (params (fn-type (params (con Int)) (ret (con Int)))) (ret (con Int))))
|
|
(params f)
|
|
(body (app f 5)))
|
|
|
|
(fn run_with_base
|
|
(doc "Build a recursive helper that captures `base` and pass it as a value to apply5.")
|
|
(type (fn-type (params (con Int)) (ret (con Int))))
|
|
(params base)
|
|
(body
|
|
(let-rec factorial_plus
|
|
(params n)
|
|
(type (fn-type (params (con Int)) (ret (con Int))))
|
|
(body
|
|
(if (app <= n 1)
|
|
(app + 1 base)
|
|
(app * n (app factorial_plus (app - n 1)))))
|
|
(in (app apply5 factorial_plus)))))
|
|
|
|
(fn main
|
|
(doc "Iter 16b.5: pass a capturing let-rec helper as a value. Expected stdout: 1320, 12120.")
|
|
(type (fn-type (params) (ret (con Unit)) (effects IO)))
|
|
(params)
|
|
(body
|
|
(seq (do io/print_int (app run_with_base 10))
|
|
(do io/print_int (app run_with_base 100))))))
|