octez-libs 18.1 · OCaml Package

include module type of Tezos_stdlib.TzList

val repeat : int -> 'a -> 'a list

repeat n x is List.of_array (Array.make n x) but more efficient.

If n < 0 it is the empty list [].

val take_n : int -> 'a list -> 'a list

take_n n l returns the n first elements of l.

If n < 0 it is the empty list []. If n > List.length l it is the list l in its entirety.

val rev_take_n : int -> 'a list -> 'a list

rev_take_n n l is List.rev (take_n n l) but more efficient.

val drop_n : int -> 'a list -> 'a list

drop_n n l returns the suffix of l after the first n elements.

If n < 0 it is the list l in its entirety. If n > List.length l it is the empty list [].

val split_n : int -> 'a list -> 'a list * 'a list

split_n n l is (take_n n l, drop_n n l) but more efficient.

val rev_split_n : int -> 'a list -> 'a list * 'a list

rev_split_n n l is (rev_take_n n l, drop_n n l) but more efficient.

val all_equal : ('a -> 'a -> bool) -> 'a list -> bool

all_equal cmp l checks if all elements of l are identical according to cmp.

If l is the empty list it is true.

include module type of Tezos_error_monad.TzLwtreslib.List

type !'a t = 'a list =

| []
| :: of 'a * 'a list

val nil : 'a list

val nil_e : ('a list, 'trace) result

val nil_s : 'a list Lwt.t

val nil_es : ('a list, 'trace) result Lwt.t

val cons : 'a -> 'a list -> 'a list

val is_empty : 'a list -> bool

val hd : 'a list -> 'a option

val tl : 'a list -> 'a list option

val nth : 'a list -> int -> 'a option

val nth_opt : 'a list -> int -> 'a option

val last : 'a -> 'a list -> 'a

val last_opt : 'a list -> 'a option

