Module NS.List

include module type of ContainersLabels.List
type !'a iter = ('a -> unit) -> unit
type !'a gen = unit -> 'a option
type !'a printer = Stdlib.Format.formatter -> 'a -> unit
type !'a random_gen = Stdlib.Random.State.t -> 'a
val length : 'a list -> int
val nth : 'a list -> int -> 'a
val rev : 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val rev_map : f:('a -> 'b) -> 'a list -> 'b list
val concat_map : f:('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc
val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val memq : 'a -> set:'a list -> bool
val find_index : f:('a -> bool) -> 'a list -> int option
val find_all : f:('a -> bool) -> 'a list -> 'a list
val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list
val assq : 'a -> ('a * 'b) list -> 'b
val mem_assq : 'a -> map:('a * 'b) list -> bool
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val empty : 'a list
val is_empty : 'a list -> bool
val cons : 'a -> 'a list -> 'a list
val append : 'a list -> 'a list -> 'a list
val cons' : 'a list -> 'a -> 'a list
val cons_maybe : 'a option -> 'a list -> 'a list
val cons_when : bool -> 'a -> 'a list -> 'a list
val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) -> init:'a -> 'b list -> 'a
val fold_map_i : f:('acc -> int -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
val fold_on_map : f:('a -> 'b) -> reduce:('acc -> 'b -> 'acc) -> init:'acc -> 'a list -> 'acc
val scan_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc list
val reduce_exn : f:('a -> 'a -> 'a) -> 'a list -> 'a
val fold_map2 : f:('acc -> 'a -> 'b -> 'acc * 'c) -> init:'acc -> 'a list -> 'b list -> 'acc * 'c list
val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
val fold_filter_map_i : f:('acc -> int -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
val fold_flat_map : f:('acc -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
val fold_flat_map_i : f:('acc -> int -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
val unfold : f:('seed -> ('b * 'seed) option) -> init:'seed -> 'b list
val count : f:('a -> bool) -> 'a list -> int
val count_true_false : f:('a -> bool) -> 'a list -> int * int
val init : int -> f:(int -> 'a) -> 'a list
val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
val combine_shortest : 'a list -> 'b list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> int -> int
val flat_map : f:('a -> 'b list) -> 'a list -> 'b list
val flat_map_i : f:(int -> 'a -> 'b list) -> 'a list -> 'b list
val flatten : 'a list list -> 'a list
val product : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_product : f:('c -> 'a -> 'b -> 'c) -> init:'c -> 'a list -> 'b list -> 'c
val cartesian_product : 'a list list -> 'a list list
val map_product_l : f:('a -> 'b list) -> 'a list -> 'b list list
val diagonal : 'a list -> ('a * 'a) list
val partition_map_either : f:('a -> ('b, 'c) CCEither.t) -> 'a list -> 'b list * 'c list
val partition_filter_map : f:('a -> [< `Drop | `Left of 'b | `Right of 'c ]) -> 'a list -> 'b list * 'c list
val join : join_row:('a -> 'b -> 'c option) -> 'a list -> 'b list -> 'c list
val sublists_of_len : ?last:('a list -> 'a list option) -> ?offset:int -> len:int -> 'a list -> 'a list list
val chunks : int -> 'a list -> 'a list list
val intersperse : x:'a -> 'a list -> 'a list
val interleave : 'a list -> 'a list -> 'a list
val pure : 'a -> 'a list
val mguard : bool -> unit list
val return : 'a -> 'a list
val take : int -> 'a list -> 'a list
val drop : int -> 'a list -> 'a list
val hd_tl : 'a list -> 'a * 'a list
val take_drop : int -> 'a list -> 'a list * 'a list
val take_while : f:('a -> bool) -> 'a list -> 'a list
val drop_while : f:('a -> bool) -> 'a list -> 'a list
val take_drop_while : f:('a -> bool) -> 'a list -> 'a list * 'a list
val last : int -> 'a list -> 'a list
val head_opt : 'a list -> 'a option
val tail_opt : 'a list -> 'a list option
val last_opt : 'a list -> 'a option
val find_pred : f:('a -> bool) -> 'a list -> 'a option
val find_opt : f:('a -> bool) -> 'a list -> 'a option
val find_pred_exn : f:('a -> bool) -> 'a list -> 'a
val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option
val find_idx : f:('a -> bool) -> 'a list -> (int * 'a) option
val filter_map : f:('a -> 'b option) -> 'a list -> 'b list
val keep_some : 'a option list -> 'a list
val keep_ok : ('a, 'b) Stdlib.result list -> 'a list
val all_some : 'a option list -> 'a list option
val all_ok : ('a, 'err) Stdlib.result list -> ('a list, 'err) Stdlib.result
val split_result : ('ok, 'error) Stdlib.result list -> 'ok list * 'error list
val sorted_mem : cmp:('a -> 'a -> int) -> 'a -> 'a list -> bool
val sorted_merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val sorted_diff : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val sorted_merge_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val sorted_diff_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val is_sorted : cmp:('a -> 'a -> int) -> 'a list -> bool
val sorted_insert : cmp:('a -> 'a -> int) -> ?uniq:bool -> 'a -> 'a list -> 'a list
val sorted_remove : cmp:('a -> 'a -> int) -> ?all:bool -> 'a -> 'a list -> 'a list
val uniq_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list
val group_succ : eq:('a -> 'a -> bool) -> 'a list -> 'a list list
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
val iteri2 : f:(int -> 'a -> 'b -> unit) -> 'a list -> 'b list -> unit
val foldi2 : f:('c -> int -> 'a -> 'b -> 'c) -> init:'c -> 'a list -> 'b list -> 'c
val get_at_idx : int -> 'a list -> 'a option
val nth_opt : 'a list -> int -> 'a option
val get_at_idx_exn : int -> 'a list -> 'a
val set_at_idx : int -> 'a -> 'a list -> 'a list
val insert_at_idx : int -> 'a -> 'a list -> 'a list
val remove_at_idx : int -> 'a list -> 'a list
val add_nodup : eq:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list
val subset : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val uniq : eq:('a -> 'a -> bool) -> 'a list -> 'a list
val union : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list
val inter : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> 'a list
val range_by : step:int -> int -> int -> int list
val range : int -> int -> int list
val range' : int -> int -> int list
val replicate : int -> 'a -> 'a list
val repeat : int -> 'a list -> 'a list
val assoc : eq:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b
val assoc_opt : eq:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val remove_assoc : eq:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> ('a * 'b) list
module Ref : sig ... end
module type MONAD = sig ... end
module Traverse (M : MONAD) : sig ... end
val random : 'a random_gen -> 'a list random_gen
val random_non_empty : 'a random_gen -> 'a list random_gen
val random_len : int -> 'a random_gen -> 'a list random_gen
val random_choose : 'a list -> 'a random_gen
val random_sequence : 'a random_gen list -> 'a list random_gen
val to_string : ?start:string -> ?stop:string -> ?sep:string -> ('a -> string) -> 'a list -> string
val to_iter : 'a list -> 'a iter
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_iter : 'a iter -> 'a list
val of_seq_rev : 'a Stdlib.Seq.t -> 'a list
val of_seq : 'a Stdlib.Seq.t -> 'a list
val to_gen : 'a list -> 'a gen
val of_gen : 'a gen -> 'a list
module Infix : sig ... end
val (>|=) : 'a CCList.t -> ('a -> 'b) -> 'b CCList.t
val (@) : 'a CCList.t -> 'a CCList.t -> 'a CCList.t
val (<*>) : ('a -> 'b) CCList.t -> 'a CCList.t -> 'b CCList.t
val (<$>) : ('a -> 'b) -> 'a CCList.t -> 'b CCList.t
val (>>=) : 'a CCList.t -> ('a -> 'b CCList.t) -> 'b CCList.t
val (--) : int -> int -> int CCList.t
val (--^) : int -> int -> int CCList.t
val let+ : 'a CCList.t -> ('a -> 'b) -> 'b CCList.t
val and+ : 'a CCList.t -> 'b CCList.t -> ('a * 'b) CCList.t
val let* : 'a CCList.t -> ('a -> 'b CCList.t) -> 'b CCList.t
val and* : 'a CCList.t -> 'b CCList.t -> ('a * 'b) CCList.t
val and& : 'a list -> 'b list -> ('a * 'b) list
type 'a t = 'a list
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
val equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equal
include Sexplib0.Sexpable.S1 with type '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 pp : ?pre:(unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> ?suf:(unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> (unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> (Stdlib.Format.formatter -> 'a -> unit) -> Stdlib.Format.formatter -> 'a list -> unit

Pretty-print a list.

val pp_diff : cmp:('a -> 'a -> int) -> ?pre:(unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> ?suf:(unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> (unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> (Stdlib.Format.formatter -> 'a -> unit) -> Stdlib.Format.formatter -> ('a list * 'a list) -> unit
val hd : 'a t -> 'a option
val hd_exn : 'a t -> 'a
val tl : 'a t -> 'a t option
val tl_exn : 'a t -> 'a t
val pop_exn : 'a list -> 'a * 'a list
val mem : 'a -> 'a t -> eq:('a -> 'a -> bool) -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val find : 'a t -> f:('a -> bool) -> 'a option
val find_exn : 'a t -> f:('a -> bool) -> 'a
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val find_map_exn : 'a t -> f:('a -> 'b option) -> 'b
val remove_one_exn : eq:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list

Returns the input list without the first element equal to the argument, or raise Not_found if no such element exists.

val remove_one : eq:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list option
val remove : eq:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list
val filter : 'a list -> f:('a -> bool) -> 'a list
val partition : 'a t -> f:('a -> bool) -> 'a t * 'a t

partition xs ~f returns a pair of lists (ts, fs), where ts is the list of all the elements of xs that satisfy the predicate f, and fs is the list of all the elements of xs that do not satisfy f. The order of the elements in the input list is preserved.

val partition_map : 'a t -> f:('a -> ('l, 'r) Either.t) -> 'l t * 'r t

partition_map xs ~f returns a pair of lists (ls, rs) such that, for each element x of the input list xs:

  • if f x is Left l, then l is in ls, and
  • if f x is Right r, then r is in rs.

The output elements are included in ls and rs in the same relative order as the corresponding input elements in xs.

val rev_partition_map : 'a t -> f:('a -> ('l, 'r) Either.t) -> 'l t * 'r t

rev_partition_map xs ~f is (rev ls, rev rs) where partition_map xs ~f = (ls, rs). This avoids the rev that partition_map performs.

val partition_map_endo : 'a t -> f:('a -> ('a, 'r) Either.t) -> 'a t * 'r t

partition_map_endo xs ~f is equivalent to partition_map xs ~f but specialized to the case where the left and input elements have the same type. Preserves == if f x is Left x for all x in xs.

val fold_partition_map : 'a t -> 's -> f:('a -> 's -> ('l, 'r) Either.t * 's) -> 'l t * 'r t * 's

fold_partition_map is like partition_map but threads an accumulator through the calls to f.

val fold_partition_map_endo : 'a t -> 's -> f:('a -> 's -> ('a, 'r) Either.t * 's) -> 'a t * 'r t * 's

fold_partition_map_endo xs s ~f is equivalent to fold_partition_map xs s ~f but specialized to the case where the left and input elements have the same type. Preserves == if f x is Left x for all x in xs.

val map : 'a t -> f:('a -> 'b) -> 'b t
val map_endo : 'a t -> f:('a -> 'a) -> 'a t

Like map, but specialized to require f to be an endofunction, which enables preserving == if f preserves == of every element.

val rev_map_split : 'a t -> f:('a -> 'b * 'c) -> 'b list * 'c list

rev_map_split ~f xs is split (rev_map ~f xs) but more efficient.

val combine : 'a t -> 'b t -> ('a * 'b) t option
val combine_exn : 'a t -> 'b t -> ('a * 'b) t
val group_by : 'a t -> hash:('a -> int) -> eq:('a -> 'a -> bool) -> 'a list t
val join_by : eq:('key -> 'key -> bool) -> hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
val join_all_by : eq:('key -> 'key -> bool) -> hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a list -> 'b list -> 'c option) -> 'a t -> 'b t -> 'c t
val group_join_by : eq:('a -> 'a -> bool) -> hash:('a -> int) -> ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
val fold : 'a list -> 's -> f:('a -> 's -> 's) -> 's
val fold_left : 'a list -> 's -> f:('s -> 'a -> 's) -> 's
val fold_right : 'a list -> 's -> f:('a -> 's -> 's) -> 's
val foldi : 'a t -> 's -> f:(int -> 'a -> 's -> 's) -> 's
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val fold_diagonal : 'a list -> 's -> f:('a -> 'a -> 's -> 's) -> 's
val fold_map : 'a t -> 's -> f:('a -> 's -> 'b * 's) -> 'b t * 's
val fold2_exn : 'a t -> 'b t -> 's -> f:('a -> 'b -> 's -> 's) -> 's
val symmetric_diff : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> ('a, 'a) Either.t t
module Assoc : sig ... end
val mem_assoc : 'a -> ('a * _) t -> eq:('a -> 'a -> bool) -> bool