Core.Option
SourceThis module extends Base.Option
with bin_io, quickcheck, and support for ppx_optional.
include Bin_prot.Binable.S_local1 with type 'a t := 'a t
include Typerep_lib.Typerepable.S1 with type 'a t := 'a t
val typerep_of_t :
'a Typerep_lib.Std_internal.Typerep.t ->
'a t Typerep_lib.Std_internal.Typerep.t
val hash_fold_t :
(Base.Hash.state -> 'a -> Base.Hash.state) ->
Base.Hash.state ->
'a option ->
Base.Hash.state
include Base.Equal.S1 with type 'a t := 'a option
include Base.Invariant.S1 with type 'a t := 'a option
Options form an applicative, where:
return x = Some x
None <*> x = None
Some f <*> None = None
Some f <*> Some x = Some (f x)
Options form a monad, where:
return x = Some x
(None >>= f) = None
(Some x >>= f) = f x
include Base.Monad.S_local with type 'a t := 'a option
t >>= f
returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t
to yield a value v
, and then runs the computation returned by f v
.
t >>| f
is t >>= (fun a -> return (f a))
.
bind t ~f
= t >>= f
return v
returns the (trivial) computation that returns v.
map t ~f
is t >>| f.
join t
is t >>= (fun t' -> t')
.
ignore_m t
is map t ~f:(fun _ -> ())
. ignore_m
used to be called ignore
, but we decided that was a bad name, because it shadowed the widely used Stdlib.ignore
. Some monads still do let ignore = ignore_m
for historical reasons.
Like all
, but ensures that every monadic value in the list produces a unit value, all of which are discarded rather than being collected into a list.
Extracts the underlying value if present, otherwise returns default
.
val value_exn :
?here:Lexing.position ->
?error:Base.Error.t ->
?message:string ->
'a option ->
'a
Extracts the underlying value, or raises if there is no value present. The error raised can be augmented using the ~here
, ~error
, and ~message
optional arguments.
Extracts the underlying value and applies f
to it if present, otherwise returns default
.
Extracts the underlying value if present, otherwise executes and returns the result of default
. default
is only executed if the underlying value is absent.
On None
, returns init
. On Some x
, returns f init x
.
Checks whether the provided element is there, using equal
.
On None
, returns false
. On Some x
, returns f x
.
On None
, returns true
. On Some x
, returns f x
.
find t ~f
returns t
if t = Some x
and f x = true
; otherwise, find
returns None
.
On None
, returns None
. On Some x
, returns f x
.
call x f
runs an optional function ~f
on the argument.
merge a b ~f
merges together the values from a
and b
using f
. If both a
and b
are None
, returns None
. If only one is Some
, returns that one, and if both are Some
, returns Some
of the result of applying f
to the contents of a
and b
.
try_with f
returns Some x
if f
returns x
and None
if f
raises an exception. See Result.try_with
if you'd like to know which exception.
try_with_join f
returns the optional value returned by f
if it exits normally, and None
if f
raises an exception.
Wraps the Some
constructor as a function.
first_some t1 t2
returns t1
if it has an underlying value, or t2
otherwise.
some_if b x
converts a value x
to Some x
if b
, and None
otherwise.
is_none t
returns true iff t = None
.
is_some t
returns true iff t = Some x
.
include Comparator.Derived with type 'a t := 'a t
val comparator :
('a, 'cmp) Base.Comparator.comparator ->
('a t, 'cmp comparator_witness) Base.Comparator.comparator
You might think that it's pointless to have Optional_syntax
on options because OCaml already has nice syntax for matching on options. The reason to have this here is that you might have, for example, a tuple of an option and some other type that supports Optional_syntax
. Since Optional_syntax
can only be opted into at the granularity of the whole match expression, we need this Optional_syntax
support for options in order to use it for the other half of the tuple.