Module Ocamlformat_stdlib.List

type !'a t = 'a list
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val globalize : ('a -> 'a) -> 'a t -> 'a t
val t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.t
val t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t
val of_list : 'a list -> 'a t
val of_array : 'a array -> 'a t
val append : 'a t -> 'a t -> 'a t
val concat : 'a t t -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val concat_map : 'a t -> f:('a -> 'b t) -> 'b t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc
val fold_result : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'e) result) -> ('acc, 'e) result
val fold_until : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum : (module Base__Container_intf.Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b
val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
val existsi : 'a t -> f:(int -> 'a -> bool) -> bool
val for_alli : 'a t -> f:(int -> 'a -> bool) -> bool
val counti : 'a t -> f:(int -> 'a -> bool) -> int
val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
val find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option
val init : int -> f:(int -> 'a) -> 'a t
val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t
val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t
val invariant : ('a -> unit) -> 'a t -> unit
module Cartesian_product : sig ... end
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix : sig ... end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t
module Let_syntax : sig ... end
module Or_unequal_lengths : sig ... end
val nth : 'a t -> int -> 'a option
val nth_exn : 'a t -> int -> 'a
val rev : 'a t -> 'a t
val rev_append : 'a t -> 'a t -> 'a t
val unordered_append : 'a t -> 'a t -> 'a t
val rev_map : 'a t -> f:('a -> 'b) -> 'b t
val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
val iter2 : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit Or_unequal_lengths.t
val rev_map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val rev_map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t Or_unequal_lengths.t
val fold2_exn : 'a t -> 'b t -> init:'acc -> f:('acc -> 'a -> 'b -> 'acc) -> 'acc
val fold2 : 'a t -> 'b t -> init:'acc -> f:('acc -> 'a -> 'b -> 'acc) -> 'acc Or_unequal_lengths.t
val fold_right2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'acc -> 'acc) -> init:'acc -> 'acc
val fold_right2 : 'a t -> 'b t -> f:('a -> 'b -> 'acc -> 'acc) -> init:'acc -> 'acc Or_unequal_lengths.t
val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
val for_all2 : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool Or_unequal_lengths.t
val exists2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
val exists2 : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool Or_unequal_lengths.t
val rev_filter : 'a t -> f:('a -> bool) -> 'a t
val partition3_map : 'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c | `Trd of 'd ]) -> 'b t * 'c t * 'd t
val partition_result : ('ok, 'error) result t -> 'ok t * 'error t
val split_n : 'a t -> int -> 'a t * 'a t
val sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val stable_sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val merge : 'a t -> 'a t -> compare:('a -> 'a -> int) -> 'a t
val hd : 'a t -> 'a option
val tl : 'a t -> 'a t option
val hd_exn : 'a t -> 'a
val tl_exn : 'a t -> 'a t
val findi_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a
val find_exn : 'a t -> f:('a -> bool) -> 'a
val find_map_exn : 'a t -> f:('a -> 'b option) -> 'b
val find_mapi_exn : 'a t -> f:(int -> 'a -> 'b option) -> 'b
val folding_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'b t
val folding_mapi : 'a t -> init:'acc -> f:(int -> 'acc -> 'a -> 'acc * 'b) -> 'b t
val fold_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'acc * 'b t
val fold_mapi : 'a t -> init:'acc -> f:(int -> 'acc -> 'a -> 'acc * 'b) -> 'acc * 'b t
val map2_exn : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t Or_unequal_lengths.t
val rev_map3_exn : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
val rev_map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t Or_unequal_lengths.t
val map3_exn : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
val map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t Or_unequal_lengths.t
val rev_map_append : 'a t -> 'b t -> f:('a -> 'b) -> 'b t
val fold_right : 'a t -> f:('a -> 'acc -> 'acc) -> init:'acc -> 'acc
val fold_left : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc
val unzip : ('a * 'b) t -> 'a t * 'b t
val unzip3 : ('a * 'b * 'c) t -> 'a t * 'b t * 'c t
val zip : 'a t -> 'b t -> ('a * 'b) t Or_unequal_lengths.t
val zip_exn : 'a t -> 'b t -> ('a * 'b) t
val rev_mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val reduce_balanced : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val reduce_balanced_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val group : 'a t -> break:('a -> 'a -> bool) -> 'a t t
val groupi : 'a t -> break:(int -> 'a -> 'a -> bool) -> 'a t t
val sort_and_group : 'a t -> compare:('a -> 'a -> int) -> 'a t t
val chunks_of : 'a t -> length:int -> 'a t t
val last : 'a t -> 'a option
val last_exn : 'a t -> 'a
val is_prefix : 'a t -> prefix:'a t -> equal:('a -> 'a -> bool) -> bool
val is_suffix : 'a t -> suffix:'a t -> equal:('a -> 'a -> bool) -> bool
val find_consecutive_duplicate : 'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option
val remove_consecutive_duplicates : ?which_to_keep:[ `First | `Last ] -> 'a t -> equal:('a -> 'a -> bool) -> 'a t
val dedup_and_sort : 'a t -> compare:('a -> 'a -> int) -> 'a t
val find_a_dup : 'a t -> compare:('a -> 'a -> int) -> 'a option
val contains_dup : 'a t -> compare:('a -> 'a -> int) -> bool
val find_all_dups : 'a t -> compare:('a -> 'a -> int) -> 'a list
val all_equal : 'a t -> equal:('a -> 'a -> bool) -> 'a option
val range : ?stride:int -> ?start:[ `exclusive | `inclusive ] -> ?stop:[ `exclusive | `inclusive ] -> int -> int -> int t
val range' : compare:('a -> 'a -> int) -> stride:('a -> 'a) -> ?start:[ `exclusive | `inclusive ] -> ?stop:[ `exclusive | `inclusive ] -> 'a -> 'a -> 'a t
val rev_filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val rev_filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
val filter_opt : 'a option t -> 'a t
module Assoc : sig ... end
val sub : 'a t -> pos:int -> len:int -> 'a t
val take : 'a t -> int -> 'a t
val drop : 'a t -> int -> 'a t
val take_while : 'a t -> f:('a -> bool) -> 'a t
val drop_while : 'a t -> f:('a -> bool) -> 'a t
val split_while : 'a t -> f:('a -> bool) -> 'a t * 'a t
val drop_last : 'a t -> 'a t option
val drop_last_exn : 'a t -> 'a t
val concat_no_order : 'a t t -> 'a t
val cons : 'a -> 'a t -> 'a t
val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
val permute : ?random_state:Base__.Random.State.t -> 'a t -> 'a t
val random_element : ?random_state:Base__.Random.State.t -> 'a t -> 'a option
val random_element_exn : ?random_state:Base__.Random.State.t -> 'a t -> 'a
val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool
val is_sorted_strictly : 'a t -> compare:('a -> 'a -> int) -> bool
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
module Infix : sig ... end
val transpose : 'a t t -> 'a t t option
val transpose_exn : 'a t t -> 'a t t
val intersperse : 'a t -> sep:'a -> 'a t
val partition_map : 'a list -> f:('a -> ('b, 'c) Base.Either.t) -> 'b list * 'c list