@tellahq/rescript 10.1.0-alpha.1

package/lib/ocaml/belt_MapInt.ml

@@ -0,0 +1,169 @@
+# 5 "others/map.cppo.ml"
+type key = int
+module I = Belt_internalMapInt    
+
+# 11 "others/map.cppo.ml"
+module N = Belt_internalAVLtree
+module A = Belt_Array 
+
+type 'a t = (key, 'a) N.t
+
+let empty = None      
+let isEmpty = N.isEmpty
+(* let singleton = N.singleton *)
+
+let minKey = N.minKey
+let minKeyUndefined = N.minKeyUndefined
+let maxKey = N.maxKey
+let maxKeyUndefined = N.maxKeyUndefined
+let minimum = N.minimum
+let minUndefined = N.minUndefined
+let maximum = N.maximum
+let maxUndefined = N.maxUndefined
+let forEachU = N.forEachU
+let forEach = N.forEach
+let mapU  = N.mapU                
+let map  = N.map
+let mapWithKeyU = N.mapWithKeyU 
+let mapWithKey = N.mapWithKey
+let reduceU = N.reduceU
+let reduce = N.reduce               
+let everyU = N.everyU
+let every = N.every              
+let someU = N.someU
+let some = N.some                
+let keepU = N.keepSharedU
+let keep = N.keepShared 
+let partitionU = N.partitionSharedU 
+let partition = N.partitionShared
+let size = N.size
+let toList = N.toList
+let toArray = N.toArray
+let keysToArray = N.keysToArray
+let valuesToArray = N.valuesToArray
+let checkInvariantInternal = N.checkInvariantInternal
+
+let rec set  t (newK : key) (newD : _)  = 
+  match t with
+  | None -> 
+    N.singleton newK newD
+  | Some n  ->
+    let k = n.N.key in 
+    if newK = k then
+      Some (N.updateValue n newD)
+    else
+      let v = n.N.value in 
+      if newK < k then
+        N.bal (set n.N.left newK newD) k v n.N.right
+      else
+        N.bal n.N.left k v (set n.N.right newK newD)
+        
+let rec updateU  t (x : key) f  = 
+  match t with
+  | None -> 
+    begin match f None [@bs] with 
+    | None -> t 
+    | Some data -> 
+      N.singleton x data 
+    end 
+  | Some n  ->
+    let k = n.N.key in 
+    if x = k then
+      begin match f (Some n.N.value) [@bs] with 
+      | None ->
+        let {N.left = l;  right = r } = n in
+        begin match l, r with
+          | None, _ -> r
+          | _, None -> l
+          | _, Some rn ->
+            let kr, vr = ref rn.N.key, ref rn.N.value in
+            let r = N.removeMinAuxWithRef rn kr vr in
+            N.bal l kr.contents vr.contents r 
+        end
+      | Some data -> Some (N.updateValue n data )
+      end 
+    else
+      let {N.left = l; right = r; value = v} = n in 
+      if x < k then
+        let ll = (updateU l x f) in
+        if l == ll then t 
+        else N.bal ll  k v r
+      else
+        let rr = (updateU r x f) in
+        if r == rr then t 
+        else N.bal l k v rr 
+
+let update t x f = updateU t x (fun[@bs] a -> f a)
+    
+let rec removeAux n (x : key) = 
+    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.N.key, ref rn.N.value in 
+        let r = N.removeMinAuxWithRef rn kr vr in 
+        N.bal l kr.contents vr.contents r 
+    else if x < v then
+      match l with 
+      | None -> Some n
+      | Some left -> 
+        let ll = removeAux left x in 
+        if ll == l then Some n 
+        else N.(bal ll v n.value r)
+    else
+      match r with 
+      | None -> Some n 
+      | Some right -> 
+        let rr = removeAux right x  in 
+        N.bal l v n.N.value rr
+
+let remove n x = 
+  match n with 
+  | None -> None
+  | Some n -> removeAux n x 
+
+let rec removeMany0 t xs i len  =
+  if i < len then
+    let ele = A.getUnsafe xs i in
+    let u =  removeAux t ele  in
+    match u with
+    | None -> u
+    | Some t -> removeMany0 t xs (i + 1) len
+  else
+    Some t
+      
+let removeMany t keys =
+  let len = A.length keys in
+  match t with
+  | None -> None
+  | Some t ->  removeMany0 t keys 0 len
+
+let findFirstByU = N.findFirstByU
+let findFirstBy = N.findFirstBy 
+
+let mergeMany h arr =   
+  let len = A.length arr in 
+  let v = ref h in  
+  for i = 0 to len - 1 do 
+    let key,value = A.getUnsafe arr i in 
+    v.contents<- set v.contents key value
+  done ;
+  v.contents 
+
+(* let mergeArray = mergeMany *)
+
+let has = I.has
+let cmpU = I.cmpU
+let cmp = I.cmp
+let eqU = I.eqU
+let eq = I.eq
+let get = I.get
+let getUndefined = I.getUndefined
+let getWithDefault = I.getWithDefault 
+let getExn = I.getExn
+let split = I.split
+let mergeU = I.mergeU 
+let merge = I.merge 
+let fromArray = I.fromArray

