test:zig

guide/language/anonymous-structs.zig

@@ -0,0 +1,56 @@
+const expect = @import("std").testing.expect;
+
+// The struct type may be omitted from a struct literal. These literals may coerce to other struct types.
+test "anonymous struct literal" {
+    const Point = struct { x: i32, y: i32 };
+
+    const pt: Point = .{
+        .x = 13,
+        .y = 67,
+    };
+    try expect(pt.x == 13);
+    try expect(pt.y == 67);
+}
+
+// Anonymous structs may be completely anonymous i.e. without being coerced to another struct type.
+test "fully anonymous struct" {
+    try dump(.{
+        .int = @as(u32, 1234),
+        .float = @as(f64, 12.34),
+        .b = true,
+        .s = "hi",
+    });
+}
+
+fn dump(args: anytype) !void {
+    try expect(args.int == 1234);
+    try expect(args.float == 12.34);
+    try expect(args.b);
+    try expect(args.s[0] == 'h');
+    try expect(args.s[1] == 'i');
+}
+
+// Anonymous structs without field names may be created and are referred to as tuples.
+// These have many of the properties that arrays do; tuples can be iterated over,
+// indexed, can be used with the `++` and `**` operators, and have a len field.
+// Internally, these have numbered field names starting at `"0"`,
+// which may be accessed with the special syntax `@"0"` which acts as an escape for the syntax
+//  - things inside `@""` are always recognised as identifiers.
+
+// An `inline` loop must be used to iterate over the tuple here, as the type of each tuple field may differ.
+test "tuple" {
+    const values = .{
+        @as(u32, 1234),
+        @as(f64, 12.34),
+        true,
+        "hi",
+    } ++ .{false} ** 2;
+    try expect(values[0] == 1234);
+    try expect(values[4] == false);
+    inline for (values, 0..) |v, i| {
+        if (i != 2) continue;
+        try expect(v);
+    }
+    try expect(values.len == 6);
+    try expect(values.@"3"[0] == 'h');
+}