@tellahq/rescript 10.1.0-alpha.2 → 10.1.4-republish-2

package/lib/ocaml/int32.mli

@@ -1,186 +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 Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** 32-bit integers.
-
-   This module provides operations on the type [t]
-   of signed 32-bit integers.  Unlike the built-in [int] type,
-   the type [t] is guaranteed to be exactly 32-bit wide on all
-   platforms.  All arithmetic operations over [t] are taken
-   modulo 2{^32}.
-
-   Performance notice: values of type [t] occupy more memory
-   space than values of type [int], and arithmetic operations on
-   [t] are generally slower than those on [int].  Use [t]
-   only when the application requires exact 32-bit arithmetic. *)
-type t = int
-(** An alias for the type of 32-bit integers. *)
-
-val zero : t
-(** The 32-bit integer 0. *)
-
-val one : t
-(** The 32-bit integer 1. *)
-
-val minus_one : t
-(** The 32-bit integer -1. *)
-
-external neg : t -> t = "%negint"
-(** Unary negation. *)
-
-external add : t -> t -> t = "%addint"
-(** Addition. *)
-
-external sub : t -> t -> t = "%subint"
-(** Subtraction. *)
-
-external mul : t -> t -> t = "%mulint"
-(** Multiplication. *)
-
-external div : t -> t -> t = "%divint"
-(** Integer division.  Raise [Division_by_zero] if the second
-   argument is zero.  This division rounds the real quotient of
-   its arguments towards zero, as specified for {!Pervasives.(/)}. *)
-
-external rem : t -> t -> t = "%modint"
-(** Integer remainder.  If [y] is not zero, the result
-   of [Int32.rem x y] satisfies the following property:
-   [x = Int32.add (Int32.mul (Int32.div x y) y) (Int32.rem x y)].
-   If [y = 0], [Int32.rem x y] raises [Division_by_zero]. *)
-
-val succ : t -> t
-(** Successor.  [Int32.succ x] is [Int32.add x Int32.one]. *)
-
-val pred : t -> t
-(** Predecessor.  [Int32.pred x] is [Int32.sub x Int32.one]. *)
-
-val abs : t -> t
-(** Return the absolute value of its argument. *)
-
-val max_int : t
-(** The greatest representable 32-bit integer, 2{^31} - 1. *)
-
-val min_int : t
-(** The smallest representable 32-bit integer, -2{^31}. *)
-
-
-external logand : t -> t -> t = "%andint"
-(** Bitwise logical and. *)
-
-external logor : t -> t -> t = "%orint"
-(** Bitwise logical or. *)
-
-external logxor : t -> t -> t = "%xorint"
-(** Bitwise logical exclusive or. *)
-
-val lognot : t -> t
-(** Bitwise logical negation. *)
-
-external shift_left : t -> int -> t = "%lslint"
-(** [Int32.shift_left x y] shifts [x] to the left by [y] bits.
-   The result is unspecified if [y < 0] or [y >= 32]. *)
-
-external shift_right : t -> int -> t = "%asrint"
-(** [Int32.shift_right x y] shifts [x] to the right by [y] bits.
-   This is an arithmetic shift: the sign bit of [x] is replicated
-   and inserted in the vacated bits.
-   The result is unspecified if [y < 0] or [y >= 32]. *)
-
-external shift_right_logical : t -> int -> t = "%lsrint"
-(** [Int32.shift_right_logical x y] shifts [x] to the right by [y] bits.
-   This is a logical shift: zeroes are inserted in the vacated bits
-   regardless of the sign of [x].
-   The result is unspecified if [y < 0] or [y >= 32]. *)
-
-external of_int : int -> t = "%identity"
-(** Convert the given integer (type [int]) to a 32-bit integer
-    (type [t]). *)
-
-external to_int : t -> int = "%identity"
-(** Convert the given 32-bit integer (type [t]) to an
-   integer (type [int]).  On 32-bit platforms, the 32-bit integer
-   is taken modulo 2{^31}, i.e. the high-order bit is lost
-   during the conversion.  On 64-bit platforms, the conversion
-   is exact. *)
-
-external of_float : float -> t
-  = "?int_of_float"
-(** Convert the given floating-point number to a 32-bit integer,
-   discarding the fractional part (truncate towards 0).
-   The result of the conversion is undefined if, after truncation,
-   the number is outside the range \[{!Int32.min_int}, {!Int32.max_int}\]. *)
-
-external to_float : t -> float
-  = "?int_to_float" 
-(** Convert the given 32-bit integer to a floating-point number. *)
-
-external of_string : string -> t = "?int_of_string"
-(** Convert the given string to a 32-bit integer.
-   The string is read in decimal (by default, or if the string 
-   begins with [0u]) or in hexadecimal, octal or binary if the
-   string begins with [0x], [0o] or [0b] respectively.
-
-   The [0u] prefix reads the input as an unsigned integer in the range
-   [[0, 2*Int32.max_int+1]].  If the input exceeds {!Int32.max_int}
-   it is converted to the signed integer
-   [Int32.min_int + input - Int32.max_int - 1].
-
-   The [_] (underscore) character can appear anywhere in the string
-   and is ignored.
-   Raise [Failure "Int32.of_string"] if the given string is not
-   a valid representation of an integer, or if the integer represented
-   exceeds the range of integers representable in type [t]. *)
-
-val of_string_opt: string -> t option
-(** Same as [of_string], but return [None] instead of raising.
-    @since 4.05 *)
-
-
-val to_string : t -> string
-(** Return the string representation of its argument, in signed decimal. *)
-
-external bits_of_float : float -> t
-  = "?int_bits_of_float"
-(** Return the internal representation of the given float according
-   to the IEEE 754 floating-point 'single format' bit layout.
-   Bit 31 of the result represents the sign of the float;
-   bits 30 to 23 represent the (biased) exponent; bits 22 to 0
-   represent the mantissa. *)
-
-external float_of_bits : t -> float
-  = "?int_float_of_bits" 
-(** Return the floating-point number whose internal representation,
-   according to the IEEE 754 floating-point 'single format' bit layout,
-   is the given [t]. *)
-
-
-
-val compare: t -> t -> int
-(** The comparison function for 32-bit integers, with the same specification as
-    {!Pervasives.compare}.  Along with the type [t], this function [compare]
-    allows the module [Int32] to be passed as argument to the functors
-    {!Set.Make} and {!Map.Make}. *)
-
-val equal: t -> t -> bool
-(** The equal function for int32s.
-    @since 4.03.0 *)
-
-(**/**)
-
-(** {1 Deprecated functions} *)
-
-external format : string -> t -> string = "?format_int"
-(** Do not use this deprecated function.  Instead,
-   used {!Printf.sprintf} with a [%l...] format. *)

package/lib/ocaml/int64.ml

@@ -1,72 +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 Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(* Module [Int64]: 64-bit integers *)
-
-external neg : int64 -> int64 = "%int64_neg"
-external add : int64 -> int64 -> int64 = "%int64_add"
-external sub : int64 -> int64 -> int64 = "%int64_sub"
-external mul : int64 -> int64 -> int64 = "%int64_mul"
-external div : int64 -> int64 -> int64 = "%int64_div"
-external rem : int64 -> int64 -> int64 = "%int64_mod"
-external logand : int64 -> int64 -> int64 = "%int64_and"
-external logor : int64 -> int64 -> int64 = "%int64_or"
-external logxor : int64 -> int64 -> int64 = "%int64_xor"
-external shift_left : int64 -> int -> int64 = "%int64_lsl"
-external shift_right : int64 -> int -> int64 = "%int64_asr"
-external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
-external of_int : int -> int64 = "%int64_of_int"
-external to_int : int64 -> int = "%int64_to_int"
-external of_float : float -> int64
-  = "?int64_of_float"  
-external to_float : int64 -> float
-  = "?int64_to_float" 
-external of_int32 : int -> int64 = "%int64_of_int32"
-external to_int32 : int64 -> int = "%int64_to_int32"
-
-let zero = 0L
-let one = 1L
-let minus_one = -1L
-(* let succ n = add n 1L *)
-external succ : int64 -> int64 = "?int64_succ"
-let pred n = sub n 1L
-let abs n = if n >= 0L then n else neg n
-let min_int = 0x8000000000000000L
-let max_int = 0x7FFFFFFFFFFFFFFFL
-let lognot n = logxor n (-1L)
-
-external format : string -> int64 -> string = "?int64_format"
-external to_string : int64 -> string = "?int64_to_string"
-
-external of_string : string -> int64 = "?int64_of_string"
-
-let of_string_opt s =
-  (* TODO: expose a non-raising primitive directly. *)
-  try Some (of_string s)
-  with Failure _ -> None
-
-
-
-external bits_of_float : float -> int64
-  = "?int64_bits_of_float" 
-  
-external float_of_bits : int64 -> float
-  = "?int64_float_of_bits" 
-  
-
-type t = int64
-
-let compare (x: t) (y: t) = Pervasives.compare x y
-let equal (x: t) (y: t) = compare x y = 0

package/lib/ocaml/int64.mli

@@ -1,197 +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 Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** 64-bit integers.
-
-   This module provides operations on the type [int64] of
-   signed 64-bit integers.  Unlike the built-in [int] type,
-   the type [int64] is guaranteed to be exactly 64-bit wide on all
-   platforms.  All arithmetic operations over [int64] are taken
-   modulo 2{^64}
-
-   Performance notice: values of type [int64] occupy more memory
-   space than values of type [int], and arithmetic operations on
-   [int64] are generally slower than those on [int].  Use [int64]
-   only when the application requires exact 64-bit arithmetic.
-*)
-
-val zero : int64
-(** The 64-bit integer 0. *)
-
-val one : int64
-(** The 64-bit integer 1. *)
-
-val minus_one : int64
-(** The 64-bit integer -1. *)
-
-external neg : int64 -> int64 = "%int64_neg"
-(** Unary negation. *)
-
-external add : int64 -> int64 -> int64 = "%int64_add"
-(** Addition. *)
-
-external sub : int64 -> int64 -> int64 = "%int64_sub"
-(** Subtraction. *)
-
-external mul : int64 -> int64 -> int64 = "%int64_mul"
-(** Multiplication. *)
-
-external div : int64 -> int64 -> int64 = "%int64_div"
-(** Integer division.  Raise [Division_by_zero] if the second
-   argument is zero.  This division rounds the real quotient of
-   its arguments towards zero, as specified for {!Pervasives.(/)}. *)
-
-external rem : int64 -> int64 -> int64 = "%int64_mod"
-(** Integer remainder.  If [y] is not zero, the result
-   of [Int64.rem x y] satisfies the following property:
-   [x = Int64.add (Int64.mul (Int64.div x y) y) (Int64.rem x y)].
-   If [y = 0], [Int64.rem x y] raises [Division_by_zero]. *)
-
-val succ : int64 -> int64
-(** Successor.  [Int64.succ x] is [Int64.add x Int64.one]. *)
-
-val pred : int64 -> int64
-(** Predecessor.  [Int64.pred x] is [Int64.sub x Int64.one]. *)
-
-val abs : int64 -> int64
-(** Return the absolute value of its argument. *)
-
-val max_int : int64
-(** The greatest representable 64-bit integer, 2{^63} - 1. *)
-
-val min_int : int64
-(** The smallest representable 64-bit integer, -2{^63}. *)
-
-external logand : int64 -> int64 -> int64 = "%int64_and"
-(** Bitwise logical and. *)
-
-external logor : int64 -> int64 -> int64 = "%int64_or"
-(** Bitwise logical or. *)
-
-external logxor : int64 -> int64 -> int64 = "%int64_xor"
-(** Bitwise logical exclusive or. *)
-
-val lognot : int64 -> int64
-(** Bitwise logical negation. *)
-
-external shift_left : int64 -> int -> int64 = "%int64_lsl"
-(** [Int64.shift_left x y] shifts [x] to the left by [y] bits.
-   The result is unspecified if [y < 0] or [y >= 64]. *)
-
-external shift_right : int64 -> int -> int64 = "%int64_asr"
-(** [Int64.shift_right x y] shifts [x] to the right by [y] bits.
-   This is an arithmetic shift: the sign bit of [x] is replicated
-   and inserted in the vacated bits.
-   The result is unspecified if [y < 0] or [y >= 64]. *)
-
-external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
-(** [Int64.shift_right_logical x y] shifts [x] to the right by [y] bits.
-   This is a logical shift: zeroes are inserted in the vacated bits
-   regardless of the sign of [x].
-   The result is unspecified if [y < 0] or [y >= 64]. *)
-
-external of_int : int -> int64 = "%int64_of_int"
-(** Convert the given integer (type [int]) to a 64-bit integer
-    (type [int64]). *)
-
-external to_int : int64 -> int = "%int64_to_int"
-(** Convert the given 64-bit integer (type [int64]) to an
-   integer (type [int]).  On 64-bit platforms, the 64-bit integer
-   is taken modulo 2{^63}, i.e. the high-order bit is lost
-   during the conversion.  On 32-bit platforms, the 64-bit integer
-   is taken modulo 2{^31}, i.e. the top 33 bits are lost
-   during the conversion. *)
-
-external of_float : float -> int64
-  = "?int64_of_float" 
-(** Convert the given floating-point number to a 64-bit integer,
-   discarding the fractional part (truncate towards 0).
-   The result of the conversion is undefined if, after truncation,
-   the number is outside the range \[{!Int64.min_int}, {!Int64.max_int}\]. *)
-
-external to_float : int64 -> float
-  = "?int64_to_float" 
-(** Convert the given 64-bit integer to a floating-point number. *)
-
-
-external of_int32 : int -> int64 = "%int64_of_int32"
-(** Convert the given 32-bit integer (type [int])
-   to a 64-bit integer (type [int64]). *)
-
-external to_int32 : int64 -> int = "%int64_to_int32"
-(** Convert the given 64-bit integer (type [int64]) to a
-   32-bit integer (type [int]). The 64-bit integer
-   is taken modulo 2{^32}, i.e. the top 32 bits are lost
-   during the conversion.  *)
-
-
-external of_string : string -> int64 = "?int64_of_string"
-(** Convert the given string to a 64-bit integer.
-   The string is read in decimal (by default, or if the string 
-   begins with [0u]) or in hexadecimal, octal or binary if the
-   string begins with [0x], [0o] or [0b] respectively.
-
-   The [0u] prefix reads the input as an unsigned integer in the range
-   [[0, 2*Int64.max_int+1]].  If the input exceeds {!Int64.max_int}
-   it is converted to the signed integer
-   [Int64.min_int + input - Int64.max_int - 1].
-
-   The [_] (underscore) character can appear anywhere in the string
-   and is ignored.
-   Raise [Failure "Int64.of_string"] if the given string is not
-   a valid representation of an integer, or if the integer represented
-   exceeds the range of integers representable in type [int64]. *)
-
-val of_string_opt: string -> int64 option
-(** Same as [of_string], but return [None] instead of raising.
-    @since 4.05 *)
-
-val to_string : int64 -> string
-(** Return the string representation of its argument, in decimal. *)
-
-external bits_of_float : float -> int64
-  = "?int64_bits_of_float" 
-(** Return the internal representation of the given float according
-   to the IEEE 754 floating-point 'double format' bit layout.
-   Bit 63 of the result represents the sign of the float;
-   bits 62 to 52 represent the (biased) exponent; bits 51 to 0
-   represent the mantissa. *)
-
-external float_of_bits : int64 -> float
-  = "?int64_float_of_bits" 
-(** Return the floating-point number whose internal representation,
-   according to the IEEE 754 floating-point 'double format' bit layout,
-   is the given [int64]. *)
-
-type t = int64
-(** An alias for the type of 64-bit integers. *)
-
-val compare: t -> t -> int
-(** The comparison function for 64-bit integers, with the same specification as
-    {!Pervasives.compare}.  Along with the type [t], this function [compare]
-    allows the module [Int64] to be passed as argument to the functors
-    {!Set.Make} and {!Map.Make}. *)
-
-val equal: t -> t -> bool
-(** The equal function for int64s.
-    @since 4.03.0 *)
-
-(**/**)
-
-(** {1 Deprecated functions} *)
-
-external format : string -> int64 -> string = "?int64_format"
-(** Do not use this deprecated function.  Instead,
-   used {!Printf.sprintf} with a [%L...] format. *)

package/lib/ocaml/internal_map.cppo.ml

@@ -1,230 +0,0 @@
-[@@@bs.config {flags = [| "-bs-noassertfalse" |]}]
-#ifdef TYPE_STRING
-type key = string
-#elif defined TYPE_INT
-type key = int
-#else 
-  [%error "unknown type"]
-#endif 
-
-module N = Belt_internalAVLtree
-module A = Belt_Array 
-module S = Belt_SortArray
-
-
-
-type  'a t = (key,'a) N.t
-
-let rec add  t (x : key) (data : _)  = 
-  match t with
-  | None -> 
-    N.singleton x data 
-  | Some n  ->
-    let k = n.N.key in 
-    if x = k then
-      Some (N.updateValue n data)
-    else
-      let v = n.N.value  in 
-      if x < k then
-        N.bal (add n.N.left x data ) k v n.N.right
-      else
-        N.bal n.N.left k v (add n.N.right x data )
-
-let rec get n (x : key)  =
-  match n with 
-    None -> None
-  | Some n  ->
-    let v = n.N.key in 
-    if x = v then Some n.N.value
-    else get (if x < v then n.N.left else n.N.right) x 
-
-let rec getUndefined n (x : key) = 
-  match n with 
-  | None ->
-    Js.undefined
-  | Some n  ->
-    let v = n.N.key in 
-    if x = v then Js.Undefined.return n.N.value
-    else getUndefined (if x < v then n.N.left else n.N.right) x 
-
-let rec getExn n (x : key) =
-  match n with 
-  | None -> raise Not_found
-  | Some n -> 
-    let v = n.N.key in 
-    if x = v then n.N.value
-    else getExn (if x < v then n.N.left else n.N.right) x
-
-let rec getWithDefault n (x : key) def =
-  match n with 
-  | None -> def    
-  | Some n -> 
-    let v = n.N.key in 
-    if x = v then n.N.value
-    else getWithDefault (if x < v then n.N.left else n.N.right) x def
-    
-let rec has n (x : key)= 
-  match n with 
-    None -> false
-  | Some n (* Node(l, v, d, r, _) *) ->
-    let v = n.N.key in 
-    x = v || has (if x < v then n.N.left else n.N.right) x 
-
-let rec remove n (x : key) = 
-  match n with 
-  |  None -> n    
-  |  Some n ->
-    let {N.left = l; key = v; right = r} = n in 
-    if x = v then
-      match l, r with
-      | None, _ -> r 
-      | _, None -> l 
-      | _, Some rn -> 
-        let kr, vr = ref rn.key, ref rn.value in 
-        let r = N.removeMinAuxWithRef rn kr vr in 
-        N.bal l kr.contents vr.contents r 
-    else if x < v then
-      N.(bal (remove l x ) v n.value r)
-    else
-      N.(bal l v n.value (remove r x ))
-
-let rec splitAux (x : key) (n : _ N.node) : _ t * _ option  * _ t =  
-  let {N.left = l; key = v; value = d; right = r} = n in  
-  if x = v then (l, Some d, r)
-  else     
-  if x < v then
-    match l with 
-    | None -> 
-      None, None, Some n
-    | Some l -> 
-      let (ll, pres, rl) = splitAux x l in (ll, pres, N.join rl v d r)
-  else
-    match r with 
-    | None ->
-      Some n, None, None
-    | Some r -> 
-      let (lr, pres, rr) = splitAux x r in (N.join l v d lr, pres, rr)
-
-
-let split (x : key) n =
-  match n with 
-    None ->
-    None, None, None
-  | Some n -> 
-    splitAux x n 
-
-let rec mergeU s1 s2 f =
-  match s1, s2 with
-    (None, None) -> None
-  | Some n (* (Node (l1, v1, d1, r1, h1), _)*), _ 
-    when (n.N.height >= (match s2 with None -> 0 | Some n -> n.N.height)) ->
-    let {N.left = l1; key = v1; value = d1; right = r1} = n in 
-    let (l2, d2, r2) = split v1 s2 in
-    N.concatOrJoin (mergeU l1 l2 f) v1 (f v1 (Some d1) d2 [@bs]) (mergeU r1 r2 f)
-  | (_, Some n) (* Node (l2, v2, d2, r2, h2) *)  ->
-    let {N.left = l2; key = v2; value = d2; right = r2} = n in 
-    let (l1, d1, r1) = split v2 s1 in
-    N.concatOrJoin (mergeU l1 l2 f) v2 (f v2 d1 (Some d2) [@bs]) (mergeU r1 r2 f)
-  | _ ->
-    assert false
-
-let merge s1 s2 f = mergeU s1 s2 (fun [@bs] a b c -> f a b c)
-    
-let rec compareAux e1 e2 vcmp =
-  match e1,e2 with 
-  | h1::t1, h2::t2 ->
-    let c = Pervasives.compare (h1.N.key : key) h2.N.key  in 
-    if c = 0 then 
-      let cx = vcmp h1.N.value h2.N.value [@bs] in 
-      if cx = 0 then
-        compareAux 
-          (N.stackAllLeft  h1.N.right t1 ) 
-          (N.stackAllLeft h2.N.right t2)
-          vcmp 
-      else  cx
-    else c 
-  | _, _ -> 0    
-
-let cmpU s1 s2 cmp = 
-  let len1, len2 = N.size s1, N.size s2 in 
-  if len1 = len2 then 
-    compareAux 
-      (N.stackAllLeft s1 []) 
-      (N.stackAllLeft s2 []) 
-      cmp 
-  else if len1 < len2 then -1 
-  else 1 
-
-let cmp s1 s2 f = cmpU s1 s2 (fun[@bs] a b -> f a b)
-
-let rec eqAux e1 e2  eq =
-  match e1,e2 with 
-  | h1::t1, h2::t2 ->
-    if (h1.N.key : key) =  h2.N.key  && 
-       eq h1.N.value h2.N.value [@bs] then
-      eqAux (
-        N.stackAllLeft  h1.N.right t1 ) 
-        (N.stackAllLeft h2.N.right t2)
-        eq
-    else  false    
-  | _, _ -> true (*end *)  
-
-let eqU s1 s2 eq =      
-  let len1,len2 = N.size s1, N.size s2 in 
-  if len1 = len2 then 
-    eqAux 
-      (N.stackAllLeft s1 [])
-      (N.stackAllLeft s2 []) eq 
-  else false  
-
-let eq s1 s2 f = eqU s1 s2 (fun[@bs] a b -> f a b)
-    
-let rec addMutate  (t : _ t) x data : _ t =   
-  match t with 
-  | None -> N.singleton x data
-  | Some nt -> 
-    let k = nt.N.key in 
-    (* let  c = (Belt_Cmp.getCmpInternal cmp) x k [@bs] in   *)
-    if x = k then begin     
-      nt.N.key <- x;
-      nt.value <- data;
-      Some nt
-    end      
-    else
-      let l, r = (nt.N.left, nt.N.right) in 
-      (if x < k then                   
-         let ll = addMutate  l x data in
-         nt.left <- ll
-       else   
-         nt.right <- (addMutate r x data);
-      );
-      Some (N.balMutate nt)  
-
-let fromArray (xs : (key * _) array) =   
-  let len = A.length xs in 
-  if len = 0 then None
-  else
-    let next = 
-        ref (S.strictlySortedLengthU xs 
-        (fun[@bs] (x0,_) (y0,_) -> 
-            x0 < y0
-        ))
-      in 
-    let result  = ref (
-      if next.contents >= 0 then 
-        N.fromSortedArrayAux xs 0 next.contents 
-      else begin   
-        next .contents<- - next.contents; 
-        N.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<- addMutate  result.contents k v 
-    done ;
-    result.contents         
-
-
-
-
-