Result

Functions for working with Result<T, E> (Ok(v) / Err(e)) values.

Functions

Function	Signature	Description
Result.map	(Result<T, E>, (T) -> U) -> Result<U, E>	Transform the Ok value
Result.mapErr	(Result<T, E>, (E) -> F) -> Result<T, F>	Transform the Err value
Result.flatMap	(Result<T, E>, (T) -> Result<U, E>) -> Result<U, E>	Chain result-returning operations
Result.unwrapOr	(Result<T, E>, T) -> T	Extract Ok value or use default
Result.isOk	(Result<T, E>) -> boolean	Check if result is Ok
Result.isErr	(Result<T, E>) -> boolean	Check if result is Err
Result.toOption	(Result<T, E>) -> Option<T>	Convert to Option (drops error)
Result.filter	(Result<T, E>, (T) -> boolean, E) -> Result<T, E>	Keep Ok if predicate passes, else Err
Result.or	(Result<T, E>, Result<T, E>) -> Result<T, E>	Return first Ok, else second
Result.orElse	(Result<T, E>, (E) -> Result<T, F>) -> Result<T, F>	Lazy fallback chain
Result.values	(Array<Result<T, E>>) -> Array<T>	Extract all Ok values, discard Errs
Result.partition	(Array<Result<T, E>>) -> (Array<T>, Array<E>)	Split into Ok and Err arrays
Result.mapOr	(Result<T, E>, U, (T) -> U) -> U	Map + default in one step
Result.flatten	(Result<Result<T, E>, E>) -> Result<T, E>	Unwrap nested Results
Result.zip	(Result<T, E>, Result<U, E>) -> Result<(T, U), E>	Combine two Results into a tuple
Result.inspect	(Result<T, E>, (T) -> ()) -> Result<T, E>	Side-effect on Ok value
Result.inspectErr	(Result<T, E>, (E) -> ()) -> Result<T, E>	Side-effect on Err value
Result.all	(Array<Result<T, E>>) -> Result<Array<T>, E>	Collect all Ok values, fail on first Err
Result.any	(Array<Result<T, E>>) -> Result<T, Array<E>>	First Ok, or all Errs
Result.guard	(Result<T, E>, (E) -> U, (T) -> U) -> U	Bail with onErr on Err, continue with Ok value (for use)

Examples

// Transform success value
let doubled = fetchCount()
  |> Result.map((n) -> n * 2)

// Handle errors
let result = fetchUser(id)
  |> Result.mapErr((e) -> AppError(e))

// Chain operations
let profile = fetchUser(id)
  |> Result.flatMap((u) -> fetchProfile(u.profileId))

// Extract with fallback
let count = fetchCount()
  |> Result.unwrapOr(0)

// Lazy fallback chain
let data = fetchFromPrimary(id)
  |> Result.orElse((e) -> fetchFromBackup(id))

// Filter — keep Ok only if predicate passes
let validAge = parseAge(input)
  |> Result.filter((n) -> n >= 18, "must be 18+")

// Zip — combine two Results
let pair = Result.zip(fetchUser(id), fetchProfile(id))
// Ok(("Alice", Profile(...))) or first Err

// Collect all Results
let users = [fetchUser(1), fetchUser(2), fetchUser(3)]
  |> Result.all   // Ok([...]) or first Err

// Debug with inspect
let result = fetchUser(id)
  |> Result.inspect((u) -> Console.log("got user", u))
  |> Result.mapErr((e) -> AppError(e))

Guard Pattern

Result.guard combines with use for early returns on errors:

use data <- Result.guard(fetchResult, (e) -> <ErrorPage error={e} />)
<Dashboard data={data} />

See the Callback Flattening & Guards guide for the full pattern.