Errors

    The number of unique error values across the entire compilation should determine the size of the error set type. However right now it is hard coded to be a . See .

    You can coerce an error from a subset to a superset:

    coercing_subset_to_superset.zig

    Shell

    1. $ zig test coercing_subset_to_superset.zig
    2. 1/1 test "coerce subset to superset"... OK
    3. All 1 tests passed.

    But you cannot an error from a superset to a subset:

    test.zig

    1. const FileOpenError = error {
    2.     AccessDenied,
    3.     OutOfMemory,
    4.     FileNotFound,
    5. };
    7. const AllocationError = error {
    8.     OutOfMemory,
    9. };
    11. test "coerce superset to subset" {
    12.     foo(FileOpenError.OutOfMemory) catch {};
    13. }
    15. fn foo(err: FileOpenError) AllocationError {
    16.     return err;
    17. }

    Shell

    1. $ zig test test.zig
    2. ./docgen_tmp/test.zig:16:12: error: expected type 'AllocationError', found 'FileOpenError'
    3.     return err;
    4.            ^
    5. ./docgen_tmp/test.zig:2:5: note: 'error.AccessDenied' not a member of destination error set
    6.     AccessDenied,
    7.     ^
    8. ./docgen_tmp/test.zig:4:5: note: 'error.FileNotFound' not a member of destination error set
    9.     FileNotFound,
    10.     ^

    There is a shortcut for declaring an error set with only 1 value, and then getting that value:

    test.zig

    1. const err = error.FileNotFound;

    This is equivalent to:

    test.zig

    1. const err = (error {FileNotFound}).FileNotFound;

    This becomes useful when using Inferred Error Sets.

    anyerror refers to the global error set. This is the error set that contains all errors in the entire compilation unit. It is a superset of all other error sets and a subset of none of them.

    You can any error set to the global one, and you can explicitly cast an error of the global error set to a non-global one. This inserts a language-level assert to make sure the error value is in fact in the destination error set.

    The global error set should generally be avoided because it prevents the compiler from knowing what errors are possible at compile-time. Knowing the error set at compile-time is better for generated documentation and helpful error messages, such as forgetting a possible error value in a switch.

    An error set type and normal type can be combined with the ! binary operator to form an error union type. You are likely to use an error union type more often than an error set type by itself.

    Here is a function to parse a string into a 64-bit integer:

    error_union_parsing_u64.zig

    1. const std = @import("std");
    2. const maxInt = std.math.maxInt;
    4. pub fn parseU64(buf: []const u8, radix: u8) !u64 {
    5.     var x: u64 = 0;
    7.     for (buf) |c| {
    8.         const digit = charToDigit(c);
    10.         if (digit >= radix) {
    11.             return error.InvalidChar;
    12.         }
    14.         // x *= radix
    15.         if (@mulWithOverflow(u64, x, radix, &x)) {
    16.             return error.Overflow;
    17.         }
    19.         // x += digit
    20.         if (@addWithOverflow(u64, x, digit, &x)) {
    21.             return error.Overflow;
    22.         }
    23.     }
    25.     return x;
    26. }
    28. fn charToDigit(c: u8) u8 {
    29.     return switch (c) {
    30.         '0' ... '9' => c - '0',
    31.         'A' ... 'Z' => c - 'A' + 10,
    32.         'a' ... 'z' => c - 'a' + 10,
    33.         else => maxInt(u8),
    34.     };
    35. }
    37. test "parse u64" {
    38.     const result = try parseU64("1234", 10);
    39.     try std.testing.expect(result == 1234);
    40. }

    Shell

    1. $ zig test error_union_parsing_u64.zig
    2. 1/1 test "parse u64"... OK
    3. All 1 tests passed.

    Notice the return type is !u64. This means that the function either returns an unsigned 64 bit integer, or an error. We left off the error set to the left of the !, so the error set is inferred.

    Within the function definition, you can see some return statements that return an error, and at the bottom a return statement that returns a u64. Both types to anyerror!u64.

    What it looks like to use this function varies depending on what you’re trying to do. One of the following:

    • You want to provide a default value if it returned an error.
    • If it returned an error then you want to return the same error.
    • You know with complete certainty it will not return an error, so want to unconditionally unwrap it.
    • You want to take a different action for each possible error.

    If you want to provide a default value, you can use the catch binary operator:

    test.zig

    Let’s say you wanted to return the error if you got one, otherwise continue with the function logic:

    test.zig

    1. const parseU64 = @import("error_union_parsing_u64.zig").parseU64;
    3. fn doAThing(str: []u8) !void {
    4.     const number = parseU64(str, 10) catch |err| return err;
    5.     _ = number; // ...
    6. }

    There is a shortcut for this. The try expression:

    test.zig

    1. const parseU64 = @import("error_union_parsing_u64.zig").parseU64;
    3. fn doAThing(str: []u8) !void {
    4.     const number = try parseU64(str, 10);
    5.     _ = number; // ...
    6. }

    try evaluates an error union expression. If it is an error, it returns from the current function with the same error. Otherwise, the expression results in the unwrapped value.

    Maybe you know with complete certainty that an expression will never be an error. In this case you can do this:

    const number = parseU64("1234", 10) catch unreachable;

    Here we know for sure that “1234” will parse successfully. So we put the unreachable value on the right hand side. unreachable generates a panic in Debug and ReleaseSafe modes and undefined behavior in ReleaseFast mode. So, while we’re debugging the application, if there was a surprise error here, the application would crash appropriately.

    Finally, you may want to take a different action for every situation. For that, we combine the if and expression:

    handle_all_error_scenarios.zig

    1. fn doAThing(str: []u8) void {
    2.     if (parseU64(str, 10)) |number| {
    3.         doSomethingWithNumber(number);
    4.     } else |err| switch (err) {
    5.         error.Overflow => {
    6.             // handle overflow...
    7.         },
    8.         // we promise that InvalidChar won't happen (or crash in debug mode if it does)
    9.         error.InvalidChar => unreachable,
    10.     }
    11. }

    The other component to error handling is defer statements. In addition to an unconditional defer, Zig has errdefer, which evaluates the deferred expression on block exit path if and only if the function returned with an error from the block.

    Example:

    errdefer_example.zig

    1. fn createFoo(param: i32) !Foo {
    2.     const foo = try tryToAllocateFoo();
    3.     // now we have allocated foo. we need to free it if the function fails.
    4.     // but we want to return it if the function succeeds.
    5.     errdefer deallocateFoo(foo);
    7.     // tmp_buf is truly a temporary resource, and we for sure want to clean it up
    9.     defer deallocateTmpBuffer(tmp_buf);
    11.     if (param > 1337) return error.InvalidParam;
    13.     // here the errdefer will not run since we're returning success from the function.
    14.     // but the defer will run!
    15.     return foo;
    16. }

    The neat thing about this is that you get robust error handling without the verbosity and cognitive overhead of trying to make sure every exit path is covered. The deallocation code is always directly following the allocation code.

    A couple of other tidbits about error handling:

    • These primitives give enough expressiveness that it’s completely practical to have failing to check for an error be a compile error. If you really want to ignore the error, you can add catch unreachable and get the added benefit of crashing in Debug and ReleaseSafe modes if your assumption was wrong.
    • Since Zig understands error types, it can pre-weight branches in favor of errors not occurring. Just a small optimization benefit that is not available in other languages.

    See also:

    An error union is created with the ! binary operator. You can use compile-time reflection to access the child type of an error union:

    test_error_union.zig

    1. const expect = @import("std").testing.expect;
    3. test "error union" {
    4.     var foo: anyerror!i32 = undefined;
    6.     // Coerce from child type of an error union:
    7.     foo = 1234;
    9.     // Coerce from an error set:
    10.     foo = error.SomeError;
    12.     // Use compile-time reflection to access the payload type of an error union:
    13.     comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32);
    15.     // Use compile-time reflection to access the error set type of an error union:
    16.     comptime try expect(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror);
    17. }

    Shell

    1. $ zig test test_error_union.zig
    2. 1/1 test "error union"... OK
    3. All 1 tests passed.

    Use the || operator to merge two error sets together. The resulting error set contains the errors of both error sets. Doc comments from the left-hand side override doc comments from the right-hand side. In this example, the doc comments for C.PathNotFound is A doc comment.

    This is especially useful for functions which return different error sets depending on comptime branches. For example, the Zig standard library uses LinuxFileOpenError || WindowsFileOpenError for the error set of opening files.

    test_merging_error_sets.zig

    1. const A = error{
    2.     NotDir,
    4.     /// A doc comment
    5.     PathNotFound,
    6. };
    7. const B = error{
    8.     OutOfMemory,
    10.     /// B doc comment
    11.     PathNotFound,
    12. };
    14. const C = A || B;
    16. fn foo() C!void {
    17.     return error.NotDir;
    18. }
    20. test "merge error sets" {
    21.     if (foo()) {
    22.         @panic("unexpected");
    23.     } else |err| switch (err) {
    24.         error.OutOfMemory => @panic("unexpected"),
    25.         error.PathNotFound => @panic("unexpected"),
    26.         error.NotDir => {},
    27.     }
    28. }

    Shell

    Inferred Error Sets

    Because many functions in Zig return a possible error, Zig supports inferring the error set. To infer the error set for a function, prepend the ! operator to the function’s return type, like !T:

    1. // With an inferred error set
    2. pub fn add_inferred(comptime T: type, a: T, b: T) !T {
    3.     var answer: T = undefined;
    4.     return if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer;
    5. }
    7. // With an explicit error set
    8. pub fn add_explicit(comptime T: type, a: T, b: T) Error!T {
    9.     var answer: T = undefined;
    10.     return if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer;
    11. }
    13. const Error = error {
    14.     Overflow,
    15. };
    17. const std = @import("std");
    19. test "inferred error set" {
    20.     if (add_inferred(u8, 255, 1)) |_| unreachable else |err| switch (err) {
    21.         error.Overflow => {}, // ok
    22.     }
    23. }

    Shell

    1. $ zig test inferred_error_sets.zig
    2. 1/1 test "inferred error set"... OK
    3. All 1 tests passed.

    When a function has an inferred error set, that function becomes generic and thus it becomes trickier to do certain things with it, such as obtain a function pointer, or have an error set that is consistent across different build targets. Additionally, inferred error sets are incompatible with recursion.

    In these situations, it is recommended to use an explicit error set. You can generally start with an empty error set and let compile errors guide you toward completing the set.

    These limitations may be overcome in a future version of Zig.

    Error Return Traces show all the points in the code that an error was returned to the calling function. This makes it practical to use everywhere and then still be able to know what happened if an error ends up bubbling all the way out of your application.

    test.zig

    1. pub fn main() !void {
    2.     try foo(12);
    3. }
    5. fn foo(x: i32) !void {
    6.     if (x >= 5) {
    7.         try bar();
    8.     } else {
    9.         try bang2();
    10.     }
    11. }
    13. fn bar() !void {
    14.     if (baz()) {
    15.         try quux();
    16.     } else |err| switch (err) {
    17.         error.FileNotFound => try hello(),
    18.         else => try another(),
    19.     }
    20. }
    22. fn baz() !void {
    23.     try bang1();
    24. }
    26. fn quux() !void {
    27.     try bang2();
    28. }
    30.     try bang2();
    31. }
    33. fn another() !void {
    34.     try bang1();
    35. }
    37. fn bang1() !void {
    38.     return error.FileNotFound;
    39. }
    41. fn bang2() !void {
    42.     return error.PermissionDenied;
    43. }

    Shell

    1. $ zig build-exe test.zig
    3. $ ./test
    4. error: PermissionDenied
    5. /home/andy/Downloads/zig/docgen_tmp/test.zig:39:5: 0x234a02 in bang1 (test)
    6.     return error.FileNotFound;
    7.     ^
    8. /home/andy/Downloads/zig/docgen_tmp/test.zig:23:5: 0x2348df in baz (test)
    9.     try bang1();
    10.     ^
    11. /home/andy/Downloads/zig/docgen_tmp/test.zig:43:5: 0x2348a2 in bang2 (test)
    12.     return error.PermissionDenied;
    13.     ^
    14. /home/andy/Downloads/zig/docgen_tmp/test.zig:31:5: 0x2349cf in hello (test)
    15.     try bang2();
    16.     ^
    17. /home/andy/Downloads/zig/docgen_tmp/test.zig:17:31: 0x23486e in bar (test)
    18.         error.FileNotFound => try hello(),
    19.                               ^
    20. /home/andy/Downloads/zig/docgen_tmp/test.zig:7:9: 0x23475c in foo (test)
    21.         try bar();
    22.         ^
    23. /home/andy/Downloads/zig/docgen_tmp/test.zig:2:5: 0x22d054 in main (test)
    24.     try foo(12);
    25.     ^

    Look closely at this example. This is no stack trace.

    You can see that the final error bubbled up was PermissionDenied, but the original error that started this whole thing was FileNotFound. In the bar function, the code handles the original error code, and then returns another one, from the switch statement. Error Return Traces make this clear, whereas a stack trace would look like this:

    test.zig

    1. pub fn main() void {
    2.     foo(12);
    3. }
    5. fn foo(x: i32) void {
    6.     if (x >= 5) {
    7.         bar();
    8.     } else {
    9.         bang2();
    10.     }
    11. }
    13. fn bar() void {
    14.     if (baz()) {
    15.         quux();
    16.     } else {
    17.         hello();
    18.     }
    19. }
    21. fn baz() bool {
    22.     return bang1();
    23. }
    25. fn quux() void {
    26.     bang2();
    27. }
    29. fn hello() void {
    30.     bang2();
    31. }
    33. fn bang1() bool {
    34.     return false;
    35. }
    37. fn bang2() void {
    38.     @panic("PermissionDenied");
    39. }

    Shell

    1. $ zig build-exe test.zig
    3. $ ./test
    4. thread 794855 panic: PermissionDenied
    5. /home/andy/Downloads/zig/docgen_tmp/test.zig:38:5: 0x235876 in bang2 (test)
    6.     @panic("PermissionDenied");
    7.     ^
    8. /home/andy/Downloads/zig/docgen_tmp/test.zig:30:10: 0x235fc8 in hello (test)
    9.     bang2();
    10.          ^
    11. /home/andy/Downloads/zig/docgen_tmp/test.zig:17:14: 0x23585a in bar (test)
    12.         hello();
    13.              ^
    14. /home/andy/Downloads/zig/docgen_tmp/test.zig:7:12: 0x2344d5 in foo (test)
    15.         bar();
    16.            ^
    17. /home/andy/Downloads/zig/docgen_tmp/test.zig:2:8: 0x22ce3d in main (test)
    18.     foo(12);
    19.        ^
    20. /home/andy/Downloads/zig/lib/std/start.zig:543:22: 0x225bcc in std.start.callMain (test)
    21.             root.main();
    22.                      ^
    23. /home/andy/Downloads/zig/lib/std/start.zig:495:12: 0x206fce in std.start.callMainWithArgs (test)
    24.     return @call(.{ .modifier = .always_inline }, callMain, .{});
    25.            ^
    26. /home/andy/Downloads/zig/lib/std/start.zig:409:17: 0x206066 in std.start.posixCallMainAndExit (test)
    27.     std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
    28.                 ^
    29. /home/andy/Downloads/zig/lib/std/start.zig:322:5: 0x205e72 in std.start._start (test)
    30.     @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    31.     ^
    32. (process terminated by signal)

    Here, the stack trace does not explain how the control flow in bar got to the hello() call. One would have to open a debugger or further instrument the application in order to find out. The error return trace, on the other hand, shows exactly how the error bubbled up.

    This debugging feature makes it easier to iterate quickly on code that robustly handles all error conditions. This means that Zig developers will naturally find themselves writing correct, robust code in order to increase their development pace.

    Error Return Traces are enabled by default in Debug and builds and disabled by default in ReleaseFast and builds.

    There are a few ways to activate this error return tracing feature:

    • Return an error from main
    • An error makes its way to catch unreachable and you have not overridden the default panic handler
    • Use errorReturnTrace to access the current return trace. You can use std.debug.dumpStackTrace to print it. This function returns comptime-known when building without error return tracing support.

    To analyze performance cost, there are two cases:

    • when no errors are returned
    • when returning errors

    For the case when no errors are returned, the cost is a single memory write operation, only in the first non-failable function in the call graph that calls a failable function, i.e. when a function returning void calls a function returning error. This is to initialize this struct in the stack memory:

    stack_trace_struct.zig

    1. pub const StackTrace = struct {
    2.     index: usize,
    3.     instruction_addresses: [N]usize,

    Here, N is the maximum function call depth as determined by call graph analysis. Recursion is ignored and counts for 2.

    A pointer to StackTrace is passed as a secret parameter to every function that can return an error, but it’s always the first parameter, so it can likely sit in a register and stay there.

    That’s it for the path when no errors occur. It’s practically free in terms of performance.

    When generating the code for a function that returns an error, just before the return statement (only for the statements that return errors), Zig generates a call to this function:

    zig_return_error_fn.zig

    The cost is 2 math operations plus some memory reads and writes. The memory accessed is constrained and should remain cached for the duration of the error return bubbling.