Error Handling

Dogma uses Result<T, E> for recoverable errors. There are no exceptions.

Returning errors🔗

fn parse_int(s: String) -> Result<i32, String> {
    // ... implementation
    Err(f"cannot parse '{s}' as integer")
}

The ? operator🔗

? unwraps Ok(value) or returns Err(e) from the enclosing function. The function must return Result.

import { println } from "dogma:core"

fn read_and_parse(path: String) -> Result<i32, String> {
    let content = read_file(path)?   // propagates Err if read fails
    let n = parse_int(content)?      // propagates Err if parse fails
    Ok(n)
}

fn main() {
    match read_and_parse("number.txt") {
        Ok(n) => println(f"Number: {n}"),
        Err(e) => println(f"Error: {e}"),
    }
}

try expressions🔗

try { ... } is equivalent to wrapping a block in a closure and applying ?.

let result: Result<i32, String> = try {
    let a = parse_int("10")?
    let b = parse_int("5")?
    a + b
}

match on Result🔗

When you do not want to propagate — handle both arms explicitly:

match divide(10, 0) {
    Ok(n) => println(f"Result: {n}"),
    Err(e) => println(f"Failed: {e}"),
}