Module Stdlib.Option

Option values.

Option values explicitly indicate the presence or absence of a value.

Options

type t('a) = option('a) =
  1. | None
  2. | Some('a)
;

The type for option values. Either None or a value Some v.

let none: option('a);

none is None.

let some: 'a => option('a);

some v is Some v.

let value: option('a) => default:'a => 'a;

value o ~default is v if o is Some v and default otherwise.

let get: option('a) => 'a;

get o is v if o is Some v and raise otherwise.

let bind: option('a) => ('a => option('b)) => option('b);

bind o f is f v if o is Some v and None if o is None.

let join: option(option('a)) => option('a);

join oo is Some v if oo is Some (Some v) and None otherwise.

let map: ('a => 'b) => option('a) => option('b);

map f o is None if o is None and Some (f v) if o is Some v.

let product: option('a) => option('b) => option(('a, 'b));

product o0 o1 is Some (v0, v1) if o0 is Some v0 and o1 is Some v1 and None otherwise.

  • since 5.5
let fold: none:'a => some:('b => 'a) => option('b) => 'a;

fold ~none ~some o is none if o is None and some v if o is Some v.

let iter: ('a => unit) => option('a) => unit;

iter f o is f v if o is Some v and () otherwise.

let blend: ('a => 'a => 'a) => option('a) => option('a) => option('a);

blend f o1 o2 is o1 if o2 is None, o2 if o1 is None, and Some (f v1 v2) if o1 is Some v1 and o2 is Some v2.

  • since 5.5
let for_all: ('a => bool) => option('a) => bool;

for_all p behaves like List.for_all p on a list of zero or one element:

  • for_all p None is true,
  • for_all p (Some v) is p v.
  • since 5.5
let exists: ('a => bool) => option('a) => bool;

exists p behaves like List.exists p on a list of zero or one element:

  • exists p None is false,
  • exists p (Some v) is p v.
  • since 5.5

Predicates and comparisons

let is_none: option('a) => bool;

is_none o is true if and only if o is None.

let is_some: option('a) => bool;

is_some o is true if and only if o is Some o.

let equal: ('a => 'a => bool) => option('a) => option('a) => bool;

equal eq o0 o1 is true if and only if o0 and o1 are both None or if they are Some v0 and Some v1 and eq v0 v1 is true.

let compare: ('a => 'a => int) => option('a) => option('a) => int;

compare cmp o0 o1 is a total order on options using cmp to compare values wrapped by Some _. None is smaller than Some _ values.

Converting

let to_result: none:'e => option('a) => result('a, 'e);

to_result ~none o is Ok v if o is Some v and Error none otherwise.

let to_list: option('a) => list('a);

to_list o is [] if o is None and [v] if o is Some v.

let to_seq: option('a) => Seq.t('a);

to_seq o is o as a sequence. None is the empty sequence and Some v is the singleton sequence containing v.

Syntax

module Syntax: { ... };

Binding operators. See manual section 12.23 for details.