package containers

map f o applies the function f to the element inside o, if any.

map_or ~default f o is f x if o = Some x, default otherwise.

• since 0.16

map_lazy default_fn f o if f o if o = Some x, default_fn () otherwise.

• since 1.2

is_some (Some x) returns true otherwise it returns false.

is_none None returns true otherwise it returns false.

• since 0.11

compare comp o1 o2 compares two options o1 and o2, using custom comparators comp for the value. None is always assumed to be less than Some _.

equal p o1 o2 tests for equality between option types o1 and o2, using a custom equality predicate p.

return x is a monadic return, that is return x = Some x.

o >|= f is the infix version of map.

flat_map f o is equivalent to map followed by flatten. Flip version of >>=.

bind o f is f v if o is Some v, None otherwise. Monadic bind.

• since 3.0

o >>= f is the infix version of bind.

map2 f o1 o2 maps 'a option and 'b option to a 'c option using f.

iter f o applies f to o. Iterate on 0 or 1 element.

fold f init o is f init x if o is Some x, or init if o is None. Fold on 0 or 1 element.

filter f o returns Some x if f (Some x) is true, or None if f (Some x) is false or if o is None. Filter on 0 or 1 element.

• since 0.5

if_ f x is Some x if f x, None otherwise.

• since 0.17

exists f o returns true iff there exists an element for which the provided function f evaluates to true.

• since 0.17

for_all f o returns true iff the provided function f evaluates to true for all elements.

• since 0.17

get_or ~default o extracts the value from o, or returns default if o is None.

• since 0.18

value o ~default is similar to the Stdlib's Option.value and to get_or.

• since 2.8

get_exn o returns x if o is Some x or fails if o is None.

• raises Invalid_argument

  if the option is None.

get_lazy default_fn o unwraps o, but if o is None it returns default_fn () instead.

• since 0.6.1

sequence_l [x1; x2; …; xn] returns Some [y1; y2; …; yn] if every xi is Some yi. Otherwise, if the list contains at least one None, the result is None.

wrap ?handler f x calls f x and returns Some y if f x = y. If f x raises any exception, the result is None. This can be useful to wrap functions such as Map.S.find.

• parameter handler

  the exception handler, which returns true if the exception is to be caught.

wrap2 ?handler f x y is similar to wrap but for binary functions.

pure x is an alias to return.

f <*> (Some x) returns Some (f x) and f <*> None returns None.

f <$> o is like map f o.

or_ ~else_ o is o if o is Some _, else_ if o is None.

• since 1.2

or_lazy ~else_ o is o if o is Some _, else_ () if o is None.

• since 1.2

o1 <+> o2 is o1 if o1 is Some _, o2 if o1 is None.

choice lo returns the first non-None element of the list lo, or None.

flatten oo transforms Some x into x.

• since 2.2

return_if b x applies Some or None depending on the boolean b. More precisely, return_if false x is None, and return_if true x is Some x.

• since 2.2

to_list o returns [x] if o is Some x or the empty list [] if o is None.

of_list l returns Some x (x being the head of the list l), or None if l is the empty list.

to_result e o returns Ok x if o is Some x, or Error e if o is None.

• since 1.2

to_result_lazy f o returns Ok x if o is Some x or Error f if o is None.

• since 1.2

of_result result returns an option from a result.

• since 1.2

choice_iter iter is similar to choice, but works on iter. It returns the first Some x occurring in iter, or None otherwise.

• since 3.0

choice_seq seq works on Seq.t. It returns the first Some x occurring in seq, or None otherwise.

• since 3.0

to_gen o is o as a gen. Some x is the singleton gen containing x and None is the empty gen.

to_seq o is o as a sequence Seq.t. Some x is the singleton sequence containing x and None is the empty sequence. Same as Stdlib.Option.to_seq Renamed from to_std_seq since 3.0.

• since 3.0

to_iter o returns an internal iterator, like in the library Iter.

• since 2.8

pp ppf o pretty-prints option o using ppf.