Module `Option`

Module implementing basic combinators for OCaml option type. It tries follow closely the style of OCaml standard library.

Actually, some operations have the same name as List ones: they actually are similar considering 'a option as a type of lists with at most one element.

exception IsNone

val has_some : 'a option -> bool: has_some x is true if x is of the form Some y and false otherwise.

val is_empty : 'a option -> bool: Negation of has_some

val equal : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool: equal f x y lifts the equality predicate f to option types. That is, if both x and y are None then it returns true, if they are both Some _ then f is called. Otherwise it returns false.

val compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int: Same as equal, but with comparison.

val hash : ('a -> int) -> 'a option -> int: Lift a hash to option types.

val get : 'a option -> 'a

get x returns y where x is Some y.

raises IsNone: if x equals None.

val make : 'a -> 'a option: make x returns Some x.

val bind : 'a option -> ('a -> 'b option) -> 'b option: bind x f is f y if x is Some y and None otherwise

val filter : ('a -> bool) -> 'a option -> 'a option: filter f x is x if x Some y and f y is true, None otherwise

val init : bool -> 'a -> 'a option: init b x returns Some x if b is true and None otherwise.

val flatten : 'a option option -> 'a option: flatten x is Some y if x is Some (Some y) and None otherwise.

val append : 'a option -> 'a option -> 'a option: append x y is the first element of the concatenation of x and y seen as lists. In other words, append (Some a) y is Some a, append None (Some b) is Some b, and append None None is None.

"Iterators"

val iter : ('a -> unit) -> 'a option -> unit: iter f x executes f y if x equals Some y. It does nothing otherwise.

exception Heterogeneous

val iter2 : ('a -> 'b -> unit) -> 'a option -> 'b option -> unit

iter2 f x y executes f z w if x equals Some z and y equals Some w. It does nothing if both x and y are None.

raises Heterogeneous: otherwise.

val map : ('a -> 'b) -> 'a option -> 'b option: map f x is None if x is None and Some (f y) if x is Some y.

val fold_left : ('b -> 'a -> 'b) -> 'b -> 'a option -> 'b: fold_left f a x is f a y if x is Some y, and a otherwise.

val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b option -> 'c option -> 'a

fold_left2 f a x y is f z w if x is Some z and y is Some w. It is a if both x and y are None.

raises Heterogeneous: otherwise.

val fold_right : ('a -> 'b -> 'b) -> 'a option -> 'b -> 'b: fold_right f x a is f y a if x is Some y, and a otherwise.

val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b option -> 'a * 'c option: fold_left_map f a x is a, f y if x is Some y, and a otherwise.

val fold_right_map : ('b -> 'a -> 'c * 'a) -> 'b option -> 'a -> 'c option * 'a: Same as fold_left_map on the right

val cata : ('a -> 'b) -> 'b -> 'a option -> 'b: cata f e x is e if x is None and f a if x is Some a

More Specific Operations

val default : 'a -> 'a option -> 'a: default a x is y if x is Some y and a otherwise.

Smart operations

module Smart : sig ... end

Operations with Lists

module List : sig ... end