Hash_queue (merkle_address.Merkle_address.Hash

type key = t

val length : ( 'a, 'b ) Core_kernel__Hash_queue.t -> int

val is_empty : ( 'a, 'b ) Core_kernel__Hash_queue.t -> bool

val iter : ( 'b, 'a ) Core_kernel__Hash_queue.t -> f:( 'a -> unit ) -> unit

val fold : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  init:'accum ->
  f:( 'accum -> 'a -> 'accum ) ->
  'accum

val fold_result : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  init:'accum ->
  f:( 'accum -> 'a -> ( 'accum, 'e ) Base__.Result.t ) ->
  ( 'accum, 'e ) Base__.Result.t

val fold_until : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  init:'accum ->
  f:
    ( 'accum ->
      'a ->
      ( 'accum, 'final ) Base__Container_intf.Continue_or_stop.t ) ->
  finish:( 'accum -> 'final ) ->
  'final

val exists : ( 'b, 'a ) Core_kernel__Hash_queue.t -> f:( 'a -> bool ) -> bool

val for_all : ( 'b, 'a ) Core_kernel__Hash_queue.t -> f:( 'a -> bool ) -> bool

val count : ( 'b, 'a ) Core_kernel__Hash_queue.t -> f:( 'a -> bool ) -> int

val sum : 
  (module Base__Container_intf.Summable with type t = 'sum) ->
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  f:( 'a -> 'sum ) ->
  'sum

val find : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  f:( 'a -> bool ) ->
  'a option

val find_map : 
  ( 'c, 'a ) Core_kernel__Hash_queue.t ->
  f:( 'a -> 'b option ) ->
  'b option

val to_list : ( 'b, 'a ) Core_kernel__Hash_queue.t -> 'a list

val to_array : ( 'b, 'a ) Core_kernel__Hash_queue.t -> 'a array

val min_elt : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  compare:( 'a -> 'a -> int ) ->
  'a option

val max_elt : 
  ( 'b, 'a ) Core_kernel__Hash_queue.t ->
  compare:( 'a -> 'a -> int ) ->
  'a option

val invariant : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  Core_kernel__.Import.unit

val create : 
  ?growth_allowed:Core_kernel__.Import.bool ->
  ?size:Core_kernel__.Import.int ->
  Core_kernel__.Import.unit ->
  ( key, 'data ) Core_kernel__Hash_queue.t

val clear : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  Core_kernel__.Import.unit

val mem : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  Core_kernel__.Import.bool

val lookup : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data Core_kernel__.Import.option

val lookup_exn : ( 'key, 'data ) Core_kernel__Hash_queue.t -> 'key -> 'data

val enqueue : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  'key ->
  'data ->
  [ `Key_already_present | `Ok ]

val enqueue_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  'key ->
  'data ->
  Core_kernel__.Import.unit

val enqueue_back : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  [ `Key_already_present | `Ok ]

val enqueue_back_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  Core_kernel__.Import.unit

val enqueue_front : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  [ `Key_already_present | `Ok ]

val enqueue_front_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  Core_kernel__.Import.unit

val lookup_and_move_to_back : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data Core_kernel__.Import.option

val lookup_and_move_to_back_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data

val lookup_and_move_to_front : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data Core_kernel__.Import.option

val lookup_and_move_to_front_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data

val first : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'data Core_kernel__.Import.option

val first_with_key : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  ('key * 'data) Core_kernel__.Import.option

val keys : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key Core_kernel__.Import.list

val dequeue : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  'data Core_kernel__.Import.option

val dequeue_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  'data

val dequeue_back : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'data Core_kernel__.Import.option

val dequeue_back_exn : ( 'key, 'data ) Core_kernel__Hash_queue.t -> 'data

val dequeue_front : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'data Core_kernel__.Import.option

val dequeue_front_exn : ( 'key, 'data ) Core_kernel__Hash_queue.t -> 'data

val dequeue_with_key : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  ('key * 'data) Core_kernel__.Import.option

val dequeue_with_key_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  'key * 'data

val dequeue_back_with_key : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  ('key * 'data) Core_kernel__.Import.option

val dequeue_back_with_key_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key * 'data

val dequeue_front_with_key : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  ('key * 'data) Core_kernel__.Import.option

val dequeue_front_with_key_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key * 'data

val dequeue_all : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  f:( 'data -> Core_kernel__.Import.unit ) ->
  Core_kernel__.Import.unit

val remove : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  [ `No_such_key | `Ok ]

val remove_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  Core_kernel__.Import.unit

val lookup_and_remove : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data Core_kernel__.Import.option

val replace : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  [ `No_such_key | `Ok ]

val replace_exn : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  'key ->
  'data ->
  Core_kernel__.Import.unit

val drop : 
  ?n:Core_kernel__.Import.int ->
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  [ `back | `front ] ->
  Core_kernel__.Import.unit

val drop_front : 
  ?n:Core_kernel__.Import.int ->
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  Core_kernel__.Import.unit

val drop_back : 
  ?n:Core_kernel__.Import.int ->
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  Core_kernel__.Import.unit

val iteri : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  f:( key:'key -> data:'data -> Core_kernel__.Import.unit ) ->
  Core_kernel__.Import.unit

val foldi : 
  ( 'key, 'data ) Core_kernel__Hash_queue.t ->
  init:'b ->
  f:( 'b -> key:'key -> data:'data -> 'b ) ->
  'b

type 'data t = ( key, 'data ) Core_kernel__Hash_queue.t

val sexp_of_t : 
  ( 'data -> Ppx_sexp_conv_lib.Sexp.t ) ->
  'data t ->
  Ppx_sexp_conv_lib.Sexp.t