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

package/lib/ocaml/belt_MapInt.ml

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

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

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