CCOpt
val map_or : default:'b -> ('a -> 'b) -> 'a t -> 'b
map_or ~default f o
is f x
if o = Some x
, default
otherwise.
val map_lazy : (unit -> 'b) -> ('a -> 'b) -> 'a t -> 'b
map_lazy default_fn f o
if f o
if o = Some x
, default_fn ()
otherwise.
val is_some : _ t -> bool
is_some (Some x)
returns true
otherwise it returns false
.
val is_none : _ t -> bool
is_none None
returns true
otherwise it returns false
.
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
.
val return : 'a -> 'a t
return x
is a monadic return, that is return x = Some x
.
bind o f
is f v
if o
is Some v
, None
otherwise. Monadic bind.
map2 f o1 o2
maps 'a option
and 'b option
to a 'c option
using f
.
val iter : ('a -> unit) -> 'a t -> unit
iter f o
applies f
to o
. Iterate on 0 or 1 element.
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
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 o
is Some x
and f x
is true
, or None
if f x
is false
or if o
is None
. Filter on 0 or 1 element.
val exists : ('a -> bool) -> 'a t -> bool
exists f o
returns true
iff there exists an element for which the provided function f
evaluates to true
.
val for_all : ('a -> bool) -> 'a t -> bool
for_all f o
returns true
iff the provided function f
evaluates to true
for all elements.
val get_or : default:'a -> 'a t -> 'a
get_or ~default o
extracts the value from o
, or returns default
if o
is None
.
val value : 'a t -> default:'a -> 'a
value o ~default
is similar to the Stdlib's Option.value
and to get_or
.
val get_exn : 'a t -> 'a
get_exn o
returns x
if o
is Some x
or fails if o
is None
.
val get_lazy : (unit -> 'a) -> 'a t -> 'a
get_lazy default_fn o
unwraps o
, but if o
is None
it returns default_fn ()
instead.
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
.
wrap2 ?handler f x y
is similar to wrap
but for binary functions.
f <*> (Some x)
returns Some (f x)
and f <*> None
returns None
.
or_lazy ~else_ o
is o
if o
is Some _
, else_ ()
if o
is None
.
val return_if : bool -> 'a -> 'a t
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
.
module Infix : sig ... end
Let operators on OCaml >= 4.08.0, nothing otherwise
include CCShimsMkLet_.S with type 'a t_let := 'a option
val to_list : 'a t -> 'a list
to_list o
returns [x]
if o
is Some x
or the empty list []
if o
is None
.
val of_list : 'a list -> 'a t
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
.
to_result_lazy f o
returns Ok x
if o
is Some x
or Error f
if o
is None
.
type 'a printer = Format.formatter -> 'a -> unit
type 'a random_gen = Random.State.t -> 'a
val random : 'a random_gen -> 'a t random_gen
choice_iter iter
is similar to choice
, but works on iter
. It returns the first Some x
occurring in iter
, or None
otherwise.
choice_seq seq
works on Seq.t
. It returns the first Some x
occurring in seq
, or None
otherwise.
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.