module Array = Base.Array
module List = Base.List
val bin_shape_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val bin_size_t : 'a Core_kernel__.Import.sizer ‑> 'a list ‑> int
val bin_write_t : 'a Bin_prot.Write.writer ‑> Bin_prot.Common.buf ‑> pos:Bin_prot.Common.pos ‑> 'a list ‑> Bin_prot.Common.pos
val bin_writer_t : 'a Bin_prot.Type_class.writer ‑> 'a list Bin_prot.Type_class.writer
val __bin_read_t__ : 'a ‑> 'b ‑> pos_ref:Bin_prot.Common.pos Pervasives.ref ‑> 'c ‑> 'd
val bin_read_t : 'a Bin_prot.Read.reader ‑> Bin_prot.Common.buf ‑> pos_ref:Bin_prot.Common.pos_ref ‑> 'a list
val bin_reader_t : 'a Bin_prot.Type_class.reader ‑> 'a list Bin_prot.Type_class.reader
val bin_t : 'a Bin_prot.Type_class.t ‑> 'a list Bin_prot.Type_class.t
module Typename_of_t : sig ... end
val typename_of_t : 'a Typerep_lib.Typename.t ‑> 'a t Typerep_lib.Typename.t
val typerep_of_t : a. 'a Typerep_lib.Std.Typerep.t ‑> 'a t Typerep_lib.Std.Typerep.t
module Assoc : sig ... end
include module type of sig ... end with type a t := a t with module Assoc := Assoc
val hash_fold_t : (Base.Hash.state ‑> 'a ‑> Base.Hash.state) ‑> Base.Hash.state ‑> 'a t ‑> Base.Hash.state
val t_of_sexp : (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a t
val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> 'a t ‑> Base.Sexp.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:'accum ‑> f:('accum ‑> 'a ‑> 'accum) ‑> 'accum
val fold_result : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.t
val fold_until : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ‑> finish:('accum ‑> 'final) ‑> 'final
val exists : 'a t ‑> f:('a ‑> bool) ‑> bool
val for_all : 'a t ‑> f:('a ‑> bool) ‑> bool
val sum : (module Base.Commutative_group.S 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
module Monad_infix = Base__List.Monad_infix
val return : 'a ‑> 'a t
module Let_syntax = Base__List.Let_syntax
val nth : 'a t ‑> int ‑> 'a option
val nth_exn : 'a t ‑> int ‑> 'a
val fold_left : 'a t ‑> init:'b ‑> f:('b ‑> 'a ‑> 'b) ‑> 'b
val iter2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> unit) ‑> unit Or_unequal_lengths.t
val rev_map2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> 'c) ‑> 'c t Or_unequal_lengths.t
val fold2 : 'a t ‑> 'b t ‑> init:'c ‑> f:('c ‑> 'a ‑> 'b ‑> 'c) ‑> 'c Or_unequal_lengths.t
val for_alli : 'a t ‑> f:(int ‑> 'a ‑> bool) ‑> bool
val for_all2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> bool) ‑> bool Or_unequal_lengths.t
val existsi : 'a t ‑> f:(int ‑> 'a ‑> bool) ‑> bool
val exists2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> bool) ‑> bool Or_unequal_lengths.t
val hd : 'a t ‑> 'a option
val hd_exn : 'a t ‑> 'a
val findi : 'a t ‑> f:(int ‑> 'a ‑> bool) ‑> (int * 'a) option
val find_exn : 'a t ‑> f:('a ‑> bool) ‑> 'a
val find_map_exn : 'a t ‑> f:('a ‑> 'b option) ‑> 'b
val find_mapi : 'a t ‑> f:(int ‑> 'a ‑> 'b option) ‑> 'b option
val find_mapi_exn : 'a t ‑> f:(int ‑> 'a ‑> 'b option) ‑> 'b
val map2 : 'a t ‑> 'b t ‑> f:('a ‑> 'b ‑> 'c) ‑> 'c t Or_unequal_lengths.t
val rev_map3 : 'a t ‑> 'b t ‑> 'c t ‑> f:('a ‑> 'b ‑> 'c ‑> 'd) ‑> 'd t Or_unequal_lengths.t
val map3 : 'a t ‑> 'b t ‑> 'c t ‑> f:('a ‑> 'b ‑> 'c ‑> 'd) ‑> 'd t Or_unequal_lengths.t
val fold_right : 'a t ‑> f:('a ‑> 'b ‑> 'b) ‑> init:'b ‑> 'b
val iteri : 'a t ‑> f:(int ‑> 'a ‑> unit) ‑> unit
val foldi : 'a t ‑> init:'b ‑> f:(int ‑> 'b ‑> 'a ‑> 'b) ‑> 'b
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 last : 'a t ‑> 'a option
val last_exn : 'a t ‑> 'a
val find_consecutive_duplicate : 'a t ‑> equal:('a ‑> 'a ‑> bool) ‑> ('a * 'a) option
val find_a_dup : compare:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a option
val contains_dup : compare:('a ‑> 'a ‑> int) ‑> 'a t ‑> bool
val find_all_dups : compare:('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a list
val count : 'a t ‑> f:('a ‑> bool) ‑> int
val counti : 'a t ‑> f:(int ‑> 'a ‑> bool) ‑> int
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 init : int ‑> f:(int ‑> 'a) ‑> 'a t
module Assoc = Base__List.Assoc
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
module Infix = Base__List.Infix
val to_string : f:('a ‑> string) ‑> 'a List.t ‑> string
include sig ... end
val comparator : ('a, 'cmp) Base__Comparator.comparator ‑> ('a t, 'cmp comparator_witness) Base__Comparator.comparator
module For_quickcheck : sig ... end
val gen : 'a For_quickcheck.Generator.t ‑> 'a Core_kernel__.Import.list For_quickcheck.Generator.t
val gen_non_empty : 'a For_quickcheck.Generator.t ‑> 'a Core_kernel__.Import.list For_quickcheck.Generator.t
val gen_with_length : Core_kernel__.Import.int ‑> 'a For_quickcheck.Generator.t ‑> 'a Core_kernel__.Import.list For_quickcheck.Generator.t
val gen_permutations : 'a List.t ‑> 'a list For_quickcheck.Generator.t
val obs : 'a For_quickcheck.Observer.t ‑> 'a list For_quickcheck.Observer.t
val shrinker : 'a For_quickcheck.Shrinker.t ‑> 'a list For_quickcheck.Shrinker.t