Skip to main content

Result Methods

Results in Oxide use Rust's standard Result<T, E> methods directly. Oxide's case conversion automatically translates camelCase method calls to Rust's snake_case equivalents.

Methods​

MethodRust EquivalentDescription
isOk()is_ok()Returns true if Ok
isErr()is_err()Returns true if Err
unwrapOr(default)unwrap_or(default)Returns value or default
map(f)map(f)Transforms Ok value
mapErr(f)map_err(f)Transforms Err value
ok()ok()Converts to Option, discards error
err()err()Gets error as Option
andThen(f)and_then(f)Chains result-returning functions

Examples​

Checking Status​

let ok: Result<Int, String> = Ok(42)
let err: Result<Int, String> = Err("error")

ok.isOk()      // true
ok.isErr()     // false

err.isOk()     // false
err.isErr()    // true

Unwrap with Default​

let ok: Result<Int, String> = Ok(42)
let err: Result<Int, String> = Err("failed")

// Using ?? operator
ok ?? 0        // 42
err ?? 0       // 0

// Using method
ok.unwrapOr(0)     // 42
err.unwrapOr(0)    // 0

Mapping Values​

let result: Result<Int, String> = Ok(21)

// Transform Ok value
let doubled = result.map { it * 2 }   // Ok(42)

// Chain mappings
let processed = result
    .map { it * 2 }
    .map { "Value: $it" }   // Ok("Value: 42")

Mapping Errors​

let err: Result<Int, String> = Err("not found")

// Transform error type
let mapped = err.mapErr { MyError.NotFound(it) }

Converting to Option​

let ok: Result<Int, String> = Ok(42)
let err: Result<Int, String> = Err("failed")

// Get Ok value as Option
ok.ok()      // Some(42)
err.ok()     // None

// Get Err value as Option
ok.err()     // None
err.err()    // Some("failed")

Pattern Matching​

let result = fetchData()

match result {
    Ok(data) -> process(data)
    Err(error) -> handleError(error)
}

Integration with throws​

Functions That Throw​

fn parseNumber(s: String) throws: Int {
    if s.isEmpty() {
        throw "Empty string"
    }
    s.parse<Int>().unwrap()
}

Using try Variants​

// Propagate errors
fn process() throws: Int {
    let n = try parseNumber("42")
    n * 2
}

// Convert to Option
let result: Int? = try? parseNumber("42")

// Force unwrap (panics on error)
let value: Int = try! parseNumber("42")

Do-Catch Blocks​

do {
    let value = try parseNumber(input)
    process(value)
} catch {
    println!("Error: $error")
}

Comparison with Rust​

OxideRust
r.isOk()r.is_ok()
r.isErr()r.is_err()
r ?? defaultr.unwrap_or(default)
r.unwrapOr(d)r.unwrap_or(d)
r.map(f)r.map(f)
r.mapErr(f)r.map_err(f)
r.ok()r.ok()
r.err()r.err()
r.andThen(f)r.and_then(f)
try exprexpr?
try? exprexpr.ok()
try! exprexpr.unwrap()

Common Patterns​

Result Chaining​

fn processFile(path: String) throws: Data {
    let content = try readFile(path)
    let parsed = try parseContent(content)
    let validated = try validate(parsed)
    validated
}

Converting Result to Option​

// When you only care about success
let maybeValue = result.ok()

// Use with null coalescing
let value = result.ok() ?? defaultValue

Combining Results​

fn loadConfig() throws: Config {
    let file1 = try readFile("config1.toml")
    let file2 = try readFile("config2.toml")
    mergeConfigs(file1, file2)
}

Error Recovery​

let result = fetchPrimary()
    .orElse { fetchFallback() }
    .orElse { Ok(defaultValue()) }

Custom Error Types​

@[derive(Debug)]
enum AppError {
    case network(message: String)
    case parse(line: Int)
    case notFound
}

fn fetchData() throws: Data {
    let response = try? http.get(url)
    guard let r = response else {
        throw AppError.network(message = "Connection failed")
    }

    if r.status == 404 {
        throw AppError.notFound
    }

    try parseResponse(r)
}

Additional Rust Methods​

Since Oxide uses Rust's Result methods directly, you can use any method from Rust's standard library:

let result: Result<Int, String> = Ok(42)

// Check methods
result.isOk()                   // true
result.isErr()                  // false

// Unwrap variants
result.unwrap()                 // 42 (panics if Err)
result.unwrapErr()              // panics (expects Err)
result.expect("failed")         // 42 (panics with message if Err)

// Logical operations
let other: Result<Int, String> = Ok(100)
result.or(other)                // Ok(42) - returns result if Ok
result.and(other)               // Ok(100) - returns other if both Ok

// Contains
result.contains(42)             // true

See Also​