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

package/lib/ocaml/belt_Option.ml

@@ -1,93 +0,0 @@
-(* Copyright (C) 2017 Hongbo Zhang, 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. *)
-
-
-let keepU opt p = match opt with
-  | Some x as some when (p x [@bs]) -> some
-  | _ -> None
-
-let keep opt p = keepU opt (fun[@bs] x -> p x)
-
-let forEachU opt f = match opt with
-  | Some x -> (f x [@bs])
-  | None  -> ()
-
-let forEach opt f = forEachU opt (fun[@bs] x -> f x)
-
-let getExn = function
-  | Some x -> x
-  | None -> raise Not_found
-
-external getUnsafe : 'a option -> 'a = "%identity"  
-
-let mapWithDefaultU opt default f = match opt with
-  | Some x -> (f x [@bs])
-  | None -> default
-
-let mapWithDefault opt default f = mapWithDefaultU opt default (fun[@bs] x -> f x)
-
-let mapU opt f = match opt with
-  | Some x -> Some (f x [@bs])
-  | None -> None
-
-let map opt f = mapU opt (fun[@bs] x -> f x)
-
-let flatMapU opt f = match opt with
-  | Some x -> (f x [@bs])
-  | None -> None
-
-let flatMap opt f = flatMapU opt (fun[@bs] x -> f x)
-
-let getWithDefault opt default = match opt with
-  | Some x -> x
-  | None -> default
-
-let orElse opt other = match opt with
-  | Some _ as some -> some
-  | None -> other
-
-let isSome = function
-  | Some _ -> true
-  | None -> false
-
-let isNone x = x = None
-
-let eqU a b f = 
-  match a with 
-  | Some a -> 
-    begin match b with 
-    | None -> false 
-    | Some b -> f a b [@bs]
-    end 
-  | None -> b = None
-  
-let eq a b f = eqU a b (fun[@bs] x y -> f x y)
-
-let cmpU a b f = match (a, b) with
-  | (Some a, Some b) -> f a b [@bs]
-  | (None, Some _) -> -1
-  | (Some _, None) -> 1
-  | (None, None) -> 0
-
-let cmp a b f = cmpU a b (fun[@bs] x y -> f x y)

package/lib/ocaml/belt_Option.mli

