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

package/lib/ocaml/belt_MutableMapInt.ml

@@ -0,0 +1,172 @@
+# 2 "others/mapm.cppo.ml"
+module I = Belt_internalMapInt
+type key = int
+# 10 "others/mapm.cppo.ml"
+module N = Belt_internalAVLtree
+module A = Belt_Array 
+
+
+
+
+type 'a t = {
+  mutable data : 'a I.t
+} 
+
+
+let make () = {data = None}
+let isEmpty m = N.isEmpty m.data
+let clear m =  m.data<- None
+(* let singleton k v = t ~data:(N.singleton k v) *)
+
+let minKeyUndefined m = N.minKeyUndefined m.data
+let minKey m = N.minKey m.data
+let maxKeyUndefined m = N.maxKeyUndefined m.data
+let maxKey m = N.maxKey m.data
+let minimum m = N.minimum m.data
+let minUndefined m = N.minUndefined m.data
+let maximum m = N.maximum m.data
+let maxUndefined m = N.maxUndefined m.data
+
+let set (m : _ t) k v = 
+  let old_data = m.data in 
+  let v = I.addMutate old_data k v in 
+  if v != old_data then 
+    m.data <-v 
+
+let forEachU d f = N.forEachU d.data f
+let forEach d f = forEachU d (fun[@bs] a b -> f a b)    
+let mapU d f = {data = N.mapU d.data f}
+let map d f = mapU d (fun[@bs] a -> f a )    
+let mapWithKeyU d f = { data = (N.mapWithKeyU d.data f)}
+let mapWithKey d f = mapWithKeyU d (fun [@bs] a b -> f a b)    
+let reduceU d acc f  = N.reduceU d.data acc f
+let reduce d acc f = reduceU d acc (fun[@bs] a b c -> f a b c)    
+let everyU d f = N.everyU d.data f
+let every d f = everyU d (fun[@bs] a b -> f a b)    
+let someU d f = N.someU d.data f    
+let some d f = someU d (fun[@bs] a b -> f a b)
+let size d = N.size d.data
+let toList d = N.toList d.data
+let toArray d = N.toArray d.data
+let keysToArray d = N.keysToArray d.data
+let valuesToArray d = N.valuesToArray d.data
+let checkInvariantInternal d = N.checkInvariantInternal d.data
+let has d v = I.has d.data v 
+
+
+let rec removeMutateAux nt (x : key)= 
+  let k = nt.N.key in 
+  if x = k then 
+    let {N.left = l; right = r} = nt in       
+    match l, r with
+    | None, _ -> r  
+    | _, None -> l 
+    | _,  Some nr ->  
+      nt.right <- (N.removeMinAuxWithRootMutate nt nr);
+      Some (N.balMutate nt)
+  else 
+    begin 
+      if x < k then 
+        match  nt.left with         
+        | None -> Some nt 
+        | Some l ->
+          nt.left <- (removeMutateAux l x );
+          Some (N.balMutate nt)
+      else 
+        match  nt.right with 
+        | None -> Some nt 
+        | Some r -> 
+          nt.right <- (removeMutateAux r x);
+          Some (N.balMutate nt)
+    end
+
+let remove d v = 
+  let oldRoot = d.data in 
+  match  oldRoot with 
+  | None -> ()
+  | Some root -> 
+    let newRoot = removeMutateAux root v in 
+    if newRoot != oldRoot then 
+      d.data <- newRoot   
+
+
+let rec updateDone t (x : key)  f  =   
+  match  t with 
+  | None ->
+    (match f None [@bs] with
+    | Some data -> N.singleton x data
+    | None -> t)
+  | Some nt -> 
+    let k = nt.N.key in 
+    (* let  c = (Belt_Cmp.getCmpInternal cmp) x k [@bs] in   *)
+    if k = x then begin     
+      match f (Some nt.value) [@bs] with
+      | None ->
+        let {N.left = l; right = r} = nt in
+        begin match  l,  r with
+          | None,  _ -> r
+          | _, None  -> l
+          | _, Some nr ->
+            nt.right <- (N.removeMinAuxWithRootMutate nt nr);
+            Some (N.balMutate nt)
+        end
+      | Some data -> 
+        nt.value <- data;
+        Some nt
+    end      
+    else
+      let {N.left = l; right = r} = nt in 
+      (if x < k then                   
+         let ll = updateDone  l x f in
+         nt.left <- ll
+       else   
+         nt.right <- (updateDone  r x f);
+      );
+      Some (N.balMutate nt)
+        
+let updateU t x f =       
+  let oldRoot = t.data in 
+  let newRoot = updateDone oldRoot x f  in 
+  if newRoot != oldRoot then 
+    t.data <- newRoot 
+let update t x f = updateU t x (fun[@bs] a -> f a )
+let rec removeArrayMutateAux t xs i len   =  
+  if i < len then 
+    let ele = A.getUnsafe xs i in 
+    let u = removeMutateAux t ele  in 
+    match  u with 
+    | None -> None
+    | Some t -> removeArrayMutateAux t xs (i+1) len 
+  else Some t    
+
+let removeMany (d : _ t) xs =  
+  let oldRoot = d.data in 
+  match  oldRoot with 
+  | None -> ()
+  | Some nt -> 
+    let len = A.length xs in 
+    let newRoot = removeArrayMutateAux nt xs 0 len in 
+    if newRoot != oldRoot then 
+      d.data <- newRoot
+
+
+
+(* let split = I.split  *)
+(* let merge = I.merge  *)
+
+
+let fromArray xs = 
+  { data = I.fromArray xs }
+
+let cmpU d0 d1 f = 
+  I.cmpU d0.data d1.data f
+let cmp d0 d1 f = cmpU d0 d1 (fun[@bs] a b -> f a b)          
+
+let eqU d0 d1 f = 
+  I.eqU d0.data d1.data f
+let eq d0 d1 f = eqU d0 d1 (fun[@bs] a b -> f a b)    
+
+let get d x =   I.get d.data x 
+let getUndefined d x = I.getUndefined d.data x 
+let getWithDefault d x def = I.getWithDefault d.data x def  
+let getExn d x = I.getExn d.data x 

