Module Base.OptionSource
The option type indicates whether a meaningful value is present. It is frequently used to represent success or failure, using None for failure. To be more descriptive about why a function failed, see the Or_error module.
Usage example from a utop session follows. Hash table lookups use the option type to indicate success or failure when looking up a key.
# let h = Hashtbl.of_alist (module String) [ ("Bar", "Value") ];;
val h : (string, string) Hashtbl.t = <abstr>;;
- : (string, string) Hashtbl.t = <abstr>
# Hashtbl.find h "Foo";;
- : string option = None
# Hashtbl.find h "Bar";;
- : string option = Some "Value"Type and Interfaces
val hash_fold_t :
(Base.Hash.state -> 'a -> Base.Hash.state) ->
Base.Hash.state ->
'a Base.Option.t ->
Base.Hash.stateinclude Base.Equal.S1 with type 'a t := 'a Base.Option.t
include Base.Invariant.S1 with type 'a t := 'a Base.Option.t
Applicative interface
Options form an applicative, where:
return x = Some xNone <*> x = NoneSome f <*> None = NoneSome f <*> Some x = Some (f x)
include Base.Applicative.S_local with type 'a t := 'a Base.Option.t
same as apply
val map3 :
'a Base.Option.t ->
'b Base.Option.t ->
'c Base.Option.t ->
f:('a -> 'b -> 'c -> 'd) ->
'd Base.Option.tMonadic interface
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 Base.Option.t
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.
These are convenient to have in scope when programming with a monad:
Extracting Underlying Values
Extracts the underlying value if present, otherwise returns default.
val value_exn :
?here:Stdlib.Lexing.position ->
?error:Base.Error.t ->
?message:string ->
'a Base.Option.t ->
'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.
Constructors
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.
Predicates
is_none t returns true iff t = None.
is_some t returns true iff t = Some x.