package batteries

  1. Overview
  2. Docs
package batteries
Legend:
Library
Module
Module type
Parameter
Class
Class type
exception Empty_list
exception Invalid_index of int
exception Different_list_size of string
exception No_more_elements
type !'a t = 'a node_t Lazy.t
and !'a node_t = 'a BatLazyList.node_t =
  1. | Nil
  2. | Cons of 'a * 'a t
type !'a enumerable = 'a t
type !'a mappable = 'a t
val nil : 'a t
val cons : 'a -> 'a t -> 'a t
val (^:^) : 'a -> 'a t -> 'a t
val peek : 'a t -> 'a option
val get : 'a t -> ('a * 'a t) option
val from : (unit -> 'a) -> 'a t
val from_while : (unit -> 'a option) -> 'a t
val from_loop : 'b -> ('b -> 'a * 'b) -> 'a t
val seq : 'a -> ('a -> 'a) -> ('a -> bool) -> 'a t
val unfold : 'b -> ('b -> ('a * 'b) option) -> 'a t
val init : int -> (int -> 'a) -> 'a t
val make : int -> 'a -> 'a t
val range : int -> int -> int t
val iter : ('a -> 'b) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'b -> 'a t -> 'b
val eager_fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val lazy_fold_right : ('a -> 'b Lazy.t -> 'b) -> 'a t -> 'b Lazy.t -> 'b Lazy.t
val mem : 'a -> 'a t -> bool
val memq : 'a -> 'a t -> bool
val find_exn : ('a -> bool) -> exn -> 'a t -> 'a
val rfind_exn : ('a -> bool) -> exn -> 'a t -> 'a
val index_of : 'a -> 'a t -> int option
val index_ofq : 'a -> 'a t -> int option
val rindex_of : 'a -> 'a t -> int option
val rindex_ofq : 'a -> 'a t -> int option
val next : 'a t -> 'a node_t
val length : 'a t -> int
val is_empty : 'a t -> bool
val would_at_fail : 'a t -> int -> bool
val hd : 'a t -> 'a
val tl : 'a t -> 'a t
val first : 'a t -> 'a
val last : 'a t -> 'a
val nth : 'a t -> int -> 'a
val mem_assoc : 'a -> ('a * 'b) t -> bool
val mem_assq : 'a -> ('a * 'b) t -> bool
val rev : 'a t -> 'a t
val eager_append : 'a t -> 'a t -> 'a t
val rev_append : 'a t -> 'a t -> 'a t
val append : 'a t -> 'a t -> 'a t
val (^@^) : 'a t -> 'a t -> 'a t
val concat : 'a t t -> 'a t
val flatten : 'a t list -> 'a t
val split_nth : int -> 'a t -> 'a t * 'a t
val unique : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
val unique_eq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
val remove : 'a -> 'a t -> 'a t
val remove_if : ('a -> bool) -> 'a t -> 'a t
val remove_all : 'a -> 'a t -> 'a t
val remove_all_such : ('a -> bool) -> 'a t -> 'a t
val take : int -> 'a t -> 'a t
val drop : int -> 'a t -> 'a t
val take_while : ('a -> bool) -> 'a t -> 'a t
val drop_while : ('a -> bool) -> 'a t -> 'a t
val to_list : 'a t -> 'a list
val to_stream : 'a t -> 'a Stream.t
val to_array : 'a t -> 'a array
val enum : 'a t -> 'a BatEnum.t
val of_list : 'a list -> 'a t
val of_stream : 'a Stream.t -> 'a t
val of_enum : 'a BatEnum.t -> 'a t
val eager_of_list : 'a list -> 'a t
val of_array : 'a array -> 'a t
val filter : ('a -> bool) -> 'a t -> 'a t
val exists : ('a -> bool) -> 'a t -> bool
val for_all : ('a -> bool) -> 'a t -> bool
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
val eternity : unit t
val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
val stable_sort : ('a -> 'a -> int) -> 'a t -> 'a t
val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val combine : 'a t -> 'b t -> ('a * 'b) t
val uncombine : ('a * 'b) t -> 'a t * 'b t
module Infix : sig ... end
val print : ?first:string -> ?last:string -> ?sep:string -> ('a BatInnerIO.output -> 'b -> unit) -> 'a BatInnerIO.output -> 'b t -> unit
module Exceptionless : sig ... end
val find : ('a -> bool) -> 'a BatLazyList.t -> 'a option
val rfind : ('a -> bool) -> 'a BatLazyList.t -> 'a option
val findi : (int -> 'a -> bool) -> 'a BatLazyList.t -> (int * 'a) option
val rfindi : (int -> 'a -> bool) -> 'a BatLazyList.t -> (int * 'a) option
val split_at : int -> 'a BatLazyList.t -> [ `Invalid_index of int | `Ok of 'a BatLazyList.t * 'a BatLazyList.t ]
val at : 'a BatLazyList.t -> int -> [ `Invalid_index of int | `Ok of 'a ]
val assoc : 'a -> ('a * 'b) BatLazyList.t -> 'b option
val assq : 'a -> ('a * 'b) BatLazyList.t -> 'b option
module Labels : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct