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

package/lib/ocaml/int32.mli

@@ -0,0 +1,186 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 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

@@ -0,0 +1,72 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 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

@@ -0,0 +1,197 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 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

@@ -0,0 +1,230 @@
+[@@@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         
+
+
+
+
+