97 lines
2.8 KiB
Plaintext
97 lines
2.8 KiB
Plaintext
#import "modules/std.sx";
|
|
|
|
// --- Closure Basics ---
|
|
|
|
// Factory: returns a new closure each time
|
|
make_adder :: (n: s64) -> Closure(s64) -> s64 {
|
|
return closure((x: s64) -> s64 => x + n);
|
|
}
|
|
|
|
// Higher-order function: accepts any Closure(s64) -> s64
|
|
apply :: (f: Closure(s64) -> s64, x: s64) -> s64 { return f(x); }
|
|
|
|
// Reduce: fold over a slice with a closure
|
|
reduce :: (arr: []s64, f: Closure(s64, s64) -> s64, init: s64) -> s64 {
|
|
acc := init;
|
|
i : s64 = 0;
|
|
while i < arr.len { acc = f(acc, arr[i]); i += 1; }
|
|
return acc;
|
|
}
|
|
|
|
// Auto-promoted bare function
|
|
triple :: (x: s64) -> s64 { return x * 3; }
|
|
|
|
// Struct with optional closure callback
|
|
Widget :: struct {
|
|
name: string;
|
|
on_update: ?Closure(s64) -> void;
|
|
}
|
|
|
|
main :: () {
|
|
// 1. Basic closure with capture
|
|
offset := 100;
|
|
add_offset := closure((x: s64) -> s64 => x + offset);
|
|
|
|
print("basic: {}\n", add_offset(42));
|
|
|
|
// 2. Capture by value (snapshot semantics)
|
|
n := 10;
|
|
snap := closure((x: s64) -> s64 => x + n);
|
|
n = 999;
|
|
print("snapshot: {}\n", snap(5));
|
|
|
|
// 3. Block-body closure with control flow
|
|
clamp := closure((x: s64) -> s64 {
|
|
if x < 0 { return 0; }
|
|
if x > 100 { return 100; }
|
|
return x;
|
|
});
|
|
print("clamp: {} {} {}\n", clamp(50), clamp(0 - 10), clamp(200));
|
|
|
|
// 4. Void closure with string capture
|
|
tag := "INFO";
|
|
logger := closure((msg: string) {
|
|
print("[{}] {}\n", tag, msg);
|
|
});
|
|
logger("system ready");
|
|
|
|
// 5. Factory pattern
|
|
add5 := make_adder(5);
|
|
add10 := make_adder(10);
|
|
print("factory: {} {}\n", add5(100), add10(100));
|
|
|
|
// 6. Auto-promotion: bare fn passed where Closure expected
|
|
print("auto-promote: {}\n", apply(triple, 7));
|
|
|
|
// 7. Closure passed to higher-order function
|
|
factor := 4;
|
|
print("hof: {}\n", apply(closure((x: s64) -> s64 => x * factor), 10));
|
|
|
|
// 8. Reduce with closure
|
|
nums : []s64 = .[1, 2, 3, 4, 5];
|
|
total := reduce(nums, closure((acc: s64, x: s64) -> s64 => acc + x), 0);
|
|
print("reduce: {}\n", total);
|
|
|
|
// 9. Closure captures closure
|
|
inner := closure((x: s64) -> s64 => x + 10);
|
|
outer := closure((x: s64) -> s64 => inner(x) * 2);
|
|
print("compose: {}\n", outer(5));
|
|
|
|
// 10. Multiple closures from same scope
|
|
base := 100;
|
|
cl_add := closure((x: s64) -> s64 => x + base);
|
|
cl_mul := closure((x: s64) -> s64 => x * base);
|
|
print("multi: {} {}\n", cl_add(5), cl_mul(5));
|
|
|
|
// 11. Optional closures
|
|
w1 := Widget.{ name = "slider", on_update = closure((val: s64) {
|
|
print("widget: {} = {}\n", "slider", val);
|
|
}) };
|
|
w2 := Widget.{ name = "label", on_update = null };
|
|
|
|
if h := w1.on_update { h(42); }
|
|
if h := w2.on_update { h(0); } else { print("widget: no handler\n"); }
|
|
|
|
print("=== DONE ===\n");
|
|
}
|