989e18b760
Replace the bare-paren tuple grammar with explicit, position-unambiguous
forms, mirroring how structs work:
type `(A, B)` -> `Tuple(A, B)` (named keeps `:`)
value `(a, b)` -> `.(a, b)` (named uses `=`)
typed (new) -> `Tuple(A, B).(a, b)` (like `Point.{...}`)
failable `-> (T, !)` -> `-> T !`
`-> (T1, T2, !)`-> `-> Tuple(T1, T2) !` (channel outside Tuple)
Bare `(...)` is now grouping only, everywhere; a comma in bare parens is a
hard error with a migration hint. Grouping, function types `(A, B) -> R`,
param lists, lambdas, and match bindings are unaffected.
`Tuple(...)` is strictly a TYPE in every position (including `size_of` /
`type_info` args); a tuple VALUE comes only from `.(...)` (anonymous) or
`Tuple(...).(...)` (explicitly typed). A bare `Tuple(1, 2)` is a tuple
type with non-type elements -> rejected.
The ~110 tuple-bearing corpus files were migrated with a one-shot
AST-aware migrator (the `sx migrate` tool from the prior commit, removed
here). New examples: 0130 (new syntax), 0131 (typed construction), 1060
(named-tuple failable return). 1116 golden updated for the new hint text.
26 lines
970 B
Plaintext
26 lines
970 B
Plaintext
// Phase 4.2 (core) — a generic struct with a pack type-param `..$Ts: []Type`
|
|
// and a pack-shaped tuple field `(..$Ts)`. Each instantiation binds the
|
|
// remaining type args as the pack, so the field is a tuple of those per-position
|
|
// types. Storing the whole tuple field and reading its elements both work.
|
|
|
|
#import "modules/std.sx";
|
|
|
|
Box :: struct($R: Type, ..$Ts: []Type) {
|
|
r: $R;
|
|
pair: Tuple(..$Ts); // tuple of the pack's element types
|
|
}
|
|
|
|
main :: () -> i32 {
|
|
// Box(i64, i32, string): R=i64, Ts=[i32, string], pair: (i32, string).
|
|
a : Box(i64, i32, string) = ---;
|
|
a.r = 7;
|
|
a.pair = .(42, "hi"); // whole-tuple field store
|
|
print("a: r={} 0={} 1={}\n", a.r, a.pair.0, a.pair.1);
|
|
|
|
// A different shape → a different per-position tuple field.
|
|
b : Box(bool, string, bool) = ---; // Ts=[string, bool], pair: (string, bool)
|
|
b.pair = .("x", true);
|
|
print("b: 0={} 1={}\n", b.pair.0, b.pair.1);
|
|
0
|
|
}
|