looking at 5056 possibilities

empty

empty

// with `const` removed for values
// with `=` for decl
// with `:=` for assign and other operators that modify lhs value
// with `.` prefix for fields
// with replace `,` with `;` for field delimiter
// with adapted tuple destruction
// with another idea; `var` keyword for fn params: indicates copy+mutable

// decl decl-ro
std = @import("std.zig");
math = std.math;
assert = std.debug.assert;
mem = std.mem;

// decl decl-rw
var some_counter: u64 = 0;

// public decl-ro
pub Foo = struct {
    // fields use dot-prefix
    .a: u32;                // field, u32, no default value
    .b: u32 = 5;            // field, u32, default value
    .c = true;              // field, infer bool, default value

    a: u32;                 // compile error
    b: u32 = 5;             // decl-ro, u32, default value
    c = true;               // decl-ro, infer bool, default value
    var d: u32 = 5;         // decl-rw, u32, default value
    var e = true;           // decl-rw, infer bool, default value
    f: *u32 = &d;           // decl-ro, *u32, default value, pointee-rw
    g: *const u32 = &b;     // decl-ro, *u32, default value, pointee-ro
};

// decl-ro
pub indexOfScalarPos = fn(comptime T: type, slice: []const T, var i: usize, value: T) ?usize {
    while (i < slice.len) : (i += 1) {
        if (slice[i] == value) return i;
    }
    return null;
}

// decl-ro
foo = fn() void {
    i: u32 = 11;        // decl-ro
    var j: u32 = 12;    // decl-rw

    i := j;             // assign
    i += 1;

    var buf: [16]u8 = undefined;    // decl-rw
    buf[15] := 0;                   // assign

    // uniform decl-ro, all types infer
    // `a`, `b`, `c`, `d`, immutable
    a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // uniform decl-rw, all types infer
    // `a`, `b`, `c`, `d`, mutable
    var a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // explicit decl
    (a, var b, c: u128, var d: u128) = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // assign
    a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // enum continue to use `,` syntax
    E = enum { cat, dog, mouse };       // decl
    cat,mouse = .{ E.cat, E.mouse };    // decl

    // error sets continue to use `,` syntax
    AllocationError = error {
        OutOfMemory,
    };
    err = doit(AllocationError.OutOfMemory);    // decl
    AllError = AllocatorError || IOError;       // decl

    // union fields use `.` and `;`
    Number = union(enum) {
        .U32: u32;
        .U64: u64;
    };
    var num: Number = .{ .U32 = 0 };    // decl
    num := .{ .U64 = 10 };              // assign

    // struct fields use `.` and `;`
    City = struct {
        .arrive: []const u8 = "hello";
        .depart: []const u8 = "goodbye";
    };
    honolulu = City{};          // decl
    honolulu.arrive := "aloha"; // assign
    honolulu.depart := "aloha"; // assign
};

// uniform decl-ro, all types infer
// `a`, `b`, `c`, `d`, immutable
a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// uniform decl-rw, all types infer
// `a`, `b`, `c`, `d`, mutable
var a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// explicit decl
(a, var b, c: u128, var d: u128) = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// compiler-error: assign not possible here
a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// with `const` removed for values
// with `:=` for decl
// with `.` prefix for fields
// with replace `,` with `;` for field delimiter
// with adapted tuple destruction
// with another idea; `var` keyword for fn params: indicates copy+mutable

// decl decl-ro
std := @import("std.zig");
math := std.math;
assert := std.debug.assert;
mem := std.mem;

// decl decl-rw
var some_counter: u64 := 0;

// public decl-ro
pub Foo := struct {
    // fields use dot-prefix
    .a: u32;                // field, u32, no default value
    .b: u32 := 5;           // field, u32, default value
    .c := true;             // field, infer bool, default value

    a: u32;                 // compile error
    b: u32 := 5;            // decl-ro, u32, default value
    c := true;              // decl-ro, infer bool, default value
    var d: u32 := 5;        // decl-rw, u32, default value
    var e := true;          // decl-rw, infer bool, default value
    f: *u32 := &d;          // decl-ro, *u32, default value, pointee-rw
    g: *const u32 := &b;    // decl-ro, *u32, default value, pointee-ro
};

// decl-ro
pub indexOfScalarPos := fn(comptime T: type, slice: []const T, var i: usize, value: T) ?usize {
    while (i < slice.len) : (i += 1) {
        if (slice[i] == value) return i;
    }
    return null;
}

// decl-ro
foo := fn() void {
    i: u32 = 11;        // decl-ro
    var j: u32 = 12;    // decl-rw

    i = j;              // assign
    i += 1;

    var buf: [16]u8 = undefined;    // decl-rw
    buf[15] = 0;                    // assign

    // uniform decl-ro, all types infer
    // `a`, `b`, `c`, `d`, immutable
    a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // uniform decl-rw, all types infer
    // `a`, `b`, `c`, `d`, mutable
    var a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // explicit decl
    (a, var b, c: u128, var d: u128) := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // assign
    a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

    // enum continue to use `,` syntax
    E := enum { cat, dog, mouse };       // decl
    cat,mouse := .{ E.cat, E.mouse };    // decl

    // error sets continue to use `,` syntax
    AllocationError = error {
        OutOfMemory,
    };
    err := doit(AllocationError.OutOfMemory);    // decl
    AllError := AllocatorError || IOError;       // decl

    // union fields use `.` and `;`
    Number := union(enum) {
        .U32: u32;
        .U64: u64;
    };
    var num: Number := .{ .U32 = 0 };   // decl
    num = .{ .U64 = 10 };               // assign

    // struct fields use `.` and `;`
    City := struct {
        .arrive: []const u8 := "hello";     // field, default
        .depart: []const u8 := "goodbye";   // field, default
    };
    honolulu := City{};         // decl
    honolulu.arrive = "aloha";  // assign
    honolulu.depart = "aloha";  // assign

    // `_` uses assign syntax
    _ = run();
};

// uniform decl-ro, all types infer
// `a`, `b`, `c`, `d`, immutable
a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// uniform decl-rw, all types infer
// `a`, `b`, `c`, `d`, mutable
var a,b,c,d := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// explicit decl
(a, var b, c: u128, var d: u128) := .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };

// compiler-error: assign not possible here
a,b,c,d = .{ @as(u8,0), @as(u16,1), @as(u32,2), @as(u64,3) };