Tezos_error_monad.TzLwtreslib.List · tezos-error-monad 14.0

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 TzTrace.trace ) result Lwt.t ) ->
  ( 'a list, 'error TzTrace.trace ) result Lwt.t

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tezos-error-monad 15.1 15.0 14.0 13.0 12.3 12.0 11.1 11.0 10.2 9.7 9.4 9.3 9.2 9.1 9.0 8.3 8.2 8.1 8.0 7.4 7.3 7.2 7.1 7.0

tezos-error-monad