List (tezos-base.Tezos_base.TzPervasives.List)

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.

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 ) Stdlib.result

val nil_s : 'a list Lwt.t

val nil_es : ( 'a list, 'trace ) Stdlib.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 ) Stdlib.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 ) Stdlib.result

val rev_combine : 
  when_different_lengths:'trace ->
  'a list ->
  'b list ->
  ( ('a * 'b) list, 'trace ) Stdlib.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 ) Stdlib.result

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val find_map_es : 
  ( 'a -> ( 'b option, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b option, 'trace ) Stdlib.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 ) Stdlib.result list -> 'a list

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

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

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

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

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

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

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

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

val filter_e : 
  ( 'a -> ( bool, 'trace ) Stdlib.result ) ->
  'a list ->
  ( 'a list, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'a list, 'trace ) Stdlib.result Lwt.t

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

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

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

val filteri_e : 
  ( int -> 'a -> ( bool, 'trace ) Stdlib.result ) ->
  'a list ->
  ( 'a list, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'a list, 'trace ) Stdlib.result Lwt.t

val filteri_es : 
  ( int -> 'a -> ( bool, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'a list, 'trace ) Stdlib.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 ) Stdlib.Either.t ) ->
  'a list ->
  'b list * 'c list

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

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

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

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

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

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

val partition_e : 
  ( 'a -> ( bool, 'trace ) Stdlib.result ) ->
  'a list ->
  ( 'a list * 'a list, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'a list * 'a list, 'trace ) Stdlib.result Lwt.t

val partition_es : 
  ( 'a -> ( bool, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'a list * 'a list, 'trace ) Stdlib.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 ) Stdlib.Either.t, 'trace ) Stdlib.result ) ->
  'a list ->
  ( 'b list * 'c list, 'trace ) Stdlib.result

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

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

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

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

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

val partition_map_p : 
  ( 'a -> ( 'b, 'c ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( unit, 'trace ) Stdlib.result

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

val iter_es : 
  ( 'a -> ( unit, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( unit, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( unit, 'trace ) Stdlib.result

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

val iteri_es : 
  ( int -> 'a -> ( unit, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( unit, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result

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

val map_es : 
  ( 'a -> ( 'b, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result

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

val mapi_es : 
  ( int -> 'a -> ( 'b, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result

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

val rev_map_es : 
  ( 'a -> ( 'b, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result

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

val rev_mapi_es : 
  ( int -> 'a -> ( 'b, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result

val filter_map_e : 
  ( 'a -> ( 'b option, 'trace ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.result Lwt.t

val filter_map_es : 
  ( 'a -> ( 'b option, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'error ) Stdlib.result

val concat_map_es : 
  ( 'a -> ( 'b list, 'error ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( 'b list, 'error ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( 'b list, 'error ) Stdlib.result

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

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

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

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

val fold_left_es : 
  ( 'a -> 'b -> ( 'a, 'trace ) Stdlib.result Lwt.t ) ->
  'a ->
  'b list ->
  ( 'a, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a ->
  'b list ->
  ( 'a * 'c list, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a ->
  'b list ->
  ( 'a * 'c list, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a ->
  'b list ->
  ( 'a, 'trace ) Stdlib.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 ) Stdlib.result Lwt.t ) ->
  'a ->
  'b list ->
  ( 'a, 'trace ) Stdlib.result Lwt.t

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val for_all_es : 
  ( 'a -> ( bool, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( bool, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  ( bool, 'trace ) Stdlib.result

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

val exists_es : 
  ( 'a -> ( bool, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  ( bool, 'trace ) Stdlib.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 ) Stdlib.result ) ->
  'a list ->
  'b list ->
  ( bool, 'trace ) Stdlib.result

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

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

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

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

val exists2_es : 
  when_different_lengths:'trace ->
  ( 'a -> 'b -> ( bool, 'trace ) Stdlib.result Lwt.t ) ->
  'a list ->
  'b list ->
  ( bool, 'trace ) Stdlib.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 ) Stdlib.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:Stdlib.Random.State.t -> '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 init_ep : 
  when_negative_length:'error ->
  int ->
  ( int -> ( 'a, 'error Tezos_error_monad.TzTrace.trace ) Stdlib.result Lwt.t ) ->
  ( 'a list, 'error Tezos_error_monad.TzTrace.trace ) Stdlib.result Lwt.t

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

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

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

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

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

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

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

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

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

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

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

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

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

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