containers 0.6.1 · OCaml Package

Options

type +'a t = 'a option

val map : ('a -> 'b) -> 'a t -> 'b t

Transform the element inside, if any

val maybe : ('a -> 'b) -> 'b -> 'a t -> 'b

maybe f x o is x if o is None, otherwise it's f y if o = Some y

val is_some : _ t -> bool

val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int

val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

val return : 'a -> 'a t

Monadic return

val (>|=) : 'a t -> ('a -> 'b) -> 'b t

Infix version of map

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t

Monadic bind

val flat_map : ('a -> 'b t) -> 'a t -> 'b t

Flip version of >>=

val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

val iter : ('a -> unit) -> 'a t -> unit

Iterate on 0 or 1 elements

val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a

Fold on 0 or 1 elements

val filter : ('a -> bool) -> 'a t -> 'a t

Filter on 0 or 1 elements

since 0.5

val get : 'a -> 'a t -> 'a

get default x unwraps x, but if x = None it returns default instead.

since 0.4.1

val get_exn : 'a t -> 'a

Open the option, possibly failing if it is None

raises Invalid_argument
if the option is None

val get_lazy : (unit -> 'a) -> 'a t -> 'a

get_lazy default_fn x unwraps x, but if x = None it returns default_fn () instead.

since 0.6.1

val sequence_l : 'a t list -> 'a list t

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.

val wrap : ?handler:(exn -> bool) -> ('a -> 'b) -> 'a -> 'b option

wrap 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.

parameter handler
the exception handler, which returns true if the exception is to be caught.

val wrap2 : ?handler:(exn -> bool) -> ('a -> 'b -> 'c) -> 'a -> 'b -> 'c option

wrap2 f x y is similar to wrap1 but for binary functions.

Applicative

val pure : 'a -> 'a t

Alias to return

val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

val (<$>) : ('a -> 'b) -> 'a t -> 'b t

Alternatives

val (<+>) : 'a t -> 'a t -> 'a t

a <+> b is a if a is Some _, b otherwise

val choice : 'a t list -> 'a t

choice returns the first non-None element of the list, or None

Conversion and IO

val to_list : 'a t -> 'a list

val of_list : 'a list -> 'a t

Head of list, or None

type 'a sequence = ('a -> unit) -> unit

type 'a gen = unit -> 'a option

type 'a printer = Buffer.t -> 'a -> unit

type 'a random_gen = Random.State.t -> 'a

val random : 'a random_gen -> 'a t random_gen

val to_gen : 'a t -> 'a gen

val to_seq : 'a t -> 'a sequence

val pp : 'a printer -> 'a t printer

package containers

Options

Applicative

Alternatives

Conversion and IO