enum

    2. 1/7 test "enum ordinal value"...OK
    3. 2/7 test "set enum ordinal value"...OK
    4. 3/7 test "enum method"...OK
    5. 4/7 test "enum variant switch"...OK
    6. 5/7 test "@TagType"...OK
    7. 6/7 test "@typeInfo"...OK
    8. 7/7 test "@tagName"...OK
    9. All 7 tests passed.

    See also:

    By default, enums are not guaranteed to be compatible with the C ABI:

    test.zig

    1. const Foo = enum { A, B, C };
    2. export fn entry(foo: Foo) void { }
    1. $ zig build-obj test.zig
    2. ./docgen_tmp/test.zig:2:22: error: parameter of type 'Foo' not allowed in function with calling convention 'C'
    3. export fn entry(foo: Foo) void { 
    4.                      ^

    For a C-ABI-compatible enum, use extern enum:

      By default, the size of enums is not guaranteed.

      packed enum causes the size of the enum to be the same as the size of the integer tag type of the enum:

      test.zig

      1. const std = @import("std");
      3. test "packed enum" {
      5.         One,
      6.         Two,
      7.         Three,
      8.     };
      9.     std.debug.assert(@sizeOf(Number) == @sizeOf(u8));
      10. }
      1. $ zig test test.zig
      2. 1/1 test "packed enum"...OK
      3. All 1 tests passed.

      This makes the enum eligible to be in a .

      test.zig

      1. $ zig test test.zig
      2. 1/2 test "enum literals"...OK
      3. 2/2 test "switch using enum literals"...OK
      4. All 2 tests passed.

      A Non-exhaustive enum can be created by adding a trailing '_' field. It must specify a tag type and cannot consume every enumeration value.

      @intToEnum on a non-exhaustive enum cannot fail.

      A switch on a non-exhaustive enum can include a '_' prong as an alternative to an else prong with the difference being that it makes it a compile error if all the known tag names are not handled by the switch. 

      1. const std = @import("std");
      2. const assert = std.debug.assert;
      4. const Number = enum(u8) {
      5.     One,
      7.     _,
      8. };
      10. test "switch on non-exhaustive enum" {
      11.     const number = Number.One;
      12.     const result = switch (number) {
      13.         .One => true,
      14.         .Two,
      15.         .Three => false,
      16.         _ => false,
      17.     };
      18.     assert(result);
      19.     const is_one = switch (number) {
      20.         .One => true,
      21.         else => false,
      22.     };
      23.     assert(is_one);
      24. }
      1. $ zig test test.zig
      2. 1/1 test "switch on non-exhaustive enum"...OK