sig
  type 'a t = 'a list
  type 'a binable = 'a t
  val bin_size_t : ('a, 'a binable) Bin_prot.Size.sizer1
  val bin_write_t : ('a, 'a binable) Bin_prot.Map_to_safe.writer1
  val bin_write_t_ : ('a, 'a binable) Bin_prot.Unsafe_write_c.writer1
  val bin_read_t : ('a, 'a binable) Bin_prot.Map_to_safe.reader1
  val bin_read_t_ : ('a, 'a binable) Bin_prot.Unsafe_read_c.reader1
  val bin_read_t__ : ('a, int -> 'a binable) Bin_prot.Unsafe_read_c.reader1
  val bin_writer_t : ('a, 'a binable) Bin_prot.Type_class.S1.writer
  val bin_reader_t : ('a, 'a binable) Bin_prot.Type_class.S1.reader
  val bin_t : ('a, 'a binable) Bin_prot.Type_class.S1.t
  type 'a container = 'a t
  val length : 'a container -> int
  val is_empty : 'a container -> bool
  val iter : 'a container -> f:('-> unit) -> unit
  val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
  val exists : 'a container -> f:('-> bool) -> bool
  val for_all : 'a container -> f:('-> bool) -> bool
  val find : 'a container -> f:('-> bool) -> 'a option
  val to_list : 'a container -> 'a list
  val to_array : 'a container -> 'a array
  val container : ('a, 'a container) Container.type_class
  type 'a sexpable = 'a t
  val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a sexpable -> Sexplib.Sexp.t
  val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a sexpable
  type 'a monad = 'a t
  val ( >>= ) : 'a monad -> ('-> 'b monad) -> 'b monad
  val ( >>| ) : 'a monad -> ('-> 'b) -> 'b monad
  module Monad_infix :
    sig
      type 'a monad = 'a monad
      val ( >>= ) : 'a monad -> ('-> 'b monad) -> 'b monad
      val ( >>| ) : 'a monad -> ('-> 'b) -> 'b monad
    end
  val bind : 'a monad -> ('-> 'b monad) -> 'b monad
  val return : '-> 'a monad
  val map : 'a monad -> f:('-> 'b) -> 'b monad
  val join : 'a monad monad -> 'a monad
  val ignore : 'a monad -> unit monad
  val unit : unit monad
  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 rev_map : f:('-> 'b) -> 'a t -> 'b t
  val fold_left : f:('-> '-> 'a) -> init:'-> 'b t -> 'a
  val iter2 : f:('-> '-> unit) -> 'a t -> 'b t -> unit
  val rev_map2 : f:('-> '-> 'c) -> 'a t -> 'b t -> 'c t
  val fold_left2 : f:('-> '-> '-> 'a) -> init:'-> 'b t -> 'c t -> 'a
  val for_all2 : f:('-> '-> bool) -> 'a t -> 'b t -> bool
  val exists2 : f:('-> '-> bool) -> 'a t -> 'b t -> bool
  val mem : '-> set:'a t -> bool
  val memq : '-> set:'a t -> bool
  val filter : f:('-> bool) -> 'a t -> 'a t
  val filteri : 'a t -> f:(int -> '-> bool) -> 'a list
  val find_all : f:('-> bool) -> 'a t -> 'a t
  val partition : 'a t -> f:('-> bool) -> 'a t * 'a t
  val assoc' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> 'b option
  val assoc_exn' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> 'b
  val mem_assoc' : ('a * 'b) t -> '-> equal:('-> '-> bool) -> bool
  val remove_assoc' :
    ('a * 'b) t -> '-> equal:('-> '-> bool) -> ('a * 'b) t
  val assoc : '-> ('a * 'b) t -> 'b
  val mem_assoc : '-> map:('a * 'b) t -> bool
  val remove_assoc : '-> ('a * 'b) t -> ('a * 'b) t
  val sort : cmp:('-> '-> int) -> 'a t -> 'a t
  val stable_sort : cmp:('-> '-> int) -> 'a t -> 'a t
  val fast_sort : cmp:('-> '-> int) -> 'a t -> 'a t
  val merge : 'a t -> 'a t -> cmp:('-> '-> 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 : 'a t -> f:(int -> '-> bool) -> (int * 'a) option
  val find_map : 'a t -> f:('-> 'b option) -> 'b option
  val find_exn : 'a t -> f:('-> bool) -> 'a
  val append : 'a t -> 'a t -> 'a t
  val map : 'a t -> f:('-> 'b) -> 'b t
  val concat_map : 'a t -> f:('-> 'b t) -> 'b t
  val map2 : 'a t -> 'b t -> f:('-> '-> 'c) -> 'c t
  val rev_map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
  val map3 : 'a t -> 'b t -> 'c t -> f:('-> '-> '-> 'd) -> 'd t
  val rev_map_append : 'a t -> 'b t -> f:('-> 'b) -> 'b t
  val fold_right : 'a t -> f:('-> '-> 'b) -> init:'-> 'b
  val fold_right2 : 'a t -> 'b t -> f:('-> '-> '-> 'c) -> init:'-> 'c
  val split : ('a * 'b) t -> 'a t * 'b t
  val combine : 'a t -> 'b t -> ('a * 'b) t
  val mapi : 'a t -> f:(int -> '-> 'b) -> 'b t
  val iteri : 'a t -> f:(int -> '-> unit) -> unit
  val fold_lefti : 'a t -> f:(int -> '-> '-> 'b) -> init:'-> 'b
  val reduce_exn : 'a t -> f:('-> '-> 'a) -> 'a
  val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
  val group : 'a t -> break:('-> '-> bool) -> 'a t t
  val groupi : 'a t -> break:(int -> '-> '-> bool) -> 'a t t
  val min_combine : 'a t -> 'b t -> ('a * 'b) t
  val last : 'a t -> 'a option
  val last_exn : 'a t -> 'a
  val dedup : ?compare:('-> '-> int) -> 'a t -> 'a t
  val stable_dedup : 'a t -> 'a t
  val contains_dup : 'a t -> bool
  val find_a_dup : 'a t -> 'a option
  val count : 'a t -> f:('-> bool) -> int
  val range : ?stride:int -> int -> int -> int t
  val frange : ?stride:float -> float -> float -> float t
  val init : int -> f:(int -> 'a) -> 'a t
  val rev_filter_map : 'a t -> f:('-> 'b option) -> 'b t
  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
  val filter_opt : 'a option t -> 'a t
  val partition_map :
    'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
  val reverse_pairs : ('a * 'b) t -> ('b * 'a) t
  val split_n : 'a t -> int -> 'a t * 'a t
  val sub : 'a t -> pos:int -> len:int -> 'a t
  val slice : 'a t -> int -> int -> 'a t
  val take : 'a t -> int -> 'a t
  val drop : 'a t -> int -> 'a t
  val drop_while : 'a t -> f:('-> bool) -> 'a t
  val concat : 'a t t -> 'a t
  val flatten : 'a t t -> 'a t
  val flatten_no_order : 'a t t -> 'a t
  val assoc_opt : '-> ('a * 'b) t -> 'b option
  val cons : '-> 'a t -> 'a t
  val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
  val to_string : ('-> string) -> 'a t -> string
  val permute : ?random_state:Random.State.t -> 'a t -> 'a t
  val is_sorted : 'a t -> compare:('-> '-> int) -> bool
  val compare : 'a t -> 'a t -> cmp:('-> '-> int) -> int
  module Infix : sig val ( @ ) : 'a t -> 'a t -> 'a t end
end