Module Kxclib.List0

module Ops_piping : sig ... end
include module type of struct include Ops_piping end
val (|&>) : 'x Stdlib.List.t -> ('x -> 'y) -> 'y Stdlib.List.t
val (|&>>) : 'x Stdlib.List.t -> ('x -> 'y Stdlib.List.t) -> 'y Stdlib.List.t
val (|+&>) : 'x Stdlib.List.t -> ('x -> 'y) -> ('x * 'y) Stdlib.List.t
val (|!>) : 'x Stdlib.List.t -> ('x -> unit) -> unit
val (|-!>) : 'x Stdlib.List.t -> ('x -> unit) -> 'x Stdlib.List.t
val (|@>) : 'x Stdlib.List.t -> ('acc * (('acc * 'x) -> 'acc)) -> 'acc
val (|?>) : 'x Stdlib.List.t -> ('x -> bool) -> 'x Stdlib.List.t
val (|&?>) : 'x Stdlib.List.t -> ('x -> 'y option) -> 'y Stdlib.List.t
val (|+&?>) : 'x Stdlib.List.t -> ('x -> 'y option) -> ('x * 'y) Stdlib.List.t
include module type of struct include Stdlib.List end
type !'a t = 'a list =
  1. | []
  2. | :: of 'a * 'a list
val length : 'a list -> int
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> int -> int
val is_empty : 'a list -> bool
val cons : 'a -> 'a list -> 'a list
val nth : 'a list -> int -> 'a
val nth_opt : 'a list -> int -> 'a option
val rev : 'a list -> 'a list
val init : int -> (int -> 'a) -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int
val iter : ('a -> unit) -> 'a list -> unit
val iteri : (int -> 'a -> unit) -> 'a list -> unit
val map : ('a -> 'b) -> 'a list -> 'b list
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val filter_map : ('a -> 'b option) -> 'a list -> 'b list
val concat_map : ('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc
val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'acc
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a list -> 'b list -> 'acc
val fold_right2 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'acc
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val find_opt : ('a -> bool) -> 'a list -> 'a option
val find_index : ('a -> bool) -> 'a list -> int option
val find_map : ('a -> 'b option) -> 'a list -> 'b option
val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
val partition_map : ('a -> ('b, 'c) Stdlib.Either.t) -> 'a list -> 'b list * 'c list
val assoc : 'a -> ('a * 'b) list -> 'b
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq : 'a -> ('a * 'b) list -> 'b
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : ('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a list
val iota : int -> int t
val iota1 : int -> int t
val range : ?include_endpoint:bool -> int -> int -> int Stdlib.List.t
val dedup' : by:('a -> 'b) -> 'c Stdlib.List.t -> 'c Stdlib.List.t
val dedup : 'a Stdlib.List.t -> 'a Stdlib.List.t
val update_assoc : 'k -> ('v option -> 'v option) -> ('k * 'v) list -> ('k * 'v) list
val update_assq : 'k -> ('v option -> 'v option) -> ('k * 'v) list -> ('k * 'v) list
val deassoc_opt : 'k -> ('k * 'v) list -> 'v option * ('k * 'v) list

deassoc_opt k l removes entry keyed k from l, interpreted as an association list, and return v, l' where v is the value of the entry being removed or None, and l' is the list after the removal, or semantically unchanged if the key does not exist. note that entries in l' may differ in order wrt. l.

if there are multiple entries keyed k, v will be Some _ and l' will differ from the original, but otherwise the behavior is unspecified

val deassq_opt : 'k -> ('k * 'v) list -> 'v option * ('k * 'v) list

same as deassoc_opt except using (==) when comparing keys

val deassoc_opt' : 'k -> ('k * 'v) list -> ('v * ('k * 'v) list) option

same as deassoc_opt but different return type

val deassq_opt' : 'k -> ('k * 'v) list -> ('v * ('k * 'v) list) option

same as deassq_opt but different return type

val deassoc : 'k -> ('k * 'v) list -> 'v * ('k * 'v) list

same as deassoc_opt but throws Not_found when the requested key does not exist

val deassq : 'k -> ('k * 'v) list -> 'v * ('k * 'v) list

same as deassq_opt but throws Not_found when the requested key does not exist

val group_by : ('x -> 'k) -> 'x t -> ('k * 'x t) t
val unzip : ('a * 'b) list -> 'c t * 'd t
val unzip3 : ('a * 'b * 'c) list -> 'd t * 'e t * 'f t
val reduce : ('a -> 'b -> 'a) -> 'c t -> 'd
val reduce_opt : ('a -> 'b -> 'a) -> 'c t -> 'd option
val min_opt : ('a -> 'b -> int) -> 'c t -> 'd option
val max_opt : ('a -> 'b -> int) -> 'c t -> 'd option
val min : ('a -> 'a -> int) -> 'a t -> 'b
val max : ('a -> 'a -> int) -> 'a t -> 'b
val foldl : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val foldr : ('a -> 'b -> 'b) -> 'b -> 'a list -> 'b
val hd : 'a t -> 'b
val tl : 'a t -> 'b list
val take : int -> 'a t -> 'a list
val drop : int -> 'a t -> 'a t
val make : int -> 'a -> 'b list
val count : ('a -> bool) -> 'b list -> int

pred list returns the number of elements e in list that satisfies pred

val last : 'a list -> 'b

last element of list

val and_last : 'x. 'x list -> 'x list * 'x

last element and rest of a list

val iter' : ('a -> unit) -> ('b -> unit) -> 'c t -> unit
val fmap : ('x -> 'y list) -> 'x list -> 'y list
val interpolate : 'a -> 'b t -> 'c list
val filteri : (int -> 'a -> bool) -> 'b t -> 'c list
val empty : 'a t -> bool
val to_function : 'a list -> int -> 'a
val to_hashtbl : ('k * 'v) list -> ('k, 'v) Stdlib.Hashtbl.t
val pp : ?sep:string -> ?parens:(string * string) -> (Stdlib.Format.formatter -> 'a -> unit) -> Stdlib.Format.formatter -> 'b list -> unit
val bind : 'a list -> ('a -> 'b list) -> 'b list
val return : 'a -> 'b t