06e2685350
A closure's underlying function carries a hidden env arg that a bare (T)->U slot
doesn't pass, so a closure flowing into a bare function-type slot dropped the
env — the first user arg landed in the env slot and the rest read garbage
(apply(closure((x)->s64 { x*2 })) returned 192 instead of 10; non-failable too).
- createClosureToBareFnAdapter: a capture-free closure into a bare (T)->U slot is
bridged by a generated adapter carrying the bare ABI (forwards a null env);
lowerLambda returns its func_ref. Rejected (no silent miscompile): a capturing
closure into a bare slot (env has nowhere to live) and a failable closure into
a non-failable slot (the ERR E5.1 FFI-boundary rule).
- Arrow-body failable closures (-> (T,!) => expr) now wrap the bare success value
into {value, 0} via lowerFailableSuccessReturn (the implicit return previously
returned a malformed tuple → caught value read as 0).
The isLambda .bang parser fix (failable closure literals parse) already landed in
485b4fa. Regressions: examples/0309-closures-literal-as-bare-fn-param (non-
failable, block + arrow, called in callee) + 1039-errors-failable-closure-literal
(failable, block + arrow, direct + Closure(...) param). Resolves issue 0060
(remaining E5.1 follow-ups noted in the .md). Suite: 328 passed.
25 lines
1.1 KiB
Plaintext
25 lines
1.1 KiB
Plaintext
// Failable closure literals (ERR E5.1): a `closure(...)` literal may declare a
|
|
// failable return type — `-> (T, !)` / `-> !Named` — in both block and arrow
|
|
// body forms, and `raise` inside. Called directly through the bound local, the
|
|
// error channel is consumed by `catch` / `or`; passed as a `Closure(...)`
|
|
// parameter, it composes through the callee (here absorbed with `catch`).
|
|
// (A capturing closure into a bare `(T)->U` slot, and a failable closure into a
|
|
// non-failable slot, are rejected — see issue 0060 / the FFI-boundary rule.)
|
|
|
|
#import "modules/std.sx";
|
|
|
|
E :: error { Neg }
|
|
|
|
runwith :: (cb: Closure(s64) -> (s64, !E), n: s64) -> s64 { return cb(n) catch e -1; }
|
|
|
|
main :: () -> s32 {
|
|
// block-body and arrow-body failable closures, called directly
|
|
m := closure((x: s64) -> (s64, !E) { if x < 0 { raise error.Neg; } return x * 2; });
|
|
n := closure((x: s64) -> (s64, !E) => x + 1);
|
|
print("{} {} {} {}\n", m(5) catch e 0, m(-1) catch e 99, m(-1) or 7, n(40) catch e 0); // 10 99 7 41
|
|
|
|
// failable closure passed as a Closure(...) parameter
|
|
print("param ok={} err={}\n", runwith(m, 5), runwith(m, -1)); // 10 -1
|
|
return 0;
|
|
}
|