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?(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?(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(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(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(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.to_string

impl Display

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

impl Display.to_string

Maybe.equal?

impl Equatable

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

impl Equatable.equal?

Maybe.hash

impl Hashable

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

impl Hashable.hash

Maybe.inspect

impl Debug

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

impl Debug.inspect