val find : ('a -> bool) -> 'a list -> 'a option

val find_opt : ('a -> bool) -> 'a list -> 'a option

val find_map : ('a -> 'b option) -> 'a list -> 'b option

val mem : equal:('a -> 'a -> bool) -> 'a -> 'a list -> bool

val memq : 'a -> 'a list -> bool

val assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option

val assoc_opt : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option

val assq : 'a -> ('a * 'b) list -> 'b option

val assq_opt : 'a -> ('a * 'b) list -> 'b option

val mem_assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> bool

val mem_assq : 'a -> ('a * 'b) list -> bool

val remove_assoc : 
  equal:('a -> 'a -> bool) ->
  'a ->
  ('a * 'b) list ->
  ('a * 'b) list

val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list

val init : 
  when_negative_length:'trace ->
  int ->
  (int -> 'a) ->
  ('a list, 'trace) result

val length : 'a list -> int

val rev : 'a list -> 'a list

val concat : 'a list list -> 'a list

val append : 'a list -> 'a list -> 'a list

val rev_append : 'a list -> 'a list -> 'a list

val flatten : 'a list list -> 'a list

val combine : 
  when_different_lengths:'trace ->
  'a list ->
  'b list ->
  (('a * 'b) list, 'trace) result

val rev_combine : 
  when_different_lengths:'trace ->
  'a list ->
  'b list ->
  (('a * 'b) list, 'trace) result

val split : ('a * 'b) list -> 'a list * 'b list

val iter2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> unit) ->
  'a list ->
  'b list ->
  (unit, 'trace) result

val map2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result

val rev_map2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result

val fold_left2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> 'a) ->
  'a ->
  'b list ->
  'c list ->
  ('a, 'trace) result

val fold_right2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> 'c) ->
  'a list ->
  'b list ->
  'c ->
  ('c, 'trace) result

val for_all2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> bool) ->
  'a list ->
  'b list ->
  (bool, 'trace) result

val exists2 : 
  when_different_lengths:'trace ->
  ('a -> 'b -> bool) ->
  'a list ->
  'b list ->
  (bool, 'trace) result

val init_e : 
  when_negative_length:'trace ->
  int ->
  (int -> ('a, 'trace) result) ->
  ('a list, 'trace) result

val init_s : 
  when_negative_length:'trace ->
  int ->
  (int -> 'a Lwt.t) ->
  ('a list, 'trace) result Lwt.t

val init_es : 
  when_negative_length:'trace ->
  int ->
  (int -> ('a, 'trace) result Lwt.t) ->
  ('a list, 'trace) result Lwt.t

val init_p : 
  when_negative_length:'trace ->
  int ->
  (int -> 'a Lwt.t) ->
  ('a list, 'trace) result Lwt.t

val find_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  ('a option, 'trace) result

val find_s : ('a -> bool Lwt.t) -> 'a list -> 'a option Lwt.t

val find_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a option, 'trace) result Lwt.t

val find_map_e : 
  ('a -> ('b option, 'trace) result) ->
  'a list ->
  ('b option, 'trace) result

val find_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b option Lwt.t

val find_map_es : 
  ('a -> ('b option, 'trace) result Lwt.t) ->
  'a list ->
  ('b option, 'trace) result Lwt.t

val filter : ('a -> bool) -> 'a list -> 'a list

val filteri : (int -> 'a -> bool) -> 'a list -> 'a list

val find_all : ('a -> bool) -> 'a list -> 'a list

val rev_filter : ('a -> bool) -> 'a list -> 'a list

val rev_filteri : (int -> 'a -> bool) -> 'a list -> 'a list

val rev_filter_some : 'a option list -> 'a list

val filter_some : 'a option list -> 'a list

val rev_filter_ok : ('a, 'b) result list -> 'a list

val filter_ok : ('a, 'b) result list -> 'a list

val rev_filter_error : ('a, 'b) result list -> 'b list

val filter_error : ('a, 'b) result list -> 'b list

val rev_filter_left : ('a, 'b) Either.t list -> 'a list

val filter_left : ('a, 'b) Either.t list -> 'a list

val rev_filter_right : ('a, 'b) Either.t list -> 'b list

val filter_right : ('a, 'b) Either.t list -> 'b list

val rev_filter_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  ('a list, 'trace) result

val filter_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  ('a list, 'trace) result

val rev_filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val rev_filter_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list, 'trace) result Lwt.t

val filter_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list, 'trace) result Lwt.t

val filter_p : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val rev_filteri_e : 
  (int -> 'a -> (bool, 'trace) result) ->
  'a list ->
  ('a list, 'trace) result

val filteri_e : 
  (int -> 'a -> (bool, 'trace) result) ->
  'a list ->
  ('a list, 'trace) result

val rev_filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val rev_filteri_es : 
  (int -> 'a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list, 'trace) result Lwt.t

val filteri_es : 
  (int -> 'a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list, 'trace) result Lwt.t

val filteri_p : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t

val rev_partition : ('a -> bool) -> 'a list -> 'a list * 'a list

val partition : ('a -> bool) -> 'a list -> 'a list * 'a list

val rev_partition_map : 
  ('a -> ('b, 'c) Either.t) ->
  'a list ->
  'b list * 'c list

val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c list

val rev_partition_result : ('a, 'b) result list -> 'a list * 'b list

val partition_result : ('a, 'b) result list -> 'a list * 'b list

val rev_partition_either : ('a, 'b) Either.t list -> 'a list * 'b list

val partition_either : ('a, 'b) Either.t list -> 'a list * 'b list

val rev_partition_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  ('a list * 'a list, 'trace) result

val partition_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  ('a list * 'a list, 'trace) result

val rev_partition_s : 
  ('a -> bool Lwt.t) ->
  'a list ->
  ('a list * 'a list) Lwt.t

val partition_s : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.t

val rev_partition_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list * 'a list, 'trace) result Lwt.t

val partition_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  ('a list * 'a list, 'trace) result Lwt.t

val partition_p : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.t

val rev_partition_map_e : 
  ('a -> (('b, 'c) Either.t, 'trace) result) ->
  'a list ->
  ('b list * 'c list, 'trace) result

val partition_map_e : 
  ('a -> (('b, 'c) Either.t, 'trace) result) ->
  'a list ->
  ('b list * 'c list, 'trace) result

val rev_partition_map_s : 
  ('a -> ('b, 'c) Either.t Lwt.t) ->
  'a list ->
  ('b list * 'c list) Lwt.t

val partition_map_s : 
  ('a -> ('b, 'c) Either.t Lwt.t) ->
  'a list ->
  ('b list * 'c list) Lwt.t

val rev_partition_map_es : 
  ('a -> (('b, 'c) Either.t, 'trace) result Lwt.t) ->
  'a list ->
  ('b list * 'c list, 'trace) result Lwt.t

val partition_map_es : 
  ('a -> (('b, 'c) Either.t, 'trace) result Lwt.t) ->
  'a list ->
  ('b list * 'c list, 'trace) result Lwt.t

val partition_map_p : 
  ('a -> ('b, 'c) Either.t Lwt.t) ->
  'a list ->
  ('b list * 'c list) Lwt.t

val iter : ('a -> unit) -> 'a list -> unit

val iter_e : ('a -> (unit, 'trace) result) -> 'a list -> (unit, 'trace) result

val iter_s : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.t

val iter_es : 
  ('a -> (unit, 'trace) result Lwt.t) ->
  'a list ->
  (unit, 'trace) result Lwt.t

val iter_p : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.t

val iteri : (int -> 'a -> unit) -> 'a list -> unit

val iteri_e : 
  (int -> 'a -> (unit, 'trace) result) ->
  'a list ->
  (unit, 'trace) result

val iteri_s : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.t

val iteri_es : 
  (int -> 'a -> (unit, 'trace) result Lwt.t) ->
  'a list ->
  (unit, 'trace) result Lwt.t

val iteri_p : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.t

val map : ('a -> 'b) -> 'a list -> 'b list

val map_e : ('a -> ('b, 'trace) result) -> 'a list -> ('b list, 'trace) result

val map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val map_es : 
  ('a -> ('b, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list

val mapi_e : 
  (int -> 'a -> ('b, 'trace) result) ->
  'a list ->
  ('b list, 'trace) result

val mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val mapi_es : 
  (int -> 'a -> ('b, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_map : ('a -> 'b) -> 'a list -> 'b list

val rev_mapi : (int -> 'a -> 'b) -> 'a list -> 'b list

val rev_map_e : 
  ('a -> ('b, 'trace) result) ->
  'a list ->
  ('b list, 'trace) result

val rev_map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_map_es : 
  ('a -> ('b, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val rev_map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_mapi_e : 
  (int -> 'a -> ('b, 'trace) result) ->
  'a list ->
  ('b list, 'trace) result

val rev_mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_mapi_es : 
  (int -> 'a -> ('b, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val rev_mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_filter_map : ('a -> 'b option) -> 'a list -> 'b list

val rev_filter_map_e : 
  ('a -> ('b option, 'trace) result) ->
  'a list ->
  ('b list, 'trace) result

val filter_map_e : 
  ('a -> ('b option, 'trace) result) ->
  'a list ->
  ('b list, 'trace) result

val rev_filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t

val filter_map : ('a -> 'b option) -> 'a list -> 'b list

val filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_filter_map_es : 
  ('a -> ('b option, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val filter_map_es : 
  ('a -> ('b option, 'trace) result Lwt.t) ->
  'a list ->
  ('b list, 'trace) result Lwt.t

val filter_map_p : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t

val concat_map : ('a -> 'b list) -> 'a list -> 'b list

val concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t

val concat_map_e : 
  ('a -> ('b list, 'error) result) ->
  'a list ->
  ('b list, 'error) result

val concat_map_es : 
  ('a -> ('b list, 'error) result Lwt.t) ->
  'a list ->
  ('b list, 'error) result Lwt.t

val concat_map_p : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_concat_map : ('a -> 'b list) -> 'a list -> 'b list

val rev_concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t

val rev_concat_map_e : 
  ('a -> ('b list, 'error) result) ->
  'a list ->
  ('b list, 'error) result

val rev_concat_map_es : 
  ('a -> ('b list, 'error) result Lwt.t) ->
  'a list ->
  ('b list, 'error) result Lwt.t

val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a

val fold_left_e : 
  ('a -> 'b -> ('a, 'trace) result) ->
  'a ->
  'b list ->
  ('a, 'trace) result

val fold_left_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.t

val fold_left_es : 
  ('a -> 'b -> ('a, 'trace) result Lwt.t) ->
  'a ->
  'b list ->
  ('a, 'trace) result Lwt.t

val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list

val fold_left_map_e : 
  ('a -> 'b -> ('a * 'c, 'trace) result) ->
  'a ->
  'b list ->
  ('a * 'c list, 'trace) result

val fold_left_map_s : 
  ('a -> 'b -> ('a * 'c) Lwt.t) ->
  'a ->
  'b list ->
  ('a * 'c list) Lwt.t

val fold_left_map_es : 
  ('a -> 'b -> ('a * 'c, 'trace) result Lwt.t) ->
  'a ->
  'b list ->
  ('a * 'c list, 'trace) result Lwt.t

val fold_left_i : (int -> 'a -> 'b -> 'a) -> 'a -> 'b list -> 'a

val fold_left_i_e : 
  (int -> 'a -> 'b -> ('a, 'trace) result) ->
  'a ->
  'b list ->
  ('a, 'trace) result

val fold_left_i_s : (int -> 'a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.t

val fold_left_i_es : 
  (int -> 'a -> 'b -> ('a, 'trace) result Lwt.t) ->
  'a ->
  'b list ->
  ('a, 'trace) result Lwt.t

val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b

val fold_right_e : 
  ('a -> 'b -> ('b, 'trace) result) ->
  'a list ->
  'b ->
  ('b, 'trace) result

val fold_right_s : ('a -> 'b -> 'b Lwt.t) -> 'a list -> 'b -> 'b Lwt.t

val fold_right_es : 
  ('a -> 'b -> ('b, 'trace) result Lwt.t) ->
  'a list ->
  'b ->
  ('b, 'trace) result Lwt.t

val iter2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (unit, 'trace) result) ->
  'a list ->
  'b list ->
  (unit, 'trace) result

val iter2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> unit Lwt.t) ->
  'a list ->
  'b list ->
  (unit, 'trace) result Lwt.t

val iter2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (unit, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  (unit, 'trace) result Lwt.t

val map2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> ('c, 'trace) result) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result

val map2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c Lwt.t) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result Lwt.t

val map2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> ('c, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result Lwt.t

val rev_map2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> ('c, 'trace) result) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result

val rev_map2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c Lwt.t) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result Lwt.t

val rev_map2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> ('c, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  ('c list, 'trace) result Lwt.t

val fold_left2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> ('a, 'trace) result) ->
  'a ->
  'b list ->
  'c list ->
  ('a, 'trace) result

val fold_left2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> 'a Lwt.t) ->
  'a ->
  'b list ->
  'c list ->
  ('a, 'trace) result Lwt.t

val fold_left2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> ('a, 'trace) result Lwt.t) ->
  'a ->
  'b list ->
  'c list ->
  ('a, 'trace) result Lwt.t

val fold_right2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> ('c, 'trace) result) ->
  'a list ->
  'b list ->
  'c ->
  ('c, 'trace) result

val fold_right2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> 'c Lwt.t) ->
  'a list ->
  'b list ->
  'c ->
  ('c, 'trace) result Lwt.t

val fold_right2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> 'c -> ('c, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  'c ->
  ('c, 'trace) result Lwt.t

val for_all : ('a -> bool) -> 'a list -> bool

val for_all_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  (bool, 'trace) result

val for_all_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t

val for_all_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  (bool, 'trace) result Lwt.t

val for_all_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t

val exists : ('a -> bool) -> 'a list -> bool

val exists_e : 
  ('a -> (bool, 'trace) result) ->
  'a list ->
  (bool, 'trace) result

val exists_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t

val exists_es : 
  ('a -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  (bool, 'trace) result Lwt.t

val exists_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t

val for_all2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (bool, 'trace) result) ->
  'a list ->
  'b list ->
  (bool, 'trace) result

val for_all2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> bool Lwt.t) ->
  'a list ->
  'b list ->
  (bool, 'trace) result Lwt.t

val for_all2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  (bool, 'trace) result Lwt.t

val exists2_e : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (bool, 'trace) result) ->
  'a list ->
  'b list ->
  (bool, 'trace) result

val exists2_s : 
  when_different_lengths:'trace ->
  ('a -> 'b -> bool Lwt.t) ->
  'a list ->
  'b list ->
  (bool, 'trace) result Lwt.t

val exists2_es : 
  when_different_lengths:'trace ->
  ('a -> 'b -> (bool, 'trace) result Lwt.t) ->
  'a list ->
  'b list ->
  (bool, 'trace) result Lwt.t

val combine_drop : 'a list -> 'b list -> ('a * 'b) list

val combine_with_leftovers : 
  'a list ->
  'b list ->
  ('a * 'b) list * ('a list, 'b list) Either.t option

val product : 'a list -> 'b list -> ('a * 'b) list

val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int

val compare_lengths : 'a list -> 'b list -> int

val compare_length_with : 'a list -> int -> int

val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool

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 shuffle : rng:Random.State.t -> 'a list -> 'a list

val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

val to_seq : 'a list -> 'a Seq.t

val of_seq : 'a Seq.t -> 'a list

val init_ep : 
  when_negative_length:'error ->
  int ->
  (int -> ('a, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  ('a list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val filter_ep : 
  ('a -> (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('a list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val filteri_ep : 
  (int -> 'a -> (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('a list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val partition_ep : 
  ('a -> (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('a list * 'a list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val partition_map_ep : 
  ('a ->
    (('b, 'c) Either.t, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list * 'c list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val iter_ep : 
  ('a -> (unit, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  (unit, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val iteri_ep : 
  (int -> 'a -> (unit, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  (unit, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val map_ep : 
  ('a -> ('b, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val mapi_ep : 
  (int -> 'a -> ('b, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val rev_map_ep : 
  ('a -> ('b, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val rev_mapi_ep : 
  (int -> 'a -> ('b, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val filter_map_ep : 
  ('a -> ('b option, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val concat_map_ep : 
  ('a -> ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  ('b list, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val for_all_ep : 
  ('a -> (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

val exists_ep : 
  ('a -> (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t) ->
  'a list ->
  (bool, 'error Tezos_error_monad.TzTrace.trace) result Lwt.t

package octez-libs