package/lib/ocaml/belt_MutableMapInt.mli

@@ -0,0 +1,135 @@
+# 1 "others/mapm.cppo.mli"
+(* Copyright (C) 2017 Authors of ReScript
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a later version).
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+# 28 "others/mapm.cppo.mli"
+type key = int
+# 32 "others/mapm.cppo.mli"
+type 'a t
+
+
+val make: unit -> 'a t
+val clear: 'a t -> unit
+val isEmpty: 'a t -> bool
+
+val has:  'a t -> key -> bool
+
+val cmpU:  'a t -> 'a t -> ('a -> 'a -> int [@bs]) -> int
+val cmp:  'a t -> 'a t -> ('a -> 'a -> int) -> int
+(** `cmp m1 m2 cmp`
+  First compare by size, if size is the same,
+  compare by key, value pair
+*)
+
+val eqU: 'a t -> 'a t -> ('a -> 'a -> bool [@bs]) -> bool
+val eq: 'a t -> 'a t -> ('a -> 'a -> bool ) -> bool
+(** `eq m1 m2 cmp` *)
+
+val forEachU: 'a t -> (key -> 'a -> unit [@bs]) ->  unit
+val forEach: 'a t -> (key -> 'a -> unit) ->  unit
+(** `forEach m f` applies `f` to all bindings in map `m`.
+  `f` receives the key as first argument, and the associated value
+  as second argument.
+  The application order of `f`  is in increasing order. *)
+
+val reduceU:  'a t -> 'b -> ('b -> key -> 'a -> 'b [@bs]) -> 'b
+val reduce:  'a t -> 'b -> ('b -> key -> 'a -> 'b ) -> 'b
+(** `reduce m a f` computes `(f kN dN ... (f k1 d1 a)...)`,
+  where `k1 ... kN` are the keys of all bindings in `m`
+  (in increasing order), and `d1 ... dN` are the associated data. *)
+
+val everyU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+val every:  'a t -> (key -> 'a -> bool) -> bool
+(** `every m p` checks if all the bindings of the map
+  satisfy the predicate `p`.
+  The application order of `p` is unspecified.
+*)
+
+val someU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+val some:  'a t -> (key -> 'a -> bool) -> bool
+(** `some m p` checks if at least one binding of the map
+  satisfy the predicate `p`.
+  The application order of `p` is unspecified.
+*)
+
+
+
+
+val size: 'a t -> int
+val toList: 'a t -> (key * 'a) list
+(** In increasing order *)
+
+val toArray: 'a t -> (key * 'a) array
+(** In increasing order *)
+
+val fromArray: (key * 'a) array -> 'a t
+val keysToArray: 'a t -> key array
+val valuesToArray: 'a t -> 'a array
+val minKey: _ t -> key option
+val minKeyUndefined: _ t -> key Js.undefined
+val maxKey: _ t -> key option
+val maxKeyUndefined: _ t -> key Js.undefined
+val minimum: 'a t -> (key * 'a) option
+val minUndefined: 'a t -> (key * 'a) Js.undefined
+val maximum: 'a t -> (key * 'a) option
+val maxUndefined: 'a t -> (key * 'a) Js.undefined
+val get: 'a t ->  key -> 'a option
+val getUndefined: 'a t -> key -> 'a Js.undefined
+val getWithDefault:  'a t -> key -> 'a  -> 'a
+val getExn: 'a t -> key -> 'a
+val checkInvariantInternal: _ t -> unit
+(**
+  **raise** when invariant is not held
+*)
+
+
+
+(****************************************************************************)
+
+(*TODO: add functional `merge, partition, keep, split`*)
+
+val remove: 'a t -> key -> unit
+(** `remove m x` do the in-place modification *)
+
+val removeMany: 'a t -> key array -> unit
+
+val set: 'a t -> key -> 'a -> unit
+(** `set m x y` do the in-place modification, return
+  `m` for chaining. If `x` was already bound
+  in `m`, its previous binding disappears. *)
+
+val updateU: 'a t -> key -> ('a option -> 'a option [@bs]) -> unit
+val update: 'a t -> key -> ('a option -> 'a option) -> unit
+
+
+val mapU: 'a t -> ('a -> 'b [@bs]) ->  'b t
+val map: 'a t -> ('a -> 'b) ->  'b t
+(** `map m f` returns a map with same domain as `m`, where the
+  associated value `a` of all bindings of `m` has been
+  replaced by the result of the application of `f` to `a`.
+  The bindings are passed to `f` in increasing order
+  with respect to the ordering over the type of the keys. *)
+
+val mapWithKeyU: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
+val mapWithKey: 'a t -> (key -> 'a -> 'b) -> 'b t

