Core.OptionSourceThis module extends Base.Option with bin_io, quickcheck, and support for ppx_optional.
include Bin_prot.Binable.S_local1 with type 'a t := 'a tinclude Typerep_lib.Typerepable.S1 with type 'a t := 'a tval typerep_of_t :
'a Typerep_lib.Std_internal.Typerep.t ->
'a t Typerep_lib.Std_internal.Typerep.tval hash_fold_t :
(Base.Hash.state -> 'a -> Base.Hash.state) ->
Base.Hash.state ->
'a option ->
Base.Hash.stateinclude Base.Equal.S1 with type 'a t := 'a optioninclude Base.Invariant.S1 with type 'a t := 'a optionOptions form an applicative, where:
return x = Some xNone <*> x = NoneSome f <*> None = NoneSome f <*> Some x = Some (f x)Options form a monad, where:
return x = Some x(None >>= f) = None(Some x >>= f) = f xinclude Base.Monad.S_local with type 'a t := 'a optiont >>= 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 ->
'aExtracts 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 tval comparator :
('a, 'cmp) Base.Comparator.comparator ->
('a t, 'cmp comparator_witness) Base.Comparator.comparatorYou 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.