Batteries_uni.Option

# Module Batteries_uni.Option

    module Option: BatOption

    type 'a t = 'a option

    val may : ('a -> unit) -> 'a option -> unit

`may f (Some x)` calls `f x` and `may f None` does nothing.

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

`map f (Some x)` returns `Some (f x)` and `map f None` returns `None`.

    val bind : ('a -> 'b option) -> 'a option -> 'b option

`bind f (Some x)` returns `f x` and `bind f None` returns `None`.

    val default : 'a -> 'a option -> 'a

`default x (Some v)` returns `v` and `default x None` returns `x`.

    val map_default : ('a -> 'b) -> 'b -> 'a option -> 'b

`map_default f x (Some v)` returns `f v` and `map_default f x None` returns `x`.

    val is_none : 'a option -> bool

`is_none None` returns `true` otherwise it returns `false`.

    val is_some : 'a option -> bool

`is_some (Some x)` returns `true` otherwise it returns `false`.

    val get : 'a option -> 'a

`get (Some x)` returns `x` and `get None` raises `No_value`.

    val get_exn : 'a option -> exn -> 'a

`get_exn (Some x) e` returns `x` and `get_exn None e` raises `e`.

    val compare : ?cmp:('a -> 'a -> int) -> 'a option -> 'a option -> int

Compare two options, possibly using custom comparators for the value. `None` is always assumed to be less than `Some _`. The parameter `cmp` defaults to `Pervasives.compare`.

    val eq : ?eq:('a -> 'a -> bool) -> 'a option -> 'a option -> bool

Test for equality between option types, possibly using a custom equality predicate. The parameter `eq` defaults to `Pervasives.(=)`.
Since 1.4.0

    val enum : 'a option -> 'a BatEnum.t

`enum (Some x)` returns the singleton `x`, while `enum None` returns the empty enumeration

    val of_enum : 'a BatEnum.t -> 'a option

`of_enum e` consumes the first element of `e`, if it exists, and returns `Some e`. If `e` is empty, return `None`

    exception No_value

Raised when calling `get None`.

###### The Option Monad

    module Monad: sig .. end

This module provides everything needed to write and execute computations in the Option monad.

###### Boilerplate code

Printing

    val print : ('a BatInnerIO.output -> 'b -> unit) ->
           'a BatInnerIO.output -> 'b t -> unit

    val t_printer : 'a BatValue_printer.t -> 'a t BatValue_printer.t

    val maybe_printer : 'a BatValue_printer.t -> 'a t BatValue_printer.t

    module Labels: sig .. end

Operations on options, with labels.