Flow_map (melange.Js_parser.Flow

type t0('k, 'v) =

| Empty
| Leaf of {
1. v: 'k,
2. d: 'v,
}
| Node of {
1. h: int,
2. v: 'k,
3. d: 'v,
4. l: t0('k, 'v),
5. r: t0('k, 'v),
}

;

type partial_node('k, 'v) = {

h: int,
v: 'k,
d: 'v,
l: t0('k, 'v),
r: t0('k, 'v),

};

type leaf_tuple('k, 'v) = ('k, 'v);

let (~!!): t0('k, 'v) => leaf_tuple('k, 'v);

let (~!): t0('k, 'v) => partial_node('k, 'v);

let height: t0('a, 'b) => int;

let singleton: 'a => 'b => t0('c, 'd);

let sorted_two_nodes_larger: t0('a, 'b) => 'c => 'd => t0('e, 'f);

let sorted_two_nodes_smaller: 'a => 'b => t0('c, 'd) => t0('e, 'f);

let create: t0('a, 'b) => 'c => 'd => t0('e, 'f) => t0('g, 'h);

let of_increasing_iterator_unchecked: (unit => ('a, 'b)) => int => t0('c, 'd);

let of_sorted_array_unchecked: array(('a, 'b)) => t0('a, 'b);

let node: t0('a, 'b) => 'c => 'd => t0('e, 'f) => t0('g, 'h);

let bal: t0('a, 'b) => 'c => 'd => t0('a, 'b) => t0('e, 'f);

let empty: t0('a, 'b);

let is_empty: t0('a, 'b) => bool;

type enumeration('key, 'a) =

| End
| More('key, 'a, t0('key, 'a), enumeration('key, 'a))

;

let cons_enum: t0('a, 'b) => enumeration('c, 'd) => enumeration('c, 'd);

let min_binding: t0('a, 'b) => leaf_tuple('a, 'b);

let min_binding_from_node_unsafe: t0('a, 'b) => leaf_tuple('c, 'd);

let min_binding_opt: t0('a, 'b) => option(('c, 'd));

let max_binding: t0('a, 'b) => leaf_tuple('a, 'b);

let max_binding_opt: t0('a, 'b) => option(('c, 'd));

let remove_min_binding_from_node_unsafe: t0('a, 'b) => t0('c, 'd);

let add_min_node: t0('a, 'b) => t0('c, 'd) => t0('a, 'b);

let add_min_binding: 'a => 'b => t0('c, 'd) => t0('e, 'f);

let add_max_node: t0('a, 'b) => t0('c, 'd) => t0('a, 'b);

let add_max_binding: 'a => 'b => t0('c, 'd) => t0('e, 'f);

let internal_merge: t0('a, 'b) => t0('a, 'b) => t0('a, 'b);

let join: t0('a, 'b) => 'c => 'd => t0('a, 'b) => t0('e, 'f);

let concat: t0('a, 'b) => t0('a, 'b) => t0('a, 'b);

let concat_or_join: t0('a, 'b) => 'c => option('d) => t0('a, 'b) => t0('a, 'b);

let iter: ('a => 'b => unit) => t0('c, 'd) => unit;

let map: ('a => 'b) => t0('c, 'd) => t0('e, 'f);

let mapi: ('a => 'b => 'c) => t0('d, 'e) => t0('f, 'g);

let fold: ('a => 'b => 'c => 'd) => t0('e, 'f) => 'g => 'h;

let keys_aux: list('a) => t0('b, 'c) => list('a);

let keys: t0('a, 'b) => list('a);

let ordered_keys: t0('a, 'b) => list('a);

let for_all: ('a => 'b => bool) => t0('c, 'd) => bool;

let exists: ('a => 'b => bool) => t0('c, 'd) => bool;

let filter: ('a => 'b => bool) => t0('c, 'd) => t0('c, 'd);

let cardinal: t0('a, 'b) => int;

let bindings_aux: 
  list(leaf_tuple('a, 'b)) =>
  t0('a, 'b) =>
  list(leaf_tuple('a, 'b));

let bindings: t0('a, 'b) => list(leaf_tuple('a, 'b));

type t1('k, 'v) = t0('k, 'v) =

| Empty
| Leaf of {
1. v: 'k,
2. d: 'v,
}
| Node of {
1. h: int,
2. v: 'k,
3. d: 'v,
4. l: t0('k, 'v),
5. r: t0('k, 'v),
}

;

module type OrderedType = { ... };

module type S = { ... };

module Make: (Ord: OrderedType) => S with type key = Ord.t;