BatList.Exceptionless

# Module BatList.Exceptionless

    module Exceptionless: sig .. end

Exceptionless counterparts for error-raising operations

    val find : ('a -> bool) -> 'a list -> 'a option

`find p l` returns `Some x` where `x` is the first element of `l` such as `p x` returns `true` or `None` if such an element has not been found.

    val rfind : ('a -> bool) -> 'a list -> 'a option

`rfind p l` returns `Some x` where `x` is the last element of `l` such that `p x` returns `true` or `None` if such element as not been found.

    val findi : (int -> 'a -> bool) -> 'a list -> (int * 'a) option

`findi p e l` returns `Some (i, ai)` where `ai` and `i` are respectively the first element of `l` and its index, such that `p i ai` is true, or `None` if no such element has been found.

    val split_at : int -> 'a list -> [ `Invalid_argument of string | `Ok of 'a list * 'a list ]

Whenever `n` is inside of `l` size bounds, `split_at n l` returns `Ok(l1,l2)`, where `l1` contains the first `n` elements of `l` and `l2` contains the others. Otherwise, returns ``Invalid_index n`

    val at : 'a list -> int -> [ `Invalid_argument of string | `Ok of 'a ]

If `n` is inside the bounds of `l`, `at l n` returns `Ok x`, where `x` is the n-th element of the list `l`. Otherwise, returns `Error (`Invalid_index(n))`.

    val assoc : 'a -> ('a * 'b) list -> 'b option

`assoc a l` returns `Some b` where `b` is the value associated with key `b` in the list of pairs `l`. That is, `assoc a [ ...; (a,b); ...] = Some b` if `(a,b)` is the leftmost binding of `a` in list `l`. Return `None` if there is no value associated with `a` in the list `l`.

    val assoc_inv : 'a -> ('b * 'a) list -> 'b option

`assoc_inv b l` returns `Some a` where `a` is the key associated with value `b` in the list of pairs `l`. That is, `assoc b [ ...; (a,b); ...] = Some a` if `(a,b)` is the leftmost binding of `a` in list `l`. Return `None` if there is no key associated with `b` in the list `l`.

    val assq : 'a -> ('a * 'b) list -> 'b option

As `BatList.Exceptionless.assoc` but with physical equality.

    val find_map : ('a -> 'b option) -> 'a list -> 'b option

`find_map f xs` returns `Some y` such that `x` is the first element of the list where `f x` returns `Some y`. It returns `None` if no such element exists.

    val hd : 'a list -> 'a option

`hd l` returns `Some x` such that `x` is the first element of the given list `l`. Returns `None` if list `l` is empty.

    val tl : 'a list -> 'a list option

`tl l` returns `Some x` such that `x` is the given list `l` without its first element. Returns `None` if list `l` is empty