Module `ResourceLeakCSDomain.LeakList`

include module type of Base.List

type !'a t = 'a list

val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val hash_fold_t : (Base__.Ppx_hash_lib.Std.Hash.state -> 'a -> Base__.Ppx_hash_lib.Std.Hash.state) -> Base__.Ppx_hash_lib.Std.Hash.state -> 'a t -> Base__.Ppx_hash_lib.Std.Hash.state
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 : Base__.Ppx_sexp_conv_lib.Sexp.Private.Raw_grammar.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__.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 invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
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 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 of_list : 'a t -> 'a t
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:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c
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_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 existsi : 'a t -> f:(int -> 'a -> bool) -> bool
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 filter : 'a t -> f:('a -> bool) -> 'a t
val rev_filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t
val partition_map : 'a t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b t * 'c 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_tf : 'a t -> f:('a -> bool) -> 'a t * 'a 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 : '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 append : 'a t -> 'a t -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val folding_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'c t
val folding_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'c t
val fold_map : 'a t -> init:'b -> f:('b -> 'a -> 'b * 'c) -> 'b * 'c t
val fold_mapi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b * 'c) -> 'b * 'c t
val concat_map : 'a t -> f:('a -> 'b t) -> 'b t
val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> '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 -> 'b -> 'b) -> init:'b -> 'b
val fold_left : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
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 mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val rev_mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
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 group : 'a t -> break:('a -> 'a -> bool) -> 'a t t
val groupi : 'a t -> break:(int -> 'a -> 'a -> bool) -> '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 : compare:('a -> 'a -> int) -> 'a t -> 'a t
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
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_map : 'a t -> f:('a -> 'b option) -> 'b t
val 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 : 'a t 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 append_one : 'a list -> 'a -> 'a list