Error Handling

Result Type

Functions that can fail return ResultInt:

fn safe_div(a: int, b: int) -> ResultInt {
    if b == 0 { return Err("divide by zero") }
    return Ok(a / b)
}

Checking Results

var result = safe_div(10, 2)
println(result.to_string())            // Ok(5)

var err = safe_div(10, 0)
println(err.to_string())               // Err(divide by zero)

Unwrapping

var result = safe_div(10, 2)
var value = result.unwrap_or(0)         // 5

var err = safe_div(10, 0)
var fallback = err.unwrap_or(-1)        // -1

The ? Operator

The ? operator propagates errors automatically. If the result is Err, the function returns early with that error. If Ok, it unwraps the value.

fn compute() -> ResultInt {
    var a = safe_div(10, 2)?    // 5 — unwrapped from Ok(5)
    var b = safe_div(a, 2)?     // 2 — unwrapped from Ok(2)
    return Ok(a + b)            // Ok(7)
}

fn will_fail() -> ResultInt {
    var x = safe_div(10, 0)?    // returns Err("divide by zero") immediately
    return Ok(x)                // never reached
}

println(compute().to_string())      // Ok(7)
println(will_fail().to_string())    // Err(divide by zero)

TIP

The ? operator can only be used inside functions that return ResultInt.

Pattern Matching on Results

var result = safe_div(10, 3)
match result {
    Ok(v) => println("got: " + v.to_string())
    Err(e) => println("error: " + e)
}

Option Type

For values that may or may not exist:

var some: OptionInt = Some(42)
var none: OptionInt = None

println(some.is_some().to_string())     // true
println(none.is_none().to_string())     // true
println(some.unwrap_or(0).to_string())  // 42
println(none.unwrap_or(99).to_string()) // 99