package/lib/ocaml/belt_MutableMapString.ml

@@ -0,0 +1,172 @@
+# 5 "others/mapm.cppo.ml"
+module I = Belt_internalMapString
+type key = string
+# 10 "others/mapm.cppo.ml"
+module N = Belt_internalAVLtree
+module A = Belt_Array 
+
+
+
+
+type 'a t = {
+  mutable data : 'a I.t
+} 
+
+
+let make () = {data = None}
+let isEmpty m = N.isEmpty m.data
+let clear m =  m.data<- None
+(* let singleton k v = t ~data:(N.singleton k v) *)
+
+let minKeyUndefined m = N.minKeyUndefined m.data
+let minKey m = N.minKey m.data
+let maxKeyUndefined m = N.maxKeyUndefined m.data
+let maxKey m = N.maxKey m.data
+let minimum m = N.minimum m.data
+let minUndefined m = N.minUndefined m.data
+let maximum m = N.maximum m.data
+let maxUndefined m = N.maxUndefined m.data
+
+let set (m : _ t) k v = 
+  let old_data = m.data in 
+  let v = I.addMutate old_data k v in 
+  if v != old_data then 
+    m.data <-v 
+
+let forEachU d f = N.forEachU d.data f
+let forEach d f = forEachU d (fun[@bs] a b -> f a b)    
+let mapU d f = {data = N.mapU d.data f}
+let map d f = mapU d (fun[@bs] a -> f a )    
+let mapWithKeyU d f = { data = (N.mapWithKeyU d.data f)}
+let mapWithKey d f = mapWithKeyU d (fun [@bs] a b -> f a b)    
+let reduceU d acc f  = N.reduceU d.data acc f
+let reduce d acc f = reduceU d acc (fun[@bs] a b c -> f a b c)    
+let everyU d f = N.everyU d.data f
+let every d f = everyU d (fun[@bs] a b -> f a b)    
+let someU d f = N.someU d.data f    
+let some d f = someU d (fun[@bs] a b -> f a b)
+let size d = N.size d.data
+let toList d = N.toList d.data
+let toArray d = N.toArray d.data
+let keysToArray d = N.keysToArray d.data
+let valuesToArray d = N.valuesToArray d.data
+let checkInvariantInternal d = N.checkInvariantInternal d.data
+let has d v = I.has d.data v 
+
+
+let rec removeMutateAux nt (x : key)= 
+  let k = nt.N.key in 
+  if x = k then 
+    let {N.left = l; right = r} = nt in       
+    match l, r with
+    | None, _ -> r  
+    | _, None -> l 
+    | _,  Some nr ->  
+      nt.right <- (N.removeMinAuxWithRootMutate nt nr);
+      Some (N.balMutate nt)
+  else 
+    begin 
+      if x < k then 
+        match  nt.left with         
+        | None -> Some nt 
+        | Some l ->
+          nt.left <- (removeMutateAux l x );
+          Some (N.balMutate nt)
+      else 
+        match  nt.right with 
+        | None -> Some nt 
+        | Some r -> 
+          nt.right <- (removeMutateAux r x);
+          Some (N.balMutate nt)
+    end
+
+let remove d v = 
+  let oldRoot = d.data in 
+  match  oldRoot with 
+  | None -> ()
+  | Some root -> 
+    let newRoot = removeMutateAux root v in 
+    if newRoot != oldRoot then 
+      d.data <- newRoot   
+
+
+let rec updateDone t (x : key)  f  =   
+  match  t with 
+  | None ->
+    (match f None [@bs] with
+    | Some data -> N.singleton x data
+    | None -> t)
+  | Some nt -> 
+    let k = nt.N.key in 
+    (* let  c = (Belt_Cmp.getCmpInternal cmp) x k [@bs] in   *)
+    if k = x then begin     
+      match f (Some nt.value) [@bs] with
+      | None ->
+        let {N.left = l; right = r} = nt in
+        begin match  l,  r with
+          | None,  _ -> r
+          | _, None  -> l
+          | _, Some nr ->
+            nt.right <- (N.removeMinAuxWithRootMutate nt nr);
+            Some (N.balMutate nt)
+        end
+      | Some data -> 
+        nt.value <- data;
+        Some nt
+    end      
+    else
+      let {N.left = l; right = r} = nt in 
+      (if x < k then                   
+         let ll = updateDone  l x f in
+         nt.left <- ll
+       else   
+         nt.right <- (updateDone  r x f);
+      );
+      Some (N.balMutate nt)
+        
+let updateU t x f =       
+  let oldRoot = t.data in 
+  let newRoot = updateDone oldRoot x f  in 
+  if newRoot != oldRoot then 
+    t.data <- newRoot 
+let update t x f = updateU t x (fun[@bs] a -> f a )
+let rec removeArrayMutateAux t xs i len   =  
+  if i < len then 
+    let ele = A.getUnsafe xs i in 
+    let u = removeMutateAux t ele  in 
+    match  u with 
+    | None -> None
+    | Some t -> removeArrayMutateAux t xs (i+1) len 
+  else Some t    
+
+let removeMany (d : _ t) xs =  
+  let oldRoot = d.data in 
+  match  oldRoot with 
+  | None -> ()
+  | Some nt -> 
+    let len = A.length xs in 
+    let newRoot = removeArrayMutateAux nt xs 0 len in 
+    if newRoot != oldRoot then 
+      d.data <- newRoot
+
+
+
+(* let split = I.split  *)
+(* let merge = I.merge  *)
+
+
+let fromArray xs = 
+  { data = I.fromArray xs }
+
+let cmpU d0 d1 f = 
+  I.cmpU d0.data d1.data f
+let cmp d0 d1 f = cmpU d0 d1 (fun[@bs] a b -> f a b)          
+
+let eqU d0 d1 f = 
+  I.eqU d0.data d1.data f
+let eq d0 d1 f = eqU d0 d1 (fun[@bs] a b -> f a b)    
+
+let get d x =   I.get d.data x 
+let getUndefined d x = I.getUndefined d.data x 
+let getWithDefault d x def = I.getWithDefault d.data x def  
+let getExn d x = I.getExn d.data x 

