moresult

A collection of ergonomic utility functions for working with Result types.

This package provides helpful combinators and transformations to make error handling in Gleam more expressive and concise.

Values

and

</>

pub fn and(
  first: Result(a, e),
  second: Result(b, e),
) -> Result(b, e)

Returns second if the first is Ok, otherwise returns the Error value of first.

either

</>

pub fn either(
  result: Result(a, e),
  on_ok: fn(a) -> b,
  on_error: fn(e) -> b,
) -> b

Case analysis for the Result type. If the value is Ok, apply the first function; if it is Error, apply the second function.

error

</>

pub fn error(result: Result(a, e)) -> option.Option(e)

Converts Result(a, e) into an Option(e) and discarding the success value, if any.

errors

</>

pub fn errors(results: List(Result(a, e))) -> List(e)

Extracts from a list of Result all Error elements. All the Error elements extracts in order.

from_either

</>

pub fn from_either(result: Result(a, a)) -> a

Pull the value out of an Result where both alternatives have the same type.

inspect

</>

pub fn inspect(
  result: Result(a, e),
  func: fn(a) -> Nil,
) -> Result(a, e)

Calls a function with contained value if Ok. Returns the original result.

inspect_err

</>

pub fn inspect_err(
  result: Result(a, e),
  func: fn(e) -> Nil,
) -> Result(a, e)

is_error_and

</>

pub fn is_error_and(
  result: Result(a, e),
  predicate: fn(e) -> Bool,
) -> Bool

Returns true if the result is Error and the value inside of it matches a predicate.

is_ok_and

</>

pub fn is_ok_and(
  result: Result(a, e),
  predicate: fn(a) -> Bool,
) -> Bool

Returns true if the result is Ok and the value inside of it matches a predicate.

lazy_unwrap_error

</>

pub fn lazy_unwrap_error(
  result: Result(a, e),
  default: fn() -> e,
) -> e

Extracts the Error value from a result, evaluating the default function if the result is an Error.

map_or

</>

pub fn map_or(
  result: Result(a, e),
  default: b,
  fun: fn(a) -> b,
) -> b

Returns the provided default (if Error), or applies a function to the contained value (if Ok). Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use map_or_else, which is lazily evaluated.

map_or_else

</>

pub fn map_or_else(
  result: Result(a, e),
  default: fn() -> b,
  fun: fn(a) -> b,
) -> b

Maps a Result(a, e) to a by applying fallback function default to a contained Error value, or function fun to a contained Ok value.

ok

</>

pub fn ok(result: Result(a, e)) -> option.Option(a)

Converts Result(a, e) into an Option(a) and converting the error to None, if any.