@@ -1,270 +0,0 @@
-(* 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. *)
-
-(**
-   In Belt we represent the existence and nonexistence of a value by wrapping it
-   with the `option` type.  In order to make it a bit more convenient to work with
-   option-types, Belt provides utility-functions for it.
-
-   The `option` type is a part of the ReScript standard library which is defined like this:
-
-   ```res sig
-   type option<'a> = None | Some('a)
-   ```
-
-   ```res example
-   let someString: option<string> = Some("hello")
-   ```
-*)
-
-
-val keepU : 'a option -> ('a -> bool [@bs]) -> 'a option
-(** Uncurried version of `keep` *)
-
-val keep : 'a option -> ('a -> bool) -> 'a option
-(**
-   If `optionValue` is `Some(value)` and `p(value) = true`, it returns `Some(value)`; otherwise returns `None`
-
-   ```res example
-   Belt.Option.keep(Some(10), x => x > 5) /* returns `Some(10)` */
-   Belt.Option.keep(Some(4), x => x > 5) /* returns `None` */
-   Belt.Option.keep(None, x => x > 5) /* returns `None` */
-   ```
-*)
-
-val forEachU : 'a option -> ('a -> unit [@bs]) -> unit
-(** Uncurried version of `forEach` *)
-
-val forEach : 'a option -> ('a -> unit) -> unit
-(**
-   If `optionValue` is `Some(value`), it calls `f(value)`; otherwise returns `()`
-
-   ```res example
-   Belt.Option.forEach(Some("thing"), x => Js.log(x)) /* logs "thing" */
-   Belt.Option.forEach(None, x => Js.log(x)) /* returns () */
-   ```
-*)
-
-val getExn : 'a option -> 'a
-(**
-   Raises an Error in case `None` is provided. Use with care.
-
-   ```res example
-   Belt.Option.getExn(Some(3)) /* 3 */
-
-   Belt.Option.getExn(None) /* Raises an Error */
-   ```
-*)
-
-external getUnsafe :
-  'a option -> 'a = "%identity"
-(**
-   `getUnsafe(x)` returns `x`
-
-   This is an unsafe operation, it assumes `x` is neither `None`
-   nor `Some(None(...)))`
-*)
-
-val mapWithDefaultU : 'a option -> 'b -> ('a -> 'b [@bs]) -> 'b
-(** Uncurried version of `mapWithDefault` *)
-
-val mapWithDefault : 'a option -> 'b -> ('a -> 'b) -> 'b
-(**
-   If `optionValue` is of `Some(value)`,
-   this function returns that value applied with `f`, in other words `f(value)`.
-
-   If `optionValue` is `None`, the default is returned.
-
-   ```res example
-   let someValue = Some(3)
-   someValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 8 */
-
-   let noneValue = None
-   noneValue->Belt.Option.mapWithDefault(0, x => x + 5) /* 0 */
-   ```
-*)
-
-val mapU : 'a option -> ('a -> 'b [@bs]) -> 'b option
-(** Uncurried version of `map` *)
-
-val map : 'a option -> ('a -> 'b) -> 'b option
-(**
-   If `optionValue` is `Some(value)` this returns `f(value)`, otherwise it returns `None`.
-
-   ```res example
-   Belt.Option.map(Some(3), x => x * x) /* Some(9) */
-
-   Belt.Option.map(None, x => x * x) /* None */
-   ```
-*)
-
-val flatMapU : 'a option -> ('a -> 'b option [@bs]) -> 'b option
-(** Uncurried version of `flatMap` *)
-
-val flatMap : 'a option -> ('a -> 'b option) -> 'b option
-(**
-   If `optionValue` is `Some(value)`, returns `f(value)`, otherwise returns
-   `None`.<br/>
-   The function `f` must have a return type of `option<'b>`.
-
-   ```res example
-   let addIfAboveOne = value =>
-     if (value > 1) {
-       Some(value + 1)
-     } else {
-       None
-     }
-
-   Belt.Option.flatMap(Some(2), addIfAboveOne) /* Some(3) */
-
-   Belt.Option.flatMap(Some(-4), addIfAboveOne) /* None */
-
-   Belt.Option.flatMap(None, addIfAboveOne) /* None */
-   ```
-*)
-
-val getWithDefault : 'a option -> 'a -> 'a
-(**
-   If `optionalValue` is `Some(value)`, returns `value`, otherwise default.
-
-   ```res example
-   Belt.Option.getWithDefault(None, "Banana") /* Banana */
-
-   Belt.Option.getWithDefault(Some("Apple"), "Banana") /* Apple */
-   ```
-
-   ```res example
-   let greet = (firstName: option<string>) =>
-     "Greetings " ++ firstName->Belt.Option.getWithDefault("Anonymous")
-
-   Some("Jane")->greet /* "Greetings Jane" */
-
-   None->greet /* "Greetings Anonymous" */
-   ```
-*)
-
-val orElse : 'a option -> 'a option -> 'a option
-(**
-   `orElse optionalValue otherOptional`
-
-   If `optionalValue` is `Some value`, returns `Some value`, otherwise `otherOptional`
-
-   ```
-   orElse (Some 1812) (Some 1066) = Some 1812;;
-   orElse None (Some 1066) = Some 1066;;
-   orElse None None = None;;
-   ```
-*)
-
-val isSome : 'a option -> bool
-(**
-   Returns `true` if the argument is `Some(value)`, `false` otherwise.
-
-   ```res example
-   Belt.Option.isSome(None) /* false */
-
-   Belt.Option.isSome(Some(1)) /* true */
-   ```
-*)
-
-val isNone : 'a option -> bool
-(**
-   Returns `true` if the argument is `None`, `false` otherwise.
-
-   ```res example
-   Belt.Option.isNone(None) /* true */
-
-   Belt.Option.isNone(Some(1)) /* false */
-   ```
-*)
-
-val eqU : 'a option -> 'b option -> ('a -> 'b -> bool [@bs]) -> bool
-(**
-   Uncurried version of `eq`
-*)
-
-val eq : 'a option -> 'b option -> ('a -> 'b -> bool) -> bool
-(**
-   Evaluates two optional values for equality with respect to a predicate
-   function. If both `optValue1` and `optValue2` are `None`, returns `true`.
-   If one of the arguments is `Some(value)` and the other is `None`, returns
-   `false`.
-
-   If arguments are `Some(value1)` and `Some(value2)`, returns the result of
-   `predicate(value1, value2)`; the predicate function must return a bool.
-
-   ```res example
-   let clockEqual = (a, b) => mod(a, 12) == mod(b, 12)
-
-   open Belt.Option
-
-   eq(Some(3), Some(15), clockEqual) /* true */
-
-   eq(Some(3), None, clockEqual) /* false */
-
-   eq(None, Some(3), clockEqual) /* false */
-
-   eq(None, None, clockEqual) /* true */
-   ```
-*)
-
-val cmpU : 'a option -> 'b option -> ('a -> 'b -> int [@bs]) -> int
-(** Uncurried version of `cmp` *)
-
-val cmp : 'a option -> 'b option -> ('a -> 'b -> int) -> int
-(**
-   `cmp(optValue1, optValue2, comparisonFunction)` compares two optional values
-   with respect to given `comparisonFunction`.
-
-   If both `optValue1` and `optValue2` are `None`, it returns `0`.
-
-   If the first argument is `Some(value1)` and the second is `None`, returns `1`
-   (something is greater than nothing).
-
-   If the first argument is `None` and the second is `Some(value2)`, returns `-1`
-   (nothing is less than something).
-
-   If the arguments are `Some(value1)` and `Some(value2)`, returns the result of
-   `comparisonFunction(value1, value2)`; comparisonFunction takes two arguments
-   and returns `-1` if the first argument is less than the second, `0` if the
-   arguments are equal, and `1` if the first argument is greater than the second.
-
-   ```res example
-   let clockCompare = (a, b) => compare(mod(a, 12), mod(b, 12))
-
-   open Belt.Option
-
-   cmp(Some(3), Some(15), clockCompare) /* 0 */
-
-   cmp(Some(3), Some(14), clockCompare) /* 1 */
-
-   cmp(Some(2), Some(15), clockCompare) /* (-1) */
-
-   cmp(None, Some(15), clockCompare) /* (-1) */
-
-   cmp(Some(14), None, clockCompare) /* 1 */
-
-   cmp(None, None, clockCompare) /* 0 */
-   ```
-*)

