# Module Extlib.Option

    module Option: BatOption

    type 'a t = 'a option

    val some : 'a -> 'a option

`some x` returns `Some x`.
Since 2.2.0

    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 option -> ('a -> 'b option) -> 'b option

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

    val apply : ('a -> 'a) option -> 'a -> 'a

`apply None x` returns `x` and `apply (Some f) x` returns `f x`

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

`filter f None` returns `None`, `filter f (Some x)` returns `Some x` if `f x` is true, and `None` otherwise.

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

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

    val (|?) : 'a option -> 'a -> 'a

Like `BatOption.default`, with the arguments reversed. `None |? 10` returns `10`, while `Some "foo" |? "bar"` returns `"foo"`.

Note This operator does not short circuit like `( || )` and `( && )`. Both arguments will be evaluated.
Since 2.0

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

Like `BatOption.default`, but the default value is passed as a thunk that is only computed if needed.
Since 2.1

    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 map_default_delayed : ('a -> 'b) -> (unit -> 'b) -> 'a option -> 'b

Like `BatOption.map_default`, but the default value is passed as a thunk that is only computed if needed.
Since 2.1

    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`.
Raises `Invalid_argument` on `get None`.

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

###### The Option Monad

    module Monad: sig .. end

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

###### Boilerplate code

    val ord : 'a BatOrd.ord -> 'a option BatOrd.ord

Comparison between optional values
Since 2.2.0
Printing

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

    module Labels: sig .. end

Operations on options, with labels.

    module Infix: sig .. end