List (hax-engine.Hax_engine.Utils.List)

include module type of struct include Base.List end

type !'a t = 'a list

val compare : 
  'a Base__Ppx_compare_lib.compare ->
  'a t Base__Ppx_compare_lib.compare

val globalize : ('a -> 'a) -> 'a t -> 'a t

val hash_fold_t : 
  'a Base__Ppx_hash_lib.hash_fold ->
  'a t Base__Ppx_hash_lib.hash_fold

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 partition_map : 'a t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b t * 'c 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) Base__.Result.t) ->
  ('acc, 'e) Base__.Result.t

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, 'a, 'b) Base__Indexed_container_intf.foldi

val iteri : ('a t, 'a) Base__Indexed_container_intf.iteri

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 Base__Invariant_intf.inv -> 'a t Base__Invariant_intf.inv

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) Base__.Result.t 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 zip_opt : 
  'a 'b. 'a Base.list ->
  'b Base.list ->
  ('a * 'b) Base.list Base.option