@tellahq/rescript 10.1.0-alpha.1

package/lib/ocaml/belt_Result.mli

@@ -0,0 +1,205 @@
+(* 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. *)
+
+(**
+  Result types are really useful to describe the result of a certain operation
+  without relying on exceptions or `option` types.
+
+  This module gives you useful utilities to create and combine `Result` data.
+*)
+
+type ('a,'b) t = Ok of 'a | Error of 'b
+(**
+  The type `Result.t(result, err)` describes a variant of two states:
+  `Ok(someResult)` represents a successful operation, whereby
+  ``Error(someError)` signals an erronous operation.
+
+  In this concrete example, we are defining our own `Result` type to reflect an HTTP like
+  query operation:
+
+  ```res example
+  type responseError = NotAvailable | NotFound
+  type queryResult = t<string, responseError>
+
+  let failQueryUser = (username: string): queryResult => {
+    Error(NotAvailable)
+  }
+```
+*)
+
+val getExn : ('a, 'b) t -> 'a
+(**
+  `getExn(res)`: when `res` is `Ok(n)`, returns `n` when `res` is `Error(m)`, raise an exception
+
+  ```res example
+  Belt.Result.getExn(Belt.Result.Ok(42)) == 42
+
+  Belt.Result.getExn(Belt.Result.Error("Invalid data")) /* raises exception */
+  ```
+*)
+
+val mapWithDefaultU : ('a, 'c) t -> 'b -> ('a -> 'b [@bs]) -> 'b
+val mapWithDefault : ('a, 'c) t -> 'b -> ('a -> 'b) -> 'b
+(**
+  `mapWithDefault(res, default, f)`: When res is `Ok(n)`, returns `f(n)`,
+  otherwise `default`.
+
+  ```res example
+  let ok = Belt.Result.Ok(42)
+  Belt.Result.mapWithDefault(ok, 0, (x) => x / 2) == 21
+
+  let error = Belt.Result.Error("Invalid data")
+  Belt.Result.mapWithDefault(error, 0, (x) => x / 2) == 0
+  ```
+*)
+
+val mapU : ('a, 'c) t -> ('a -> 'b [@bs]) -> ('b, 'c) t
+val map : ('a, 'c) t -> ('a -> 'b) -> ('b, 'c) t
+(**
+  `map(res, f)`: When res is `Ok(n)`, returns `Ok(f(n))`. Otherwise returns res
+  unchanged. Function `f` takes a value of the same type as `n` and returns an
+  ordinary value.
+
+  ```res example
+  let f = (x) => sqrt(Belt.Int.toFloat(x))
+
+  Belt.Result.map(Ok(64), f) == Ok(8.0)
+
+  Belt.Result.map(Error("Invalid data"), f) == Error("Invalid data")
+  ```
+*)
+
+val flatMapU : ('a, 'c) t -> ('a -> ('b, 'c) t [@bs]) -> ('b, 'c) t
+val flatMap : ('a, 'c) t -> ('a -> ('b, 'c) t) -> ('b, 'c) t
+(**
+  `flatMap(res, f)`: When res is `Ok(n)`, returns `f(n)`. Otherwise, returns res
+  unchanged. Function `f` takes a value of the same type as `n` and returns a
+  `Belt.Result`.
+
+  ```res example
+  let recip = (x) =>
+    if (x !== 0.0) {
+      Belt.Result.Ok(1.0 /. x)
+    } else {
+      Belt.Result.Error("Divide by zero")
+    }
+
+  Belt.Result.flatMap(Ok(2.0), recip) == Ok(0.5)
+
+  Belt.Result.flatMap(Ok(0.0), recip) == Error("Divide by zero")
+
+  Belt.Result.flatMap(Error("Already bad"), recip) == Error("Already bad")
+  ```
+*)
+
+val getWithDefault : ('a, 'b) t -> 'a -> 'a
+(**
+  `getWithDefault(res, defaultValue)`: If `res` is `Ok(n)`, returns `n`,
+  otherwise `default`
+
+  ```res example
+  Belt.Result.getWithDefault(Ok(42), 0) == 42
+
+  Belt.Result.getWithDefault(Error("Invalid Data"), 0) == 0
+  ```
+*)
+
+val isOk : ('a, 'b) t -> bool
+(**
+  `isOk(res)`: Returns `true` if `res` is of the form `Ok(n)`, `false` if it is
+  the `Error(e)` variant.
+*)
+
+val isError : ('a, 'b) t -> bool
+(**
+  `isError(res)`: Returns `true` if `res` is of the form `Error(e)`, `false` if
+  it is the `Ok(n)` variant.
+*)
+
+val eqU : ('a, 'c) t -> ('b, 'd) t -> ('a -> 'b -> bool [@bs]) -> bool
+val eq : ('a, 'c) t -> ('b, 'd) t -> ('a -> 'b -> bool) -> bool
+(**
+  `eq(res1, res2, f)`: Determine if two `Belt.Result` variables are equal with
+  respect to an equality function. If `res1` and `res2` are of the form `Ok(n)`
+  and `Ok(m)`, return the result of `f(n, m)`. If one of `res1` and `res2` are of
+  the form `Error(e)`, return false If both `res1` and `res2` are of the form
+  `Error(e)`, return true
+
+  ```res example
+  let good1 = Belt.Result.Ok(42)
+
+  let good2 = Belt.Result.Ok(32)
+
+  let bad1 = Belt.Result.Error("invalid")
+
+  let bad2 = Belt.Result.Error("really invalid")
+
+  let mod10equal = (a, b) => mod(a, 10) === mod(b, 10)
+
+  Belt.Result.eq(good1, good2, mod10equal) == true
+
+  Belt.Result.eq(good1, bad1, mod10equal) == false
+
+  Belt.Result.eq(bad2, good2, mod10equal) == false
+
+  Belt.Result.eq(bad1, bad2, mod10equal) == true
+  ```
+*)
+
+val cmpU : ('a, 'c) t -> ('b, 'd) t -> ('a -> 'b -> int [@bs]) -> int
+val cmp : ('a, 'c) t -> ('b, 'd) t -> ('a -> 'b -> int) -> int
+(**
+  `cmp(res1, res2, f)`: Compare two `Belt.Result` variables with respect to a
+  comparison function. The comparison function returns -1 if the first variable
+  is "less than" the second, 0 if the two variables are equal, and 1 if the first
+  is "greater than" the second.
+
+  If `res1` and `res2` are of the form `Ok(n)` and `Ok(m)`, return the result of
+  `f(n, m)`. If `res1` is of the form `Error(e)` and `res2` of the form `Ok(n)`,
+  return -1 (nothing is less than something) If `res1` is of the form `Ok(n)` and
+  `res2` of the form `Error(e)`, return 1 (something is greater than nothing) If
+  both `res1` and `res2` are of the form `Error(e)`, return 0 (equal)
+
+  ```res example
+  let good1 = Belt.Result.Ok(59)
+
+  let good2 = Belt.Result.Ok(37)
+
+  let bad1 = Belt.Result.Error("invalid")
+
+  let bad2 = Belt.Result.Error("really invalid")
+
+  let mod10cmp = (a, b) => Pervasives.compare(mod(a, 10), mod(b, 10))
+
+  Belt.Result.cmp(Ok(39), Ok(57), mod10cmp) == 1
+
+  Belt.Result.cmp(Ok(57), Ok(39), mod10cmp) == (-1)
+
+  Belt.Result.cmp(Ok(39), Error("y"), mod10cmp) == 1
+
+  Belt.Result.cmp(Error("x"), Ok(57), mod10cmp) == (-1)
+
+  Belt.Result.cmp(Error("x"), Error("y"), mod10cmp) == 0
+  ```
+*)

package/lib/ocaml/belt_Set.cppo.ml

@@ -0,0 +1,205 @@
+#ifdef TYPE_INT
+module I = Belt_internalSetInt
+#elif defined TYPE_STRING
+module I = Belt_internalSetString
+#else
+  [%error "unknown type"]
+#endif  
+module N = Belt_internalAVLset
+module A = Belt_Array
+
+type value = I.value
+type t = I.t 
+
+
+let empty = None
+let isEmpty = N.isEmpty
+let minimum = N.minimum
+let minUndefined = N.minUndefined
+let maximum = N.maximum
+let maxUndefined = N.maxUndefined
+
+let forEach = N.forEach
+let forEachU = N.forEachU
+let reduce = N.reduce
+let reduceU = N.reduceU
+let every = N.every
+let everyU = N.everyU
+let some = N.some                
+let someU = N.someU
+let keep = N.keepShared              
+let keepU = N.keepSharedU
+let partition = N.partitionShared
+let partitionU = N.partitionSharedU
+                   
+let size = N.size
+let toList = N.toList
+let toArray = N.toArray
+let fromSortedArrayUnsafe = N.fromSortedArrayUnsafe
+let checkInvariantInternal = N.checkInvariantInternal
+
+let rec add  (t : t) (x : value) : t =
+  match t with 
+    None -> N.singleton x 
+  | Some nt  ->
+    let v = nt.value in  
+    if x = v then t else
+      let {N.left = l; right =  r} = nt in 
+      if x < v then 
+        let ll = add l x in 
+        if ll == l then t 
+        else N.bal ll v r
+      else 
+        let rr = add r x in 
+        if rr == r then t
+        else N.bal l v rr
+
+let mergeMany h arr =   
+  let len = A.length arr in 
+  let v = ref h in  
+  for i = 0 to len - 1 do 
+    let key = A.getUnsafe arr i in 
+    v .contents<- add v.contents  key 
+  done ;
+  v.contents 
+
+
+let rec remove (t : t) (x : value) : t = 
+  match t with 
+  | None -> t
+  | Some n  ->
+    let {N.left = l; value = v; right = r} = n in 
+    if x = v then 
+      match l, r with 
+      | None, _ -> r 
+      | _, None -> l 
+      | _, Some rn -> 
+        let v = ref rn.value in 
+        let r = N.removeMinAuxWithRef rn v in 
+        N.bal l v.contents r
+    else
+    if x < v then 
+      let ll = remove l x in  
+      if ll == l then t  
+      else N.bal ll v r 
+    else 
+      let rr = remove r x in 
+      if rr == r then t
+      else N.bal l v rr
+          
+let removeMany h arr = 
+  let len = A.length arr in 
+  let v = ref h in  
+  for i = 0 to len - 1 do 
+    let key = A.getUnsafe arr i in 
+    v .contents<- remove v.contents  key 
+  done ;
+  v.contents 
+          
+let fromArray = I.fromArray
+let cmp = I.cmp 
+let eq = I.eq 
+let get = I.get
+let getUndefined = I.getUndefined
+let getExn = I.getExn                
+let subset = I.subset 
+let has = I.has
+
+let rec splitAuxNoPivot (n : _ N.node) (x : value) : t * t =   
+  let {N.left = l; value = v; right = r} = n in  
+  if x = v then l,  r
+  else if x < v then
+    match l with 
+    | None -> 
+      None , Some n
+    | Some l -> 
+      let ll,  rl = splitAuxNoPivot l x in 
+      ll,  N.joinShared rl v r
+  else
+    match r with 
+    | None ->
+      Some n,  None
+    | Some r -> 
+      let lr,  rr = splitAuxNoPivot r x in
+      N.joinShared l v lr,  rr
+
+
+let rec splitAuxPivot (n : _ N.node) (x : value) pres : t  * t =   
+  let {N.left = l; value = v; right = r} = n in  
+  if x = v then begin 
+    pres .contents<- true;
+    (l, r)
+  end
+  else if x < v then
+    match l with 
+    | None -> 
+      None, Some n
+    | Some l -> 
+      let ll,  rl = splitAuxPivot l x pres in 
+      ll,  N.joinShared rl v r
+  else
+    match r with 
+    | None ->
+      Some n,  None
+    | Some r -> 
+      let lr,  rr = splitAuxPivot r x pres in
+      N.joinShared l v lr,  rr
+
+
+let split  (t : t) (x : value) =
+  match t with 
+    None ->
+    (None,  None), false
+  | Some n  ->    
+    let pres = ref false in 
+    let v = splitAuxPivot n  x pres  in 
+    v, pres.contents
+
+let rec union (s1 : t) (s2 : t) =
+  match s1, s2 with
+    (None, _) -> s2
+  | (_, None) -> s1
+  | Some n1, Some n2 (* (Node(l1, v1, r1, h1), Node(l2, v2, r2, h2)) *) ->    
+    let h1, h2 = n1.height, n2.height in             
+    if h1 >= h2 then
+      if h2 = 1 then add  s1 n2.value else begin
+        let {N.left = l1; value = v1; right = r1} = n1 in      
+        let (l2,  r2) = splitAuxNoPivot n2 v1 in
+        N.joinShared (union l1 l2) v1 (union r1 r2)
+      end
+    else
+    if h1 = 1 then add  s2 n1.value else begin
+      let {N.left = l2; value = v2; right = r2} = n2 in 
+      let (l1, r1) = splitAuxNoPivot n1 v2 in
+      N.joinShared (union l1 l2) v2 (union r1 r2)
+    end
+
+let  rec intersect (s1 : t) (s2 : t) =
+  match s1, s2 with
+    (None, _) 
+  | (_, None) -> None
+  | Some n1, Some n2 (* (Node(l1, v1, r1, _), t2) *) ->
+    let {N.left = l1; value = v1; right  = r1} = n1 in  
+    let pres = ref false in 
+    let l2,r2 =  splitAuxPivot n2 v1 pres in 
+    let ll = intersect l1 l2 in 
+    let rr = intersect r1 r2 in 
+    if pres.contents then N.joinShared ll v1 rr 
+    else N.concatShared ll rr 
+
+let rec diff (s1 : t) (s2 : t) =
+  match s1, s2 with
+  | (None, _) 
+  | (_, None) -> s1
+  | Some n1, Some n2 (* (Node(l1, v1, r1, _), t2) *) ->
+    let {N.left = l1; value = v1; right = r1} = n1 in
+    let pres = ref false in 
+    let l2, r2 = splitAuxPivot  n2 v1 pres in 
+    let ll = diff  l1 l2 in 
+    let rr = diff  r1 r2 in 
+    if pres.contents then N.concatShared ll rr 
+    else N.joinShared ll v1 rr 
+
+
+    
+

package/lib/ocaml/belt_Set.cppo.mli

@@ -0,0 +1,153 @@
+(* 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. *)
+
+(**
+  This module is [`Belt.Set`]() specialized with value type to be a primitive type.
+  It is more efficient in general, the  API is the same with [`Belt_Set`]() except its value type is fixed,
+  and identity is not needed(using the built-in one)
+
+  **See** [`Belt.Set`]()
+*)
+
+#ifdef TYPE_STRING
+type value = string
+#elif defined TYPE_INT
+type value = int
+#else
+[%error "unknown type"]
+#endif
+  (** The type of the set elements. *)
+
+
+type t
+(** The type of sets. *)
+
+val empty: t
+
+
+val fromArray: value array -> t
+
+val fromSortedArrayUnsafe: value array -> t
+
+val isEmpty: t -> bool
+
+val has: t -> value -> bool
+
+val add: t -> value -> t
+(** `add s x` If `x` was already in `s`, `s` is returned unchanged. *)
+
+val mergeMany: t -> value array -> t
+
+val remove: t -> value -> t
+(** `remove m x` If `x` was not in `m`, `m` is returned reference unchanged. *)
+
+val removeMany: t -> value array -> t
+
+val union: t -> t -> t
+
+val intersect: t -> t -> t
+
+val diff: t -> t -> t
+
+val subset: t -> t -> bool
+(** `subset s1 s2` tests whether the set `s1` is a subset of
+    the set `s2`. *)
+
+val cmp: t -> t -> int
+(** Total ordering between sets. Can be used as the ordering function
+    for doing sets of sets. *)
+
+val eq: t -> t -> bool
+(** `eq s1 s2` tests whether the sets `s1` and `s2` are
+    equal, that is, contain equal elements. *)
+
+val forEachU: t -> (value -> unit [@bs]) -> unit
+val forEach: t -> (value -> unit) -> unit
+(** `forEach s f` applies `f` in turn to all elements of `s`.
+    In increasing order *)
+
+val reduceU: t -> 'a -> ('a -> value -> 'a [@bs]) -> 'a
+val reduce: t -> 'a -> ('a -> value -> 'a) -> 'a
+(** Iterate in increasing order. *)
+
+val everyU: t -> (value -> bool [@bs]) -> bool
+val every: t -> (value -> bool) -> bool
+(** `every p s` checks if all elements of the set
+    satisfy the predicate `p`. Order unspecified. *)
+
+val someU: t -> (value -> bool [@bs]) -> bool
+val some: t -> (value -> bool) -> bool
+(** `some p s` checks if at least one element of
+    the set satisfies the predicate `p`. Oder unspecified. *)
+
+val keepU: t -> (value -> bool [@bs]) -> t
+val keep: t -> (value -> bool) -> t
+(** `keep p s` returns the set of all elements in `s`
+    that satisfy predicate `p`. *)
+
+val partitionU: t -> (value -> bool [@bs]) -> t * t
+val partition: t -> (value -> bool) -> t * t
+(**
+  `partition p s` returns a pair of sets `(s1, s2)`, where
+  `s1` is the set of all the elements of `s` that satisfy the
+  predicate `p`, and `s2` is the set of all the elements of
+  `s` that do not satisfy `p`.
+*)
+
+val size: t -> int
+
+val toList: t -> value list
+(** In increasing order *)
+
+val toArray: t -> value array
+
+val minimum: t -> value option
+
+val minUndefined: t -> value Js.undefined
+
+val maximum: t -> value option
+
+val maxUndefined: t -> value Js.undefined
+
+val get: t -> value -> value option
+
+val getUndefined: t -> value -> value Js.undefined
+
+val getExn: t -> value -> value
+
+val split: t -> value -> (t * t) * bool
+(**
+  `split x s` returns a triple `(l, present, r)`, where
+  `l` is the set of elements of `s` that are
+  strictly less than `x`;
+  `r` is the set of elements of `s` that are
+  strictly greater than `x`;
+  `present` is `false` if `s` contains no element equal to `x`,
+  or `true` if `s` contains an element equal to `x`.
+*)
+
+val checkInvariantInternal: t -> unit
+(**
+  **raise** when invariant is not held
+*)