Option

Option module: operations on Option(a) = Some(a) None

All functions are pure. The type Option(a) is a builtin with constructors Some and None.

Functions

fnexpectexpect(opt : {Option(a) | is_Some(_)}, msg : String) : a#

Extracts the value from Some(x), panicking with the given message if None. Use when you are certain the option is Some.

The panic message is prefixed with the module name and on None so it is clearly attributable when it shows up in a stack trace (Option.expect on None: <msg>).

Examples

march> Option.expect(Some(3), "config must have a port")
3

fnfilterfilter(opt : Option(a), pred : a -> Bool[p]) : Option(a[p])#

Returns None if the value does not satisfy pred, otherwise the option unchanged. A Some result is known to satisfy pred (an abstract refinement p, as for List.filter).

Examples

march> Option.filter(Some(4), fn x -> x % 2 == 0)
Some(4)
march> Option.filter(Some(3), fn x -> x % 2 == 0)
None

fnflat_mapflat_map(opt : Option(a), f : a -> Option(b)) : Option(b)#

Applies f (which itself returns an Option) and flattens the result. Use it to chain steps that can each fail.

Examples

march> Option.flat_map(Some(10), fn n -> if n > 0 do Some(100 / n) else None end)
Some(10)
march> Option.flat_map(Some(0), fn n -> if n > 0 do Some(100 / n) else None end)
None
march> Option.flat_map(None, fn n -> if n > 0 do Some(100 / n) else None end)
None

fnis_noneis_none(opt : Option(a)) : Bool#

Returns true if the option is None.

march> Option.is_none(None)
true

march> Option.is_none(Some(0))
false

fnis_someis_some(opt : Option(a)) : Bool#

Returns true if the option contains a value.

march> Option.is_some(Some(42))
true

march> Option.is_some(None)
false

fnmapmap(opt : Option(a), f : a -> b) : Option(b)#

Applies f to the contained value, or returns None.

Examples

march> Option.map(Some(2), fn x -> x * 10)
Some(20)
march> Option.map(None, fn x -> x * 10)
None

fnor_elseor_else(opt : Option(a), f : () -> Option(a)) : Option(a)#

Returns f() if None, or the original Some value (without calling f).

Examples

march> Option.or_else(Some(1), fn -> Some(2))
Some(1)
march> Option.or_else(None, fn -> Some(2))
Some(2)

fnto_listto_list(opt : Option(a)) : List(a)#

Converts Option(a) to a List: Some(x) becomes [x], None becomes [].

Examples

march> Option.to_list(Some(7))
[7]
march> Option.to_list(None)
[]

fnto_resultto_result(opt : Option(a), err : e) : Result(a, e)#

Converts Option(a) to Result(a, e): Some(x) becomes Ok(x), None becomes Err(err).

Examples

march> Option.to_result(Some(1), "missing")
Ok(1)
march> Option.to_result(None, "missing")
Err("missing")

fnunwrapunwrap(opt : {Option(a) | is_Some(_)}) : a#

Extracts the value from Some(x), panicking if None.

march> Option.unwrap(Some(42))
42

march> Option.unwrap(None)
** panic: Option.unwrap called on None

fnunwrap_orunwrap_or(opt : Option(a), default : a) : a#

Returns the contained value, or default if None.

march> Option.unwrap_or(Some(7), 0)
7

march> Option.unwrap_or(None, 99)
99

fnunwrap_or_elseunwrap_or_else(opt : Option(a), f : () -> a) : a#

Returns the contained value, or calls f to produce a default. f is only called when the option is None, so it can do work you want to skip on Some.

Examples

march> Option.unwrap_or_else(Some(5), fn -> 0)
5
march> Option.unwrap_or_else(None, fn -> 2 * 21)
42

fnzipzip(oa : Option(a), ob : Option(b)) : Option((a, b))#

Combines two Options into a tuple Option, returning None if either is None.

Examples

march> Option.zip(Some(1), Some("a"))
Some((1, "a"))
march> Option.zip(Some(1), None)
None