25 / Types and patterns

Result: Ok and Err

Result is Nyx's idiomatic type for operations that can fail with an error message. A function returns Result.Ok(value) when it succeeds and Result.Err(message) when something goes wrong — making error handling explicit and impossible to accidentally ignore.

25-result-ok-err.nxSource →

// Result: función que retorna Ok o Err, match exhaustivo para manejar ambos

enum Result {
    Ok(int),
    Err(String)
}

fn safe_divide(a: int, b: int) -> Result {
    if b == 0 {
        return Result.Err("division por cero")
    }
    return Result.Ok(a / b)
}

fn safe_sqrt(n: int) -> Result {
    if n < 0 {
        return Result.Err("raiz de negativo")
    }
    var i: int = 0
    while i * i <= n {
        i = i + 1
    }
    return Result.Ok(i - 1)
}

fn describe(r: Result) -> String {
    return match r {
        Result.Ok(v)  => "ok: " + int_to_string(v),
        Result.Err(e) => "error: " + e
    }
}

fn main() -> int {
    let r1: Result = safe_divide(100, 4)
    print(describe(r1))

    let r2: Result = safe_divide(10, 0)
    print(describe(r2))

    let r3: Result = safe_sqrt(16)
    print(describe(r3))

    let r4: Result = safe_sqrt(-5)
    print(describe(r4))

    return 0
}

Outputstdout

ok: 25
error: division por cero
ok: 4
error: raiz de negativo

How it works

Result is a regular enum with two variants. In this example it is defined locally with Ok(int) and Err(String), but in real Nyx programs you typically use the generic Result<T, E> from the prelude. Either way the pattern is identical: return one variant on success, the other on failure, and let the caller decide what to do.

safe_divide guards against division by zero before performing the operation. safe_sqrt uses a manual integer loop to compute floor square roots without floating-point arithmetic, returning an error for negative inputs. Both functions communicate failure through the type system rather than exceptions or out-of-band error codes.

The describe helper matches exhaustively on both variants. The compiler enforces that every variant is handled — if you add a third variant to the enum later, every existing match site becomes a compile error until you handle the new case. This exhaustiveness check is one of the most powerful safety properties of algebraic types.

All recipes The step-by-step guide