package core

  1. Overview
  2. Docs
package core
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Core.OptionSource

This module extends Base.Option with bin_io, quickcheck, and support for ppx_optional.

Sourcetype 'a t = 'a Base.Option.t
include Bin_prot.Binable.S1 with type 'a t := 'a t
Sourceval bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
Sourceval bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
Sourceval bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
Sourceval __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
Sourceval bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
Sourceval bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
Sourceval bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
include Typerep_lib.Typerepable.S1 with type 'a t := 'a t

Type and Interfaces

Sourceval compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int
Sourceval hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a option -> Base.Hash.state
Sourceval t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a option Sexplib0.Sexp_grammar.t
include Base.Equal.S1 with type 'a t := 'a option
Sourceval equal : 'a Base.Equal.equal -> 'a option Base.Equal.equal
include Base.Invariant.S1 with type 'a t := 'a option
Sourceval invariant : ('a -> unit) -> 'a option -> unit
include Base.Sexpable.S1 with type 'a t := 'a option
Sourceval t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a option
Sourceval sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a option -> Sexplib0.Sexp.t

Applicative interface

Options form an applicative, where:

  • return x = Some x
  • None <*> x = None
  • Some f <*> None = None
  • Some f <*> Some x = Some (f x)
include Base.Applicative.S with type 'a t := 'a option
Sourceval both : 'a option -> 'b option -> ('a * 'b) option
Sourceval (<*>) : ('a -> 'b) option -> 'a option -> 'b option

same as apply

Sourceval (<*) : 'a option -> unit option -> 'a option
Sourceval (*>) : unit option -> 'a option -> 'a option
Sourceval apply : ('a -> 'b) option -> 'a option -> 'b option
Sourceval map2 : 'a option -> 'b option -> f:('a -> 'b -> 'c) -> 'c option
Sourceval map3 : 'a option -> 'b option -> 'c option -> f:('a -> 'b -> 'c -> 'd) -> 'd option
Sourcemodule Applicative_infix = Base.Option.Applicative_infix

Monadic interface

Options form a monad, where:

  • return x = Some x
  • (None >>= f) = None
  • (Some x >>= f) = f x
include Base.Monad.S with type 'a t := 'a option
Sourceval (>>=) : 'a option -> ('a -> 'b option) -> 'b 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.

Sourceval (>>|) : 'a option -> ('a -> 'b) -> 'b option

t >>| f is t >>= (fun a -> return (f a)).

Sourcemodule Monad_infix = Base.Option.Monad_infix
Sourceval bind : 'a option -> f:('a -> 'b option) -> 'b option

bind t ~f = t >>= f

Sourceval return : 'a -> 'a option

return v returns the (trivial) computation that returns v.

Sourceval map : 'a option -> f:('a -> 'b) -> 'b option

map t ~f is t >>| f.

Sourceval join : 'a option option -> 'a option

join t is t >>= (fun t' -> t').

Sourceval ignore_m : 'a option -> unit option

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 Caml.ignore. Some monads still do let ignore = ignore_m for historical reasons.

Sourceval all : 'a option list -> 'a list option
Sourceval all_unit : unit option list -> unit option

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.

Sourcemodule Let_syntax = Base.Option.Let_syntax

Extracting Underlying Values

Sourceval value : 'a option -> default:'a -> 'a

Extracts the underlying value if present, otherwise returns default.

Sourceval value_exn : ?here:Caml.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.

Sourceval value_map : 'a option -> default:'b -> f:('a -> 'b) -> 'b

Extracts the underlying value and applies f to it if present, otherwise returns default.

Sourceval value_or_thunk : 'a option -> default:(unit -> 'a) -> 'a

Extracts the underlying value if present, otherwise executes and returns the result of default. default is only executed if the underlying value is absent.

Sourceval fold : 'a option -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum

On None, returns init. On Some x, returns f init x.

Sourceval mem : 'a option -> 'a -> equal:('a -> 'a -> bool) -> bool

Checks whether the provided element is there, using equal.

Sourceval length : 'a option -> int
Sourceval iter : 'a option -> f:('a -> unit) -> unit
Sourceval exists : 'a option -> f:('a -> bool) -> bool

On None, returns false. On Some x, returns f x.

Sourceval for_all : 'a option -> f:('a -> bool) -> bool

On None, returns true. On Some x, returns f x.

Sourceval find : 'a option -> f:('a -> bool) -> 'a option

find t ~f returns t if t = Some x and f x = true; otherwise, find returns None.

Sourceval find_map : 'a option -> f:('a -> 'b option) -> 'b option

On None, returns None. On Some x, returns f x.

Sourceval to_list : 'a option -> 'a list
Sourceval to_array : 'a option -> 'a array
Sourceval call : 'a -> f:('a -> unit) option -> unit

call x f runs an optional function ~f on the argument.

Sourceval merge : 'a option -> 'a option -> f:('a -> 'a -> 'a) -> 'a option

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.

Sourceval filter : 'a option -> f:('a -> bool) -> 'a option

Constructors

Sourceval try_with : (unit -> 'a) -> 'a option

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.

Sourceval try_with_join : (unit -> 'a option) -> 'a option

try_with_join f returns the optional value returned by f if it exits normally, and None if f raises an exception.

Sourceval some : 'a -> 'a option

Wraps the Some constructor as a function.

Sourceval first_some : 'a option -> 'a option -> 'a option

first_some t1 t2 returns t1 if it has an underlying value, or t2 otherwise.

Sourceval some_if : bool -> 'a -> 'a option

some_if b x converts a value x to Some x if b, and None otherwise.

Predicates

Sourceval is_none : 'a option -> bool

is_none t returns true iff t = None.

Sourceval is_some : 'a option -> bool

is_some t returns true iff t = Some x.

include Comparator.Derived with type 'a t := 'a t
Sourcetype 'cmp comparator_witness
include Quickcheckable.S1 with type 'a t := 'a t
Sourceval validate : none:unit Validate.check -> some:'a Validate.check -> 'a t Validate.check
Sourcemodule Stable : sig ... end
Sourcemodule Optional_syntax : Optional_syntax.S1 with type 'a t := 'a t and type 'a value := 'a

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.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct