How to assign optional tag

[mnemnion]

@chadwain

Actually, in Debug mode, this works for all types T.

fn bar(comptime T: type) !void {
    var x: ?T = null;
    x = @as(T, undefined);
    try expect(x != null);
}

But in ReleaseFast, it fails for pointers and function pointers

So we’ve established something here: This is a bad idea, and always run tests in ReleaseFast mode if trying to figure out what kind of weird stuff you can actually get away with.

@pqsrc

Sure we could assign the tag over and over again, wasting CPU cycles, but that would not be optimal, and that’s why Zig’s design gives us a way to avoid this waste (for unions, but seemingly not for optionals without an ugly cast).

All of this passes in both Debug and ReleaseFast mode.

const ExampleStruct = struct {
    v: u64,
};

fn returnOptional(val: u64) ?ExampleStruct {
    var example: ExampleStruct = undefined;
    example.v = val;
    return example;
}

test "It returns optional" {
    const opt = returnOptional(23);
    if (opt) |it| {
        try expectEqual(23, it.v);
    } else {
        try expect(false);
    }
}

fn takesOptional(maybe_it: ?ExampleStruct) !void {
    if (maybe_it) |it| {
        try expectEqual(128, it.v);
    } else {
        try expect(false);
    }
}

test "It passes optional" {
    var example: ExampleStruct = undefined;
    example.v = 128;
    try takesOptional(example);
}

test "Trivial assignment case" {
    var example: ExampleStruct = undefined;
    example.v = 128;
    const maybe_example: ?ExampleStruct = example;
    try takesOptional(maybe_example);
}

I don’t think real code exists where doing things this way would not be strongly preferred. You can always assign a T to a ?T. So if you need to build a T up by parts, you don’t need to create it as a ?T, create it as a T and: return it, pass it, or assign it to a ?T.