package batteries

  1. Overview
  2. Docs
A community-maintained standard library extension

Install 

dune-project
 Dependency

github.com Edit opam file Versions (15)

Authors

  1. O
    OCaml batteries-included team

Maintainers

  1. C
    Cedric Cellier <rixed@happyleptic.org>
  2. F
    Francois Berenger <unixjunkie@sdf.org>
  3. Gabriel Scherer
  4. T
    Thibault Suzanne <thi.suzanne@gmail.com>

Sources

v3.6.0.tar.gz
md5=1bcb27dfbd130eb057561196ef851649
sha512=2a56611b09a5f1cba6457539f8b6bc87a5f2a5454b36cdb39f6e0d6a5dac6db179aab1ba87c74dd49cc41df31a9a96feb349028ea41df7371ecb47f4d9dfafc4

doc/batteries.unthreaded/BatOption/index.html

Module BatOption

Functions for the option type.

Options are an Ocaml standard type that can be either None (undefined) or Some x where x can be any value. Options are widely used in Ocaml to represent undefined values (a little like NULL in C, but in a type and memory safe way). This module adds some functions for working with options.

  • author Nicolas Cannasse
  • author David Teller
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.

@example "Our functions return option types. Compose them to propagate None."

  let pick_long case =
    try
      Some (List.find (fun data -> List.length data > 1000) case)
    with Not_found -> None
  let last_null data = List.rindex_of 0 data
  let interesting_positions dataset =
    List.filter_map
      (fun case -> Option.bind last_null (pick_long case))
      dataset
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 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 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 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.

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