package/lib/ocaml/belt_Range.ml

@@ -1,76 +0,0 @@
-
-(* Copyright (C) 2017 Hongbo Zhang, 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. *)
-
-
-
-let forEachU s f action =
-  for i = s to f do
-    (action i [@bs] : unit)
-  done
-
-let forEach s f action = forEachU s f (fun[@bs] a -> action a)
-    
-let rec everyU s f p =
-  if s > f then true
-  else
-    p s [@bs] &&
-    (everyU (s + 1) f p )
-  
-let every s f p = everyU s f (fun [@bs] a -> p a)
-    
-let rec everyByAux s f ~step p =
-  if s > f then true
-  else
-    p s [@bs] &&
-    (everyByAux (s + step) f ~step p )
-
-let everyByU s f ~step p = 
-  if step > 0 then 
-     everyByAux s f ~step p
-  else true (* return empty range `true`*)  
-
-let everyBy s f ~step p = everyByU s f ~step (fun [@bs] a -> p a)
-
-let rec someU s f p =  
-  if s > f then false
-  else
-    p s [@bs] ||
-    (someU (s + 1) f p )
-
-
-let some s f p = someU s f (fun[@bs] a -> p a)
-
-let rec someByAux s f ~step p =  
-  if s > f then false
-  else
-    p s [@bs] ||
-    (someByAux (s + step) f ~step p )
-    
-let someByU s f ~step p = 
-    if step > 0 then 
-      someByAux s f ~step p 
-    else false  (* return empty range, `false` *) 
-
-let someBy s f ~step p = someByU s f ~step (fun[@bs] a -> p a)

package/lib/ocaml/belt_Range.mli

