• void
• The and i0.
• Arrays and with len 0, or with an element type that is a zero bit type.
• An enum with only 1 tag.
• A with all fields being zero bit types.
• A union with only 1 field which is a zero bit type.
• are themselves zero bit types.

These types can only ever have one possible value, and thus require 0 bits to represent. Code that makes use of these types is not included in the final generated code:

When this turns into machine code, there is no code generated in the body of entry, even in Debug mode. For example, on x86_64:

0000000000000010 <entry>:
  10:    55                       push   %rbp
  11:    48 89 e5                 mov    %rsp,%rbp
  14:    5d                       pop    %rbp
  15:    c3                       retq

These assembly instructions do not have any code associated with the void values - they only perform the function call prologue and epilog.

void can be useful for instantiating generic types. For example, given a Map(Key, Value), one can pass void for the Value type to make it into a Set:

const std = @import("std");
const expect = std.testing.expect;
test "turn HashMap into a set with void" {
    var map = std.AutoHashMap(i32, void).init(std.testing.allocator);
    defer map.deinit();
    try map.put(1, {});
    try map.put(2, {});
    expect(map.contains(2));
    expect(!map.contains(3));
    expect(!map.contains(2));
}

$ zig test test.zig
All 1 tests passed.

Note that this is different from using a dummy value for the hash map value. By using void as the type of the value, the hash map entry type has no value field, and thus the hash map takes up less space. Further, all the code that deals with storing and loading the value is deleted, as seen above.

void is distinct from c_void, which is defined like this: pub const c_void = opaque {};. void has a known size of 0 bytes, and c_void has an unknown, but non-zero, size.

Expressions of type void are the only ones whose value can be ignored. For example:

test.zig

$ zig test test.zig
./docgen_tmp/test.zig:2:8: error: expression value is ignored
    foo();
       ^
./docgen_tmp/test.zig:1:34: note: referenced here
test "ignoring expression value" {
                                 ^

test.zig

test "void is ignored" {
    returnsVoid();
}
test "explicitly ignoring expression value" {
    _ = foo();
}
fn returnsVoid() void {}
fn foo() i32 {
    return 1234;

$ zig test test.zig
1/2 test "void is ignored"... OK
All 2 tests passed.

Pointers to zero bit types also have zero bits. They always compare equal to each other:

test.zig

$ zig test test.zig
1/1 test "pointer to empty struct"... OK
All 1 tests passed.

The type being pointed to can only ever be one value; therefore loads and stores are never generated. ptrToInt and are not allowed:

const Empty = struct {};
test "@ptrToInt for pointer to zero bit type" {
    var a = Empty{};
    _ = @ptrToInt(&a);
}
test "@intToPtr for pointer to zero bit type" {
    _ = @intToPtr(*Empty, 0x1);
}

$ zig test test.zig
./docgen_tmp/test.zig:4:5: error: pointer to size 0 type has no address
    var a = Empty{};
    ^
./docgen_tmp/test.zig:5:9: note: referenced here
    _ = @ptrToInt(&a);
        ^
./docgen_tmp/test.zig:9:19: error: type '*Empty' has 0 bits and cannot store information
    _ = @intToPtr(*Empty, 0x1);
                  ^
./docgen_tmp/test.zig:9:9: note: referenced here
    _ = @intToPtr(*Empty, 0x1);