package/lib/ocaml/belt_MutableMapString.mli

@@ -0,0 +1,135 @@
+# 1 "others/mapm.cppo.mli"
+(* Copyright (C) 2017 Authors of ReScript
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a later version).
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+# 26 "others/mapm.cppo.mli"
+type key = string
+# 32 "others/mapm.cppo.mli"
+type 'a t
+
+
+val make: unit -> 'a t
+val clear: 'a t -> unit
+val isEmpty: 'a t -> bool
+
+val has:  'a t -> key -> bool
+
+val cmpU:  'a t -> 'a t -> ('a -> 'a -> int [@bs]) -> int
+val cmp:  'a t -> 'a t -> ('a -> 'a -> int) -> int
+(** `cmp m1 m2 cmp`
+  First compare by size, if size is the same,
+  compare by key, value pair
+*)
+
+val eqU: 'a t -> 'a t -> ('a -> 'a -> bool [@bs]) -> bool
+val eq: 'a t -> 'a t -> ('a -> 'a -> bool ) -> bool
+(** `eq m1 m2 cmp` *)
+
+val forEachU: 'a t -> (key -> 'a -> unit [@bs]) ->  unit
+val forEach: 'a t -> (key -> 'a -> unit) ->  unit
+(** `forEach m f` applies `f` to all bindings in map `m`.
+  `f` receives the key as first argument, and the associated value
+  as second argument.
+  The application order of `f`  is in increasing order. *)
+
+val reduceU:  'a t -> 'b -> ('b -> key -> 'a -> 'b [@bs]) -> 'b
+val reduce:  'a t -> 'b -> ('b -> key -> 'a -> 'b ) -> 'b
+(** `reduce m a f` computes `(f kN dN ... (f k1 d1 a)...)`,
+  where `k1 ... kN` are the keys of all bindings in `m`
+  (in increasing order), and `d1 ... dN` are the associated data. *)
+
+val everyU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+val every:  'a t -> (key -> 'a -> bool) -> bool
+(** `every m p` checks if all the bindings of the map
+  satisfy the predicate `p`.
+  The application order of `p` is unspecified.
+*)
+
+val someU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+val some:  'a t -> (key -> 'a -> bool) -> bool
+(** `some m p` checks if at least one binding of the map
+  satisfy the predicate `p`.
+  The application order of `p` is unspecified.
+*)
+
+
+
+
+val size: 'a t -> int
+val toList: 'a t -> (key * 'a) list
+(** In increasing order *)
+
+val toArray: 'a t -> (key * 'a) array
+(** In increasing order *)
+
+val fromArray: (key * 'a) array -> 'a t
+val keysToArray: 'a t -> key array
+val valuesToArray: 'a t -> 'a array
+val minKey: _ t -> key option
+val minKeyUndefined: _ t -> key Js.undefined
+val maxKey: _ t -> key option
+val maxKeyUndefined: _ t -> key Js.undefined
+val minimum: 'a t -> (key * 'a) option
+val minUndefined: 'a t -> (key * 'a) Js.undefined
+val maximum: 'a t -> (key * 'a) option
+val maxUndefined: 'a t -> (key * 'a) Js.undefined
+val get: 'a t ->  key -> 'a option
+val getUndefined: 'a t -> key -> 'a Js.undefined
+val getWithDefault:  'a t -> key -> 'a  -> 'a
+val getExn: 'a t -> key -> 'a
+val checkInvariantInternal: _ t -> unit
+(**
+  **raise** when invariant is not held
+*)
+
+
+
+(****************************************************************************)
+
+(*TODO: add functional `merge, partition, keep, split`*)
+
+val remove: 'a t -> key -> unit
+(** `remove m x` do the in-place modification *)
+
+val removeMany: 'a t -> key array -> unit
+
+val set: 'a t -> key -> 'a -> unit
+(** `set m x y` do the in-place modification, return
+  `m` for chaining. If `x` was already bound
+  in `m`, its previous binding disappears. *)
+
+val updateU: 'a t -> key -> ('a option -> 'a option [@bs]) -> unit
+val update: 'a t -> key -> ('a option -> 'a option) -> unit
+
+
+val mapU: 'a t -> ('a -> 'b [@bs]) ->  'b t
+val map: 'a t -> ('a -> 'b) ->  'b t
+(** `map m f` returns a map with same domain as `m`, where the
+  associated value `a` of all bindings of `m` has been
+  replaced by the result of the application of `f` to `a`.
+  The bindings are passed to `f` in increasing order
+  with respect to the ordering over the type of the keys. *)
+
+val mapWithKeyU: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
+val mapWithKey: 'a t -> (key -> 'a -> 'b) -> 'b t