Zero Bit Types

For some types, @sizeOf is 0:

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

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:

zero_bit_types.zig

  1. export fn entry() void {
  2.     var x: void = {};
  3.     var y: void = {};
  4.     x = y;
  5. }

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:

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

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

void

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:

test_void_in_hashmap.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "turn HashMap into a set with void" {
  5.     var map = std.AutoHashMap(i32, void).init(std.testing.allocator);
  6.     defer map.deinit();
  8.     try map.put(1, {});
  9.     try map.put(2, {});
  11.     try expect(map.contains(2));
  12.     try expect(!map.contains(3));
  14.     _ = map.remove(2);
  15.     try expect(!map.contains(2));
  16. }

Shell

  1. $ zig test test_void_in_hashmap.zig
  2. 1/1 test.turn HashMap into a set with void... OK
  3. 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 anyopaque. void has a known size of 0 bytes, and anyopaque has an unknown, but non-zero, size.

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

test_expression_ignored.zig

  1. test "ignoring expression value" {
  2.     foo();
  3. }
  5. fn foo() i32 {
  6.     return 1234;
  7. }

Shell

  1. $ zig test test_expression_ignored.zig
  2. docgen_tmp/test_expression_ignored.zig:2:8: error: value of type 'i32' ignored
  3.     foo();
  4.     ~~~^~
  5. docgen_tmp/test_expression_ignored.zig:2:8: note: all non-void values must be used
  6. docgen_tmp/test_expression_ignored.zig:2:8: note: this error can be suppressed by assigning the value to '_'

However, if the expression has type void, there will be no error. Function return values can also be explicitly ignored by assigning them to _.

test_void_ignored.zig

  1. test "void is ignored" {
  2.     returnsVoid();
  3. }
  5. test "explicitly ignoring expression value" {
  6.     _ = foo();
  7. }
  9. fn returnsVoid() void {}
  11. fn foo() i32 {
  12.     return 1234;
  13. }

Shell

  1. $ zig test test_void_ignored.zig
  2. 1/2 test.void is ignored... OK
  3. 2/2 test.explicitly ignoring expression value... OK
  4. All 2 tests passed.