enums.directEnumArrayDefault, using null as default value

Help
, ,
1

Here is the code for the: enums.directEnumArrayDefault from std (master)

/// Initializes an array of Data which can be indexed by
/// @intCast(usize, @intFromEnum(enum_value)).  The enum must be exhaustive.
/// If the enum contains any fields with values that cannot be represented
/// by usize, a compile error is issued.  The max_unused_slots parameter limits
/// the total number of items which have no matching enum key (holes in the enum
/// numbering).  So for example, if an enum has values 1, 2, 5, and 6, max_unused_slots
/// must be at least 3, to allow unused slots 0, 3, and 4.
/// The init_values parameter must be a struct with field names that match the enum values.
/// If the enum has multiple fields with the same value, the name of the first one must
/// be used.
pub fn directEnumArrayDefault(
    comptime E: type,
    comptime Data: type,
    comptime default: ?Data,
    comptime max_unused_slots: comptime_int,
    init_values: EnumFieldStruct(E, Data, default),
) [directEnumArrayLen(E, max_unused_slots)]Data {
    const len = comptime directEnumArrayLen(E, max_unused_slots);
    var result: [len]Data = if (default) |d| [_]Data{d} ** len else undefined;
    inline for (@typeInfo(@TypeOf(init_values)).@"struct".fields) |f| {
        const enum_value = @field(E, f.name);
        const index = @as(usize, @intCast(@intFromEnum(enum_value)));
        result[index] = @field(init_values, f.name);
    }
    return result;
}

Am I missing something, is it impossible to have null in the resulting array? The returned slice is of type Data and, unless I’m misreading this line:
var result: [len]Data = if (default) |d| [_]Data{d} ** len else undefined; In case default is null we always set it to undefined.

This is a bit weird to me, what am I missing, i.e. how can I have nulls as defaults in case of “holes” in my enum?

1 Like
2

You should pass @as(T, null) , where T is your element type, which is itself an optional type.

const std = @import("std");

pub fn main() !void {
    const array = std.enums.directEnumArrayDefault(
        enum { a, b, c },
        ?i32,
        @as(?i32, null),
        0,
        .{
            .a = 1,
            .c = -20,
        },
    );

    for (array) |item| {
        std.debug.print("{?d}\n", .{item});
    }
}

This is because the default parameter in this case takes ??i32, so specifying that the null is for the inner optional is what makes it work.

Result:

$ zig run dea.zig
1
null
-20
2 Likes
3

Ok, makes sense now that you explained it. Never would’ve guessed by myself, thank you very much :slight_smile:

Thinking about the directEnumArrayDefault / directEnumArray - they are very powerful, but I don’t like this “hidden” UB - meaning if you are not extra careful, you’ll get UB - I’d prefer if the user was forced to pass in undefined and not to use it as fallback (especially in case of directEnumArray)

3 Likes
4

That’s not a bad idea, especially considering the consensus around Proposal: pass default value to `std.mem.Allocator.create` etc · Issue #20683 · ziglang/zig · GitHub. Making undefined explicit is a good thing.

4 Likes
5

Thank you very much, for the feedback, as I’m complete zig noob, it’s much appreciated. I’ll open issue in the repo, and see what others think :slight_smile:

EDIT: I can’t . Will open another topic here - the one specific to the explicit undefined