Proposal: Add a way to quickly access a tagged union's payload, when the payload type is known at comptime

[omgitsmoe]

Motivation

When using zig's tagged union I often find myself in a situation where I know which tags can be active and that those tags share the same payload type. To access that payload I'd have to use a switch on the tagged union typing out all the tags that can be active, which can add up to a lot of typing if there are alot of tags sharing the same type.

(Of course you could use a bare union with a separate tag, where you wouldn't have to use a switch on the union to just access the payload directly, but you'd lose alot of the niceties that come with zig's tagged union.)

Proposal

Add a builtin to access a union's payload with a comptime known type directly.

Example

const Tagged = union(enum) {
    A: i32,
    B: []const u8,
    C: i32,
};

fn current() void {
    var t = Tagged{ .C = -5 };

    switch (t) {
        .A, .C => |*num| {
            num.* = 234;
        },
        else => unreachable,
    }
}

fn new() void {
    var t = Tagged{ .C = -5 };

    // getting a ptr to the payload
    const payload = @unionPayloadPtr(i32, t);
    // for quickly setting it
    @unionSetPayload(i32, t, 234);
}

[ghost]

This should not require a new builtin.

fn unionPayloadPtr(comptime T: type, union_ptr: anytype) ?*T {
    const U = @typeInfo(@TypeOf(union_ptr)).Pointer.child;
    inline for (@typeInfo(U).Union.fields) |field, i| {
        if (field.field_type != T)
            continue;
        if (@enumToInt(union_ptr.*) == i)
            return &@field(union_ptr, field.name);
    }
    return null;
}

pub fn main() void {
    const std = @import("std");

    const Tagged = union(enum) {
        A: i32,
        B: []const u8,
        C: i32,
    };

    var t = Tagged{ .C = -5 };

    if (unionPayloadPtr(i32, &t)) |ptr|
        std.debug.warn("{}\n", .{ptr.*});

    if (unionPayloadPtr(i32, &t)) |ptr|
        ptr.* = 100;
}

This takes advantage of the fact that you can use struct-like field access in a union (which asserts if you don't access the active tag). I don't think this is documented. E.g. you could write t.A to get the payload of the A variant, assuming it's the active tag. In my example I'm doing it via the @field builtin.

[omgitsmoe]

Thank you! Amazing that this already works.

Should I leave this open for maybe adding sth. like this to std.meta?

[omgitsmoe]

Am I doing sth. wrong or why is there an extra (compared to the switch/old version) cmp instruction in the new2 version on godbolt?

[ifreund]

Am I doing sth. wrong or why is there an extra (compared to the switch/old version) cmp instruction in the new2 version on godbolt?

You're not doing anything wrong afaict. This use-case could benefit from the proposed and accepted inline switch (#7224) which would allow writing this function with semantics that are much easier for the optimizer to deal with.

[LewisGaul]

Should I leave this open for maybe adding sth. like this to std.meta?

+1 from me for something in std.meta for this. I find myself copying the logic in

zig/lib/std/json.zig

Line 2811 in 7b5d139

inline for (info.fields) |u_field| {

which feels like it could be more suited to std.meta, providing a simpler option like a unionPayload() function.