@@ -1,114 +0,0 @@
-(* 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. *)
-
-(** 
-  A small utility module to provide inclusive range operations for `[start,
-  finish]`.  Internally it is relying on loops instead of creating new arrays,
-  which makes it pretty performant and memory friendly.
-*)
-
-val forEachU : int -> int -> ((int -> unit)[@bs]) -> unit
-
-val forEach : int -> int -> (int -> unit) -> unit
-(**
-  `forEach(start, finish, action)`
-
-  equivalent to `Belt.Array.(forEach(range(start, finish), action))`
-
-  ```res example
-  Belt.Range.forEach(0, 4, (i) => Js.log(i))
-
-  /**
-   * prints:
-   *   0
-   *   1
-   *   2
-   *   3
-   *   4
-   */
-  ```
-*)
-
-val everyU : int -> int -> ((int -> bool)[@bs]) -> bool
-
-val every : int -> int -> (int -> bool) -> bool
-(**
-  `every(start, finish, p)`
-
-  equivalent to `Belt.Array.(every(range(start, finish), p))`
-
-  ```res example
-  Belt.Range.every(0, 4, (i) => i < 5) /* true */
-
-  Belt.Range.every(0, 4, (i) => i < 4) /* false */
-  ```
-*)
-
-val everyByU : int -> int -> step:int -> ((int -> bool)[@bs]) -> bool
-
-val everyBy : int -> int -> step:int -> (int -> bool) -> bool
-(**
-  `everyBy(start, finish, ~step, p)`
-
-  See `Belt_Array.rangeBy`
-
-  equivalent to `Belt.Array.(every(rangeBy(start, finish, ~step), p))`
-
-  ```res example
-  Belt.Range.everyBy(0, 4, ~step=1, (i) => mod(i, 2) === 0) /* false */
-
-  Belt.Range.everyBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-  ```
-*)
-
-val someU : int -> int -> ((int -> bool)[@bs]) -> bool
-
-val some : int -> int -> (int -> bool) -> bool
-(**
-  `some(start, finish, p)`
-
-  equivalent to `Belt.Array.(some(range(start, finish), p))`
-
-  ```res example
-  Belt.Range.some(0, 4, (i) => i > 5) /* false */
-
-  Belt.Range.some(0, 4, (i) => i > 2) /* true */
-  ```
-*)
-
-val someByU : int -> int -> step:int -> ((int -> bool)[@bs]) -> bool
-
-val someBy : int -> int -> step:int -> (int -> bool) -> bool
-(**
-  `someBy(start, finish, ~step, p)`
-
-  See `Belt_Array.rangeBy`
-
-  equivalent to `Belt.Array.(some(rangeBy(start, finish, ~step), p))`
-
-  ```res example
-  Belt.Range.someBy(1, 5, ~step=2, (i) => mod(i, 2) === 0) /* false */
-  Belt.Range.someBy(0, 4, ~step=2, (i) => mod(i, 2) === 0) /* true */
-  ```
-*)

package/lib/ocaml/belt_Result.ml

@@ -1,75 +0,0 @@
-(* Copyright (C) 2017 Hongbo Zhang, 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. *)
-
-type ('a,'b) t = Ok of 'a | Error of 'b
-
-let getExn = function
-  | Ok x -> x
-  | Error _ -> raise Not_found
-
-let mapWithDefaultU opt default f = match opt with
-  | Ok x -> (f x [@bs])
-  | Error _ -> default
-
-let mapWithDefault opt default f = mapWithDefaultU opt default (fun[@bs] x -> f x)
-
-let mapU opt f = match opt with
-  | Ok x -> Ok (f x [@bs])
-  | Error y -> Error y
-
-let map opt f = mapU opt (fun[@bs] x -> f x)
-
-let flatMapU opt f = match opt with
-  | Ok x -> (f x [@bs])
-  | Error y -> Error y
-
-let flatMap opt f = flatMapU opt (fun[@bs] x -> f x)
-
-let getWithDefault opt default = match opt with
-  | Ok x -> x
-  | Error _ -> default
-
-let isOk = function
-  | Ok _ -> true
-  | Error _ -> false
-
-let isError = function
-  | Ok _ -> false
-  | Error _ -> true
-
-let eqU a b f = match (a, b) with
-  | (Ok a, Ok b) -> f a b [@bs]
-  | (Error _, Ok _)
-  | (Ok _, Error _) -> false
-  | (Error _, Error _) -> true
-
-let eq a b f = eqU a b (fun[@bs] x y -> f x y)
-
-let cmpU a b f = match (a, b) with
-  | (Ok a, Ok b) -> f a b [@bs]
-  | (Error _, Ok _) -> -1
-  | (Ok _, Error _) -> 1
-  | (Error _, Error _) -> 0
-
-let cmp a b f = cmpU a b (fun[@bs] x y -> f x y)