@tellahq/rescript 10.1.4-republish-1 → 10.1.4-republish-2

package/lib/ocaml/belt_internalAVLtree.ml

@@ -1,762 +0,0 @@
-(***********************************************************************)
-(*                                                                     *)
-(*                                OCaml                                *)
-(*                                                                     *)
-(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
-(*                                                                     *)
-(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
-(*  en Automatique.  All rights reserved.  This file is distributed    *)
-(*  under the terms of the GNU Library General Public License, with    *)
-(*  the special exception on linking described in file ../LICENSE.     *)
-(*                                                                     *)
-(***********************************************************************)
-(** Almost rewritten  by authors of ReScript                       *)
-
-[@@@bs.config {flags = [|"-bs-noassertfalse" |] }]
-type ('k, 'v) node  = {
-  mutable key : 'k; [@bs.as "k"]
-  mutable value : 'v; [@bs.as "v"]
-  mutable height : int; [@bs.as "h"]
-  mutable left : ('k,'v) t; [@bs.as "l"]
-  mutable right : ('k,'v) t [@bs.as "r"]
-}
-and ('key, 'a) t = ('key, 'a) node option
-
-
-type ('k, 'id) cmp = ('k, 'id) Belt_Id.cmp
-
-module A = Belt_Array
-module S = Belt_SortArray
-
-
-let treeHeight (n : _ t) =
-  match  n with
-    None -> 0
-  | Some n -> n.height
-
-let rec copy n =
-  match  n with
-  | None -> n
-  | Some n ->    
-    Some { n with left = copy n.left;  right = copy n.right}
-
-let create l x d r =
-  let hl, hr  = treeHeight l,  treeHeight r in
-  Some { left = l ; key = x ; value = d ; right = r ; height = (if hl >= hr then hl + 1 else hr + 1)}
-
-let singleton x d =
-  Some { left = None; key = x;  value = d; right = None; height = 1}
-
-let heightGe l r =
-  match  l,  r with
-  | _, None -> true
-  | Some hl, Some hr -> hl.height >= hr.height
-  | None, Some _ -> false
-
-let updateValue n newValue =
-  if n.value == newValue then n
-  else
-    { left = n.left;
-      right = n.right;
-      key = n.key;
-      value = newValue;
-      height = n.height }
-
-let bal l x d r =
-  let hl = match  l with None -> 0 | Some n -> n.height in
-  let hr = match  r with None -> 0 | Some n -> n.height in
-  if hl > hr + 2 then 
-    match l with None -> assert false  | Some ({left = ll;   right = lr} as l) ->
-      if treeHeight ll >= treeHeight lr then
-        create ll l.key l.value (create lr x d r)
-      else 
-        match lr with None -> assert false | Some lr -> 
-          create (create ll l.key l.value lr.left) lr.key lr.value (create lr.right x d r)
-  else if hr > hl + 2 then
-    match r with None -> assert false | Some ({left = rl; right = rr} as r) -> 
-      if treeHeight rr >= treeHeight rl then
-        create (create l x d rl) r.key r.value rr
-      else
-        match rl with None -> assert false | Some rl ->
-          create (create l x d rl.left) rl.key rl.value (create rl.right r.key r.value rr)
-  else
-    Some { left = l; key = x ; value = d ; right = r ; height = (if hl >= hr then hl + 1 else hr + 1)}
-
-
-let rec minKey0Aux n =
-  match  n.left with
-  | None -> n.key 
-  | Some n -> minKey0Aux n
-
-let minKey n =
-  match  n with
-  | None -> None
-  | Some n -> Some (minKey0Aux n)
-
-let minKeyUndefined n =
-  match  n with
-  | None -> Js.undefined
-  | Some n -> Js.Undefined.return (minKey0Aux n)
-
-let rec maxKey0Aux n =
-  match  n.right with
-  | None -> n.key 
-  | Some n -> maxKey0Aux n
-
-let maxKey n =
-  match  n with
-  | None -> None
-  | Some n -> Some (maxKey0Aux n)
-
-let maxKeyUndefined n =
-  match  n with
-  | None -> Js.undefined
-  | Some n -> Js.Undefined.return (maxKey0Aux n)
-
-let rec minKV0Aux n =
-  match  n.left with
-  | None -> n.key  , n.value
-  | Some n -> minKV0Aux n
-
-let minimum n =
-  match  n with
-    None -> None
-  | Some n -> Some (minKV0Aux n)
-
-let minUndefined n =
-  match  n with
-  | None -> Js.undefined
-  | Some n -> Js.Undefined.return (minKV0Aux n)
-
-let rec maxKV0Aux n =
-  match  n.right with
-  | None -> n.key , n.value
-  | Some n -> maxKV0Aux n
-
-let maximum n =
-  match  n with
-  | None -> None
-  | Some n -> Some (maxKV0Aux n)
-
-let maxUndefined n =
-  match  n with
-  | None -> Js.undefined
-  | Some n -> Js.Undefined.return (maxKV0Aux n)
-
-(* TODO: use kv ref *)
-let rec removeMinAuxWithRef n kr vr =
-  match n.left with
-  | None ->  kr .contents<- n.key; vr.contents<- n.value; n.right
-  | Some ln -> bal (removeMinAuxWithRef ln kr vr) n.key n.value n.right
-
-
-
-let isEmpty x = match  x with None -> true | Some _ -> false
-
-let rec stackAllLeft v s =
-  match  v with
-  | None -> s
-  | Some x -> stackAllLeft x.left (x::s)
-
-let rec findFirstByU n p =
-  match  n with
-  | None -> None 
-  | Some n ->
-    let left =  findFirstByU n.left p in
-    if left <> None then left
-      else
-        let  {key = v; value =  d} = n  in
-        let pvd = p v d [@bs] in
-        if pvd then Some(v, d)
-          else 
-            let right =  findFirstByU n.right p in
-            if right <> None then right else None
-
-let findFirstBy n p = findFirstByU n (fun [@bs] a b -> p a b)
-
-let rec forEachU n f =
-  match  n with
-  | None -> ()
-  | Some n ->
-    forEachU  n.left f ;
-    f n.key n.value [@bs];
-    forEachU n.right f
-
-let forEach n f = forEachU n (fun [@bs] a b -> f a b)
-
-let rec mapU n f =
-  match  n with
-    None  ->
-    None
-  | Some n  ->
-    let newLeft =  mapU n.left f in
-    let newD = f n.value [@bs] in
-    let newRight = mapU n.right f in
-    Some { left = newLeft; key = n.key;  value = newD; right = newRight; height = n.height}
-
-let map n f = mapU n (fun[@bs] a -> f a)
-
-let rec mapWithKeyU n f =
-  match  n with
-    None ->
-    None
-  | Some n ->
-    let key = n.key  in
-    let newLeft =  mapWithKeyU n.left f in
-    let newD = f key n.value [@bs] in
-    let newRight =  mapWithKeyU n.right f in
-    Some { left = newLeft; key; value = newD; right = newRight; height = n.height}
-
-let mapWithKey n f = mapWithKeyU n (fun [@bs] a b -> f a b)
-
-let rec reduceU m accu f =
-  match  m with
-    None -> accu
-  | Some n  ->
-    let {left = l; key =  v; value = d; right = r} = n  in
-    reduceU
-      r
-      (f (reduceU l accu f) v d [@bs]) f
-
-let reduce m accu f = reduceU m accu (fun [@bs] a b c -> f a b c)
-
-let rec everyU  n p =
-  match  n with
-    None -> true
-  | Some n  ->
-    p n.key n.value [@bs] &&
-    everyU n.left  p &&
-    everyU n.right p
-let every n p = everyU n (fun [@bs] a b -> p a b)
-
-let rec someU n p =
-  match  n with
-    None -> false
-  | Some n  ->
-    p n.key n.value [@bs] ||
-    someU n.left p ||
-    someU n.right p
-let some n p  = someU n (fun[@bs] a b -> p a b)
-(* Beware: those two functions assume that the added k is *strictly*
-   smaller (or bigger) than all the present keys in the tree; it
-   does not test for equality with the current min (or max) key.
-
-   Indeed, they are only used during the "join" operation which
-   respects this precondition.
-*)
-
-let rec addMinElement n k v  =
-  match  n with
-  | None -> singleton k v
-  | Some n
-    ->
-    bal (addMinElement n.left k v ) n.key n.value n.right
-
-let rec addMaxElement n k v  =
-  match  n with
-  | None -> singleton k v
-  | Some n
-    ->
-    bal n.left n.key n.value (addMaxElement n.right k v )
-
-(* Same as create and bal, but no assumptions are made on the
-   relative heights of l and r. *)
-
-let rec join ln v d rn =
-  match ( ln,  rn) with
-    (None, _) -> addMinElement rn v d
-  | (_, None) -> addMaxElement ln v d
-  | Some l, Some r  ->
-    let {left = ll; key = lv; value =  ld; right = lr; height =  lh} = l  in
-    let {left = rl; key = rv; value = rd; right = rr; height = rh} = r  in
-    if lh > rh + 2 then bal ll lv ld (join lr v d rn) else
-    if rh > lh + 2 then bal (join ln v d rl) rv rd rr else
-      create ln v d rn
-
-(* Merge two trees l and r into one.
-   All elements of l must precede the elements of r.
-   No assumption on the heights of l and r. *)
-
-let concat t1 t2 =
-  match ( t1,  t2) with
-    (None, _) -> t2
-  | (_, None) -> t1
-  | (_, Some t2n) ->
-    let kr, vr = ref t2n.key, ref t2n.value in
-    let t2r = removeMinAuxWithRef t2n kr vr in
-    join t1 kr.contents vr.contents t2r
-
-let concatOrJoin t1 v d t2 =
-  match d with
-  | Some d -> join t1 v d t2
-  | None -> concat t1 t2
-
-let rec keepSharedU n p =
-  match  n with
-    None -> None
-  | Some n  ->
-    (* call `p` in the expected left-to-right order *)
-    let  {key = v; value = d} =  n   in
-    let newLeft =  keepSharedU n.left p in
-    let pvd = p v d [@bs] in
-    let newRight = keepSharedU n.right p in
-    if pvd then join newLeft v d newRight else concat newLeft newRight
-
-let keepShared n p = keepSharedU n (fun [@bs] a b -> p a b)
-
-let rec keepMapU n p =
-  match  n with
-    None -> None
-  | Some n  ->
-    (* call `p` in the expected left-to-right order *)
-    let  {key = v; value = d} =  n  in
-    let newLeft = keepMapU n.left  p in
-    let pvd = p v d [@bs] in
-    let newRight = keepMapU n.right p in
-    match pvd with
-    | None -> concat newLeft newRight
-    | Some d -> join newLeft v d newRight
-
-let keepMap n p = keepMapU n (fun[@bs] a b -> p a b)
-
-let rec partitionSharedU n p =
-  match  n with
-    None -> (None, None)
-  | Some n  ->
-    let  {key; value } =  n  in
-    (* call `p` in the expected left-to-right order *)
-    let (lt, lf) =  partitionSharedU n.left p in
-    let pvd = p key value [@bs] in
-    let (rt, rf) = partitionSharedU n.right p in
-    if pvd
-    then (join lt key value rt, concat lf rf)
-    else (concat lt rt, join lf key value rf)
-
-let partitionShared n p = partitionSharedU n (fun [@bs] a b -> p a b)
-
-let rec lengthNode n =
-  let {left = l; right = r } = n  in
-  let sizeL =
-    match  l with
-    | None -> 0
-    | Some l ->
-      lengthNode l  in
-  let sizeR =
-    match  r with
-    | None -> 0
-    | Some r -> lengthNode r in
-  1 + sizeL + sizeR
-
-let size n =
-  match  n with
-  | None -> 0
-  | Some n  ->
-    lengthNode n
-
-let rec toListAux n accu =
-  match  n with
-  | None -> accu
-  | Some n  ->
-    let {left = l; right =  r ; key = k; value = v} = n in
-    toListAux l ((k, v) :: (toListAux r accu ))
-
-let toList s =
-  toListAux  s []
-
-
-let rec checkInvariantInternal (v : _ t) =
-  match  v with
-  | None -> ()
-  | Some n ->
-    let l,r = n.left , n.right in
-    let diff = treeHeight l - treeHeight r  in
-    assert (diff <=2 && diff >= -2 );
-    checkInvariantInternal l;
-    checkInvariantInternal r
-
-
-let rec fillArrayKey n i arr =
-  let {left = l; key = v; right  = r} = n  in
-  let next =
-    match  l with
-    | None -> i
-    | Some l ->
-      fillArrayKey l i arr in
-  A.setUnsafe arr next v;
-  let rnext = next + 1 in
-  match  r with
-  | None -> rnext
-  | Some r ->
-    fillArrayKey r rnext arr
-
-let rec fillArrayValue n i arr =
-  let l,r = n.left,  n.right in
-  let next =
-    match  l with
-    | None -> i
-    | Some l ->
-      fillArrayValue l i arr in
-  A.setUnsafe arr next n.value;
-  let rnext = next + 1 in
-  match  r with
-  | None -> rnext
-  | Some r ->
-    fillArrayValue r rnext arr
-
-let rec fillArray n i arr =
-  let l,v,r = n.left, n.key , n.right in
-  let next =
-    match  l with
-    | None -> i
-    | Some l ->
-      fillArray l i arr in
-  A.setUnsafe arr next (v, n.value) ;
-  let rnext = next + 1 in
-  match  r with
-  | None -> rnext
-  | Some r ->
-    fillArray r rnext arr
-
-
-
-(* let rec fillArrayWithPartition n cursor arr p =
-  let l,v,r = n.left, n.key , n.right in
-  (match  l with
-   | None -> ()
-   | Some l ->
-     fillArrayWithPartition l cursor arr p);
-  (if p v [@bs] then begin
-      let c = forwardGet cursor in
-      A.setUnsafe arr c (v,n.value);
-      forwardSet cursor (c + 1)
-    end
-   else begin
-     let c = backwardGet cursor in
-     A.setUnsafe arr c (v, n.value);
-     backwardSet cursor (c - 1)
-   end);
-  match  r with
-  | None -> ()
-  | Some r ->
-    fillArrayWithPartition r cursor arr  p
-
-let rec fillArrayWithFilter n i arr p =
-  let l,v,r = n.left, n.key , n.right in
-  let next =
-    match  l with
-    | None -> i
-    | Some l ->
-      fillArrayWithFilter l i arr p in
-  let rnext =
-    if p v [@bs] then
-      (A.setUnsafe arr next (v, n.value);
-       next + 1
-      )
-    else next in
-  match  r with
-  | None -> rnext
-  | Some r ->
-    fillArrayWithFilter r rnext arr  p
- *)
-
-let toArray n =
-  match  n with
-  | None -> [||]
-  | Some n ->
-    let size = lengthNode n in
-    let v = A.makeUninitializedUnsafe size in
-    ignore (fillArray n 0 v : int);  (* may add assertion *)
-    v
-
-let keysToArray n =
-  match  n with
-  | None -> [||]
-  | Some n ->
-    let size = lengthNode n in
-    let v = A.makeUninitializedUnsafe size in
-    ignore (fillArrayKey n 0 v : int);  (* may add assertion *)
-    v
-
-let valuesToArray n =
-  match  n with
-  | None -> [||]
-  | Some n ->
-    let size = lengthNode n in
-    let v = A.makeUninitializedUnsafe size in
-    ignore (fillArrayValue n 0 v : int);  (* may add assertion *)
-    v
-
-let rec fromSortedArrayRevAux arr off len =
-  match len with
-  | 0 -> None
-  | 1 -> let k, v = (A.getUnsafe arr off) in singleton k v
-  | 2 ->
-    let (x0,y0),(x1,y1) = A.(getUnsafe arr off, getUnsafe arr (off - 1) )
-    in
-    Some { left = (singleton x0 y0);  key = x1; value = y1; height = 2; right = None}
-  | 3 ->
-    let (x0,y0),(x1,y1),(x2,y2) =
-      A.(getUnsafe arr off,
-         getUnsafe arr (off - 1),
-         getUnsafe arr (off - 2)) in
-    Some { left = (singleton x0 y0);
-      right = (singleton x2 y2);
-      key = x1;
-      value = y1;
-      height = 2 }
-  | _ ->
-    let nl = len / 2 in
-    let left = fromSortedArrayRevAux arr off nl in
-    let midK,midV = A.getUnsafe arr (off - nl) in
-    let right =
-      fromSortedArrayRevAux arr (off - nl - 1) (len - nl - 1) in
-    create left midK midV right
-
-
-let rec fromSortedArrayAux arr off len =
-  match len with
-  | 0 -> None
-  | 1 -> let k, v = (A.getUnsafe arr off) in singleton k v
-  | 2 ->
-    let (x0,y0),(x1,y1) = A.(getUnsafe arr off, getUnsafe arr (off + 1) )
-    in
-    Some {left = (singleton x0 y0);  key = x1 ; value = y1; height = 2; right = None}
-  | 3 ->
-    let (x0,y0),(x1,y1),(x2,y2) =
-      A.(getUnsafe arr off,
-         getUnsafe arr (off + 1),
-         getUnsafe arr (off + 2)) in
-    Some { left = (singleton x0 y0);
-      right = (singleton x2 y2);
-      key = x1; value = y1;
-      height = 2}
-  | _ ->
-    let nl = len / 2 in
-    let left = fromSortedArrayAux arr off nl in
-    let midK, midV = A.getUnsafe arr (off + nl) in
-    let right =
-      fromSortedArrayAux arr (off + nl + 1) (len - nl - 1) in
-    create left midK midV right
-
-let fromSortedArrayUnsafe arr =
-  fromSortedArrayAux arr 0 (A.length arr)
-
-let rec compareAux e1 e2 ~kcmp ~vcmp =
-  match e1,e2 with
-  | h1::t1, h2::t2 ->
-    let c = (Belt_Id.getCmpInternal kcmp) h1.key h2.key [@bs] in
-    if c = 0 then
-      let cx = vcmp h1.value h2.value [@bs] in
-      if cx = 0 then
-        compareAux ~kcmp ~vcmp
-          (stackAllLeft  h1.right t1 )
-          (stackAllLeft h2.right t2)
-      else  cx
-    else c
-  | _, _ -> 0
-
-let rec eqAux e1 e2 ~kcmp ~veq =
-  match e1,e2 with
-  | h1::t1, h2::t2 ->
-    if (Belt_Id.getCmpInternal kcmp) h1.key h2.key [@bs] = 0 &&
-       veq h1.value h2.value [@bs] then
-      eqAux ~kcmp ~veq (
-        stackAllLeft  h1.right t1 ) (stackAllLeft h2.right t2)
-    else  false
-  | _, _ -> true
-
-let cmpU s1 s2 ~kcmp ~vcmp =
-  let len1,len2 = size s1, size s2 in
-  if len1 = len2 then
-    compareAux (stackAllLeft s1 []) (stackAllLeft s2 []) ~kcmp ~vcmp
-  else  if len1 < len2 then -1 else 1
-
-let cmp s1 s2 ~kcmp ~vcmp =
-  cmpU s1 s2 ~kcmp ~vcmp:(fun[@bs] a b -> vcmp a b)
-
-let eqU s1 s2 ~kcmp ~veq =
-  let len1, len2 = size s1, size s2 in
-  if len1 = len2 then
-    eqAux (stackAllLeft s1 []) (stackAllLeft s2 []) ~kcmp ~veq
-  else false
-
-let eq s1 s2 ~kcmp ~veq =
-  eqU s1 s2 ~kcmp ~veq:(fun [@bs] a b -> veq a b)
-
-let rec get  n x ~cmp =
-  match  n with
-    None -> None
-  | Some n (* Node(l, v, d, r, _) *)  ->
-    let v = n.key  in
-    let c = (Belt_Id.getCmpInternal cmp) x v [@bs] in
-    if c = 0 then Some n.value
-    else get ~cmp  (if c < 0 then n.left else n.right) x
-
-let rec getUndefined  n x ~cmp =
-  match  n with
-  | None -> Js.undefined
-  | Some n  ->
-    let v = n.key  in
-    let c = (Belt_Id.getCmpInternal cmp) x v [@bs] in
-    if c = 0 then Js.Undefined.return (n.value )
-    else getUndefined ~cmp  (if c < 0 then n.left else n.right) x
-
-let rec getExn   n x  ~cmp =
-  match  n with
-    None ->
-    raise Not_found
-  | Some n (* Node(l, v, d, r, _)*) ->
-    let v = n.key  in
-    let c = (Belt_Id.getCmpInternal cmp) x v [@bs] in
-    if c = 0 then n.value
-    else getExn ~cmp  (if c < 0 then n.left else n.right) x
-
-let rec getWithDefault   n x def ~cmp =
-  match  n with
-    None ->
-    def
-  | Some n (* Node(l, v, d, r, _)*) ->
-    let v = n.key  in
-    let c = (Belt_Id.getCmpInternal cmp) x v [@bs] in
-    if c = 0 then n.value
-    else getWithDefault ~cmp  (if c < 0 then n.left else n.right) x def
-
-let rec has  n x ~cmp =
-  match  n with
-    None ->
-    false
-  | Some n (* Node(l, v, d, r, _) *) ->
-    let v = n.key  in
-    let c = (Belt_Id.getCmpInternal cmp) x v [@bs] in
-    c = 0 || has ~cmp (if c < 0 then n.left else n.right) x
-
-
-(******************************************************************)
-
-(*
-  L rotation, Some root node
-*)
-let rotateWithLeftChild k2 =
-  match k2.left with None -> assert false
-  | Some k1 ->
-  (k2.left <- k1.right);
-  (k1.right <- (Some k2 ));
-  let hlk2, hrk2 = (treeHeight k2.left, (treeHeight k2.right)) in
-  (k2.height <-
-     (Pervasives.max hlk2 hrk2 + 1));
-  let hlk1, hk2 = (treeHeight k1.left, k2.height) in
-  (k1.height <- (Pervasives.max hlk1 hk2 + 1));
-  k1
-(* right rotation *)
-let rotateWithRightChild k1 =
-  match k1.right with None -> assert false
-  | Some k2 ->
-  (k1.right <- k2.left);
-  (k2.left <- (Some k1));
-  let hlk1, hrk1 = ((treeHeight k1.left), (treeHeight k1.right)) in
-  (k1.height <- (Pervasives.max  hlk1 hrk1 + 1));
-  let hrk2, hk1 = (treeHeight k2.right, k1.height) in
-  (k2.height <- (Pervasives.max  hrk2 hk1 + 1));
-  k2
-
-(*
-  double l rotation
-*)
-let doubleWithLeftChild k3 =
-  let k3l = match k3.left with None -> assert false | Some x -> x in 
-  let v = rotateWithRightChild k3l in
-  (k3.left <- (Some v ));
-  rotateWithLeftChild k3
-
-let doubleWithRightChild k2 =
-  let k2r = match k2.right with None -> assert false | Some x -> x in   
-  let v = rotateWithLeftChild k2r in
-  (k2.right <- (Some v));
-  rotateWithRightChild k2
-
-let heightUpdateMutate t =
-  let hlt, hrt = (treeHeight t.left,(treeHeight t.right)) in
-  t.height <- (Pervasives.max hlt hrt  + 1);
-  t
-
-let balMutate nt  =
-  let l, r = (nt.left, nt.right) in
-  let hl, hr =  (treeHeight l, treeHeight r) in
-  if hl > 2 +  hr then
-    match l with None -> assert false 
-    | Some {left = ll;  right = lr} ->
-    (if heightGe ll lr then
-       heightUpdateMutate (rotateWithLeftChild nt)
-     else
-       heightUpdateMutate (doubleWithLeftChild nt)
-    )
-  else
-  if hr > 2 + hl  then
-    match r with None -> assert false 
-    | Some {left = rl; right = rr} ->
-    (if heightGe rr rl then
-       heightUpdateMutate (rotateWithRightChild nt)
-     else
-       heightUpdateMutate (doubleWithRightChild nt)
-    )
-  else
-    begin
-      nt.height <- (Pervasives.max hl hr + 1);
-      nt
-    end
-
-let rec updateMutate (t : _ t) x data ~cmp =
-  match  t with
-  | None -> singleton x data
-  | Some nt ->
-    let k = nt.key in
-    let  c = (Belt_Id.getCmpInternal cmp) x k [@bs] in
-    if c = 0 then begin
-      nt.value <- data;
-      Some nt
-    end
-    else
-      let l, r = (nt.left, nt.right) in
-      (if c < 0 then
-         let ll = updateMutate ~cmp l x data in
-         nt.left <- ll
-       else
-         nt.right <- (updateMutate ~cmp r x data);
-      );
-      Some (balMutate nt)
-
-let fromArray (xs : _ array) ~cmp =
-  let len = A.length xs in
-  if len = 0 then None
-  else
-    let next =
-      ref (S.strictlySortedLengthU xs
-             (fun[@bs] (x0,_) (y0,_) ->
-                (Belt_Id.getCmpInternal cmp) x0 y0 [@bs] < 0
-             ))
-    in
-    let result  = ref (
-        if next.contents >= 0 then
-          fromSortedArrayAux xs 0 next.contents
-        else begin
-          next .contents<- - next.contents;
-          fromSortedArrayRevAux xs (next.contents - 1) (next.contents)
-        end
-      ) in
-    for i = next.contents to len - 1 do
-      let k, v = (A.getUnsafe xs i)  in
-      result .contents<- updateMutate ~cmp result.contents k v
-    done ;
-    result.contents
-
-
-let rec removeMinAuxWithRootMutate nt n =
-  let rn, ln = n.right, n.left in
-  match  ln with
-  | None ->
-    nt.key <- n.key;
-    nt.value <- n.value;
-    rn
-  | Some ln ->
-    n.left <- (removeMinAuxWithRootMutate nt ln);
-    Some (balMutate n)