d7ecf02d7a
A pack spread in call-arg position now expands to N positional args: `add2(..xs.get)` ≈ `add2(xs[0].get(), xs[1].get())` — the canonical's `mapper(..sources.value)` shape. The call-arg loop detects a spread whose operand is a pack (`..xs`) or a pack projection (`..xs.method`) and splices the per-element Refs in; a runtime-slice spread (`..arr`) is still left to the slice-variadic path. Factored the per-element synthesis out of lowerPackValueProjection into `lowerPackElems` (used by both projection-to-tuple and spread-to-args), plus a `packSpreadRefs` helper. examples/197-pack-spread-call.sx (2- and 3-arg, mixed element types).
27 lines
993 B
Plaintext
27 lines
993 B
Plaintext
// Feature 1 — pack spread into a call's positional arguments. `f(..xs.get)`
|
|
// projects `get` over the pack and spreads the resulting tuple into f's params:
|
|
// add2(..xs.get) ≈ add2(xs[0].get(), xs[1].get())
|
|
// The canonical's `mapper(..sources.value)` is this shape.
|
|
|
|
#import "modules/std.sx";
|
|
|
|
Box :: protocol(T: Type) {
|
|
get :: () -> s64;
|
|
}
|
|
IntCell :: struct { v: s64; }
|
|
Dbl :: struct { n: s64; }
|
|
impl Box(s64) for IntCell { get :: (self: *IntCell) -> s64 => self.v; }
|
|
impl Box(s64) for Dbl { get :: (self: *Dbl) -> s64 => self.n * 2; }
|
|
|
|
add2 :: (a: s64, b: s64) -> s64 { return a + b; }
|
|
add3 :: (a: s64, b: s64, c: s64) -> s64 { return a + b + c; }
|
|
|
|
via2 :: (..xs: Box) -> s64 { return add2(..xs.get); }
|
|
via3 :: (..xs: Box) -> s64 { return add3(..xs.get); }
|
|
|
|
main :: () -> s32 {
|
|
print("two={}\n", via2(IntCell.{ v = 10 }, Dbl.{ n = 5 })); // 10 + 10 = 20
|
|
print("three={}\n", via3(Dbl.{ n = 1 }, IntCell.{ v = 2 }, Dbl.{ n = 3 })); // 2 + 2 + 6 = 10
|
|
0;
|
|
}
|