Error Handling

Result Type

Functions that can fail return Result<T, E>:

fn safe_div(a: int, b: int) -> Result<int, string> {
    if b == 0 { return Err("division by zero") }
    return Ok(a / b)
}

Matching on Results

match safe_div(10, 3) {
    Ok(v) => println("result: ${v}")
    Err(e) => println("error: ${e}")
}

The ? Operator

Propagate errors automatically with ?. If the expression is Err, the function returns early with that error:

fn parse(s: string) -> Result<int, string> {
    if s == "42" { return Ok(42) }
    return Err("parse error")
}

fn validate(n: int) -> Result<int, string> {
    if n < 0 { return Err("negative") }
    return Ok(n)
}

fn process(s: string) -> Result<string, string> {
    var n = parse(s)?          // returns Err early if parse fails
    var valid = validate(n)?   // returns Err early if validate fails
    return Ok("processed: ${valid}")
}

Result with String Values

fn read_config(path: string) -> Result<string, string> {
    if path == "" { return Err("empty path") }
    return Ok("config data")
}

fn load(path: string) -> Result<string, string> {
    var data = read_config(path)?
    return Ok("loaded: ${data}")
}

Option Type

For values that may or may not exist:

fn find(arr: [int], target: int) -> Option<int> {
    for i in 0..arr.len() {
        if arr[i] == target { return Some(i) }
    }
    return None
}

match find([10, 20, 30], 20) {
    Some(idx) => println("found at index ${idx}")
    None => println("not found")
}

See Also

• Enums — Result and Option are enum types
• Pattern Matching — match on Result/Option
• Functions — return types and error propagation