A Little Panic in Zig

In Rust there are several ways to handle errors that come from the Result and Option types. A common way to get the inner value is using the unwrap method that either returns the value or panics the program. So how would we implement this function in Zig? Well there are several methods of handling errors in Zig, to keep ours simple we will use an if/else statement.

Let's start with by creating a file called unwrap.zig, and import the standard library and assign it to the constant std.

// unwrap.zig 
const std = @import("std");

We will be using compile time generics in our function, you may also use function type inference if you'd like.

What we expect is a type for our generic T, and an error set in the form anyerror!T where we will return the value T.

pub fn unwrap(comptime T: type, val: anyerror!T) T {}

Inside of the function we will use an if/else statement where the if statement will handle a successful value and the else statement handles the error. In these statements we will need to capture the values using the | | syntax as shown:

if(val) |value|{
   return value;
} else |err|{
   std.debug.panic("Panicked at Error: {any}",.{err});
}

As you can see in our if block we return the successful value we capture as the variable value, while in the else block, we capture the error as the variable err and print it using std.debug.panic.

To test out our function, I have create an error type called MathError with one field called DivideByZero. This is similar to an enum implementing the Error trait in Rust.

const MathError = error{
    DivideByZero
};

Now we can create a function called divide which checks if the denominator is zero, and if it is we return the divide by zero error.

fn divide(comptime T: type, a: T, b: T) MathError!T{
    if (b == 0){
        return MathError.DivideByZero;
    } else {
        return a / b;
    }
}

Lastly we will create our main function where we will try this with a successful result and a result doomed to panic.

If we run our program we get the following result:

$ zig build-exe unwrap.zig 
$ ./unwrap
Result: 6.71641826e-01
thread 52729 panic: Panicked at Error: error.DivideByZero
...

This article was just a fun experiment to try something I use in Rust and try it in Zig. Like in Rust, panicking isn't a good way to handle errors, and in most cases the try keyword in Zig is enough.