package/lib/ocaml/belt_MapInt.mli

@@ -0,0 +1,187 @@
+# 4 "others/map.cppo.mli"
+type key = int
+# 8 "others/map.cppo.mli"
+type 'value t
+(** The type of maps from type `key` to type `'value`. *)
+
+val empty: 'v t
+
+val isEmpty: 'v t -> bool
+
+val has: 'v t -> key -> bool
+
+val cmpU: 'v t -> 'v t -> ('v -> 'v -> int [@bs]) -> int
+val cmp: 'v t -> 'v t -> ('v -> 'v -> int) -> int
+
+val eqU: 'v t -> 'v t -> ('v -> 'v -> bool [@bs]) -> bool
+val eq: 'v t -> 'v t -> ('v -> 'v -> bool) -> bool
+(**
+  `eq m1 m2` tests whether the maps `m1` and `m2` are
+  equal, that is, contain equal keys and associate them with
+  equal data.
+*)
+
+val findFirstByU : 'v t -> (key -> 'v -> bool [@bs]) -> (key * 'v) option
+val findFirstBy : 'v t -> (key -> 'v -> bool) -> (key * 'v) option
+(**
+  `findFirstBy m p` uses funcion `f` to find the first key value pair
+  to match predicate `p`.
+
+  ```
+  let s0 = fromArray ~id:(module IntCmp) [|4,"4";1,"1";2,"2,"3""|];;
+  findFirstBy s0 (fun k v -> k = 4 ) = option (4, "4");;
+  ```
+*)
+
+val forEachU: 'v t -> (key -> 'v -> unit [@bs]) -> unit
+val forEach: 'v t -> (key -> 'v -> 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 bindings are passed to `f` in increasing
+  order with respect to the ordering over the type of the keys.
+*)
+
+val reduceU: 'v t -> 'v2 -> ('v2 -> key -> 'v -> 'v2 [@bs]) -> 'v2
+val reduce: 'v t -> 'v2 -> ('v2 -> key -> 'v -> 'v2) -> 'v2
+(**
+  `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: 'v t -> (key -> 'v -> bool [@bs]) -> bool
+val every: 'v t -> (key -> 'v -> bool) -> bool
+(** `every m p` checks if all the bindings of the map
+    satisfy the predicate `p`. Order unspecified *)
+
+val someU: 'v t -> (key -> 'v -> bool [@bs]) -> bool
+val some: 'v t -> (key -> 'v -> bool) -> bool
+(** `some m p` checks if at least one binding of the map
+    satisfy the predicate `p`. Order unspecified *)
+
+val size: 'v t -> int
+
+val toList: 'v t -> (key * 'v) list
+(** In increasing order. *)
+
+val toArray: 'v t -> (key * 'v) array
+
+
+val fromArray: (key * 'v) array -> 'v t
+
+val keysToArray: 'v t -> key array
+
+val valuesToArray: 'v t -> 'v 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: 'v t -> (key * 'v) option
+
+val minUndefined: 'v t -> (key * 'v) Js.undefined
+
+val maximum: 'v t -> (key * 'v) option
+
+val maxUndefined: 'v t -> (key * 'v) Js.undefined
+
+val get: 'v t -> key -> 'v option
+
+val getUndefined: 'v t -> key -> 'v Js.undefined
+
+val getWithDefault: 'v t -> key -> 'v -> 'v
+
+val getExn: 'v t -> key -> 'v
+
+val checkInvariantInternal: _ t -> unit
+(**
+  **raise** when invariant is not held
+*)
+
+val remove: 'v t -> key -> 'v t
+(** `remove m x` returns a map containing the same bindings as
+    `m`, except for `x` which is unbound in the returned map. *)
+
+val removeMany: 'v t -> key array -> 'v t
+
+val set: 'v t -> key -> 'v -> 'v t
+(**
+  `set m x y` returns a map containing the same bindings as
+  `m`, plus a binding of `x` to `y`. If `x` was already bound
+  in `m`, its previous binding disappears.
+*)
+
+val updateU: 'v t -> key -> ('v option -> 'v option [@bs]) -> 'v t
+val update: 'v t -> key -> ('v option -> 'v option) -> 'v t
+
+val mergeU:
+  'v t -> 'v2 t ->
+  (key -> 'v option -> 'v2 option -> 'c option [@bs]) ->
+  'c t
+val merge:
+  'v t -> 'v2 t ->
+  (key -> 'v option -> 'v2 option -> 'c option) ->
+  'c t
+(**
+  `merge m1 m2 f` computes a map whose keys is a subset of keys of `m1`
+  and of `m2`. The presence of each such binding, and the corresponding
+  value, is determined with the function `f`.
+*)
+
+val mergeMany: 'v t -> (key * 'v) array -> 'v t
+
+
+val keepU:
+  'v t ->
+  (key -> 'v -> bool [@bs]) ->
+  'v t
+val keep:
+  'v t ->
+  (key -> 'v -> bool) ->
+  'v t
+(** `keep m p` returns the map with all the bindings in `m`
+    that satisfy predicate `p`. *)
+
+val partitionU:
+  'v t ->
+  (key -> 'v -> bool [@bs]) ->
+  'v t * 'v t
+val partition:
+  'v t ->
+  (key -> 'v -> bool) ->
+  'v t * 'v t
+(**
+  `partition m p` returns a pair of maps `(m1, m2)`, where
+  `m1` contains all the bindings of `s` that satisfy the
+  predicate `p`, and `m2` is the map with all the bindings of
+  `s` that do not satisfy `p`.
+*)
+
+val split: key -> 'v t -> 'v t * 'v option * 'v t
+(**
+  `split x m` returns a triple `(l, data, r)`, where
+  `l` is the map with all the bindings of `m` whose key
+  is strictly less than `x`;
+  `r` is the map with all the bindings of `m` whose key
+  is strictly greater than `x`;
+  `data` is `None` if `m` contains no binding for `x`,
+  or `Some v` if `m` binds `v` to `x`.
+*)
+
+val mapU: 'v t -> ('v -> 'v2 [@bs]) -> 'v2 t
+val map: 'v t -> ('v -> 'v2) -> 'v2 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: 'v t -> (key -> 'v -> 'v2 [@bs]) -> 'v2 t
+val mapWithKey: 'v t -> (key -> 'v -> 'v2) -> 'v2 t

package/lib/ocaml/belt_MapString.ml

@@ -0,0 +1,169 @@
+# 2 "others/map.cppo.ml"
+type key = string
+module I = Belt_internalMapString
+
+# 11 "others/map.cppo.ml"
+module N = Belt_internalAVLtree
+module A = Belt_Array 
+
+type 'a t = (key, 'a) N.t
+
+let empty = None      
+let isEmpty = N.isEmpty
+(* let singleton = N.singleton *)
+
+let minKey = N.minKey
+let minKeyUndefined = N.minKeyUndefined
+let maxKey = N.maxKey
+let maxKeyUndefined = N.maxKeyUndefined
+let minimum = N.minimum
+let minUndefined = N.minUndefined
+let maximum = N.maximum
+let maxUndefined = N.maxUndefined
+let forEachU = N.forEachU
+let forEach = N.forEach
+let mapU  = N.mapU                
+let map  = N.map
+let mapWithKeyU = N.mapWithKeyU 
+let mapWithKey = N.mapWithKey
+let reduceU = N.reduceU
+let reduce = N.reduce               
+let everyU = N.everyU
+let every = N.every              
+let someU = N.someU
+let some = N.some                
+let keepU = N.keepSharedU
+let keep = N.keepShared 
+let partitionU = N.partitionSharedU 
+let partition = N.partitionShared
+let size = N.size
+let toList = N.toList
+let toArray = N.toArray
+let keysToArray = N.keysToArray
+let valuesToArray = N.valuesToArray
+let checkInvariantInternal = N.checkInvariantInternal
+
+let rec set  t (newK : key) (newD : _)  = 
+  match t with
+  | None -> 
+    N.singleton newK newD
+  | Some n  ->
+    let k = n.N.key in 
+    if newK = k then
+      Some (N.updateValue n newD)
+    else
+      let v = n.N.value in 
+      if newK < k then
+        N.bal (set n.N.left newK newD) k v n.N.right
+      else
+        N.bal n.N.left k v (set n.N.right newK newD)
+        
+let rec updateU  t (x : key) f  = 
+  match t with
+  | None -> 
+    begin match f None [@bs] with 
+    | None -> t 
+    | Some data -> 
+      N.singleton x data 
+    end 
+  | Some n  ->
+    let k = n.N.key in 
+    if x = k then
+      begin match f (Some n.N.value) [@bs] with 
+      | None ->
+        let {N.left = l;  right = r } = n in
+        begin match l, r with
+          | None, _ -> r
+          | _, None -> l
+          | _, Some rn ->
+            let kr, vr = ref rn.N.key, ref rn.N.value in
+            let r = N.removeMinAuxWithRef rn kr vr in
+            N.bal l kr.contents vr.contents r 
+        end
+      | Some data -> Some (N.updateValue n data )
+      end 
+    else
+      let {N.left = l; right = r; value = v} = n in 
+      if x < k then
+        let ll = (updateU l x f) in
+        if l == ll then t 
+        else N.bal ll  k v r
+      else
+        let rr = (updateU r x f) in
+        if r == rr then t 
+        else N.bal l k v rr 
+
+let update t x f = updateU t x (fun[@bs] a -> f a)
+    
+let rec removeAux n (x : key) = 
+    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.N.key, ref rn.N.value in 
+        let r = N.removeMinAuxWithRef rn kr vr in 
+        N.bal l kr.contents vr.contents r 
+    else if x < v then
+      match l with 
+      | None -> Some n
+      | Some left -> 
+        let ll = removeAux left x in 
+        if ll == l then Some n 
+        else N.(bal ll v n.value r)
+    else
+      match r with 
+      | None -> Some n 
+      | Some right -> 
+        let rr = removeAux right x  in 
+        N.bal l v n.N.value rr
+
+let remove n x = 
+  match n with 
+  | None -> None
+  | Some n -> removeAux n x 
+
+let rec removeMany0 t xs i len  =
+  if i < len then
+    let ele = A.getUnsafe xs i in
+    let u =  removeAux t ele  in
+    match u with
+    | None -> u
+    | Some t -> removeMany0 t xs (i + 1) len
+  else
+    Some t
+      
+let removeMany t keys =
+  let len = A.length keys in
+  match t with
+  | None -> None
+  | Some t ->  removeMany0 t keys 0 len
+
+let findFirstByU = N.findFirstByU
+let findFirstBy = N.findFirstBy 
+
+let mergeMany h arr =   
+  let len = A.length arr in 
+  let v = ref h in  
+  for i = 0 to len - 1 do 
+    let key,value = A.getUnsafe arr i in 
+    v.contents<- set v.contents key value
+  done ;
+  v.contents 
+
+(* let mergeArray = mergeMany *)
+
+let has = I.has
+let cmpU = I.cmpU
+let cmp = I.cmp
+let eqU = I.eqU
+let eq = I.eq
+let get = I.get
+let getUndefined = I.getUndefined
+let getWithDefault = I.getWithDefault 
+let getExn = I.getExn
+let split = I.split
+let mergeU = I.mergeU 
+let merge = I.merge 
+let fromArray = I.fromArray