std/maybe

Import with import std/maybe.

Exports

Types

• Maybe

enum Maybe

enum Maybe<T> {
    Some T
    None
}

A value that may or may not be present.

Interactive Tests

assert Maybe.Some(42)
  |> case {
      .Some(v) -> v
      .None -> 0
    }
  |> Int.equal?(42)

Maybe.some?

fn some?<T>(maybe: Maybe<T>): Bool

type function on Maybe

Returns True when the value is Some.

Interactive Tests

assert Maybe.some?(Maybe.Some(3))
refute Maybe.some?(Maybe.None)

Maybe.none?

fn none?<T>(maybe: Maybe<T>): Bool

type function on Maybe

Returns True when the value is None.

Interactive Tests

refute Maybe.none?(Maybe.Some(3))
assert Maybe.none?(Maybe.None)

Maybe.map

fn map<T, U>(maybe: Maybe<T>, f: (T) -> U): Maybe<U>

type function on Maybe

Transforms the value inside Some, passes None through.

Interactive Tests

assert Maybe.map(Maybe.Some(3), |x| x * 2) == Maybe.Some(6)
assert Maybe.map(Maybe.None, |x| x * 2) == Maybe.None

Maybe.with_default

fn with_default<T>(maybe: Maybe<T>, default: T): T

type function on Maybe

Returns the value inside Some, or the default if None.

Interactive Tests

assert Maybe.with_default(Maybe.Some(5), 0) == 5
assert Maybe.with_default(Maybe.None, 0) == 0

Maybe.flat_map

fn flat_map<T, U>(maybe: Maybe<T>, f: (T) -> Maybe<U>): Maybe<U>

type function on Maybe

Like map, but the function returns a Maybe. Flattens the result.

Interactive Tests

safe_div = |a: Int, b: Int|
  if b == 0 {
    Maybe.None
  } else {
    Maybe.Some(a / b)
  }
assert Maybe.flat_map(Maybe.Some(10), |x| safe_div(x, 2)) == Maybe.Some(5)
assert Maybe.flat_map(Maybe.Some(10), |x| safe_div(x, 0)) == Maybe.None

Maybe.inspect

fn inspect<T>(value: Maybe<T>): String where T: Debug

impl Debug.inspect

Maybe.to_string

fn to_string<T>(value: Maybe<T>): String where T: Display

impl Display.to_string

Maybe.equal?

fn equal?<T>(a: Maybe<T>, b: Maybe<T>): Bool where T: Equatable

impl Equatable.equal?

Maybe.hash

fn hash<T>(value: Maybe<T>): Int where T: Hashable

impl Hashable.hash