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

package/lib/ocaml/belt_MutableMapInt.ml

@@ -1,172 +0,0 @@
-# 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

@@ -1,135 +0,0 @@
-# 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

@@ -1,172 +0,0 @@
-# 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

@@ -1,135 +0,0 @@
-# 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