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

package/lib/ocaml/mapm.cppo.mli

@@ -1,138 +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. *)
-
-#ifdef TYPE_STRING
-type key = string
-#elif defined TYPE_INT
-type key = int
-#else
-[%error "unknown type"]
-#endif
-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/moreLabels.ml

@@ -1,22 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*                Jacques Garrigue, Kyoto University RIMS                 *)
-(*                                                                        *)
-(*   Copyright 2001 Institut National de Recherche en Informatique et     *)
-(*     en Automatique.                                                    *)
-(*                                                                        *)
-(*   All rights reserved.  This file is distributed under the terms of    *)
-(*   the GNU Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(* Module [MoreLabels]: meta-module for compatibility labelled libraries *)
-
-module Hashtbl = HashtblLabels
-
-module Map = MapLabels
-
-module Set = SetLabels

package/lib/ocaml/moreLabels.mli

@@ -1,198 +0,0 @@
-(**************************************************************************)
-(*                                                                        *)
-(*                                 OCaml                                  *)
-(*                                                                        *)
-(*                Jacques Garrigue, Kyoto University RIMS                 *)
-(*                                                                        *)
-(*   Copyright 2001 Institut National de Recherche en Informatique et     *)
-(*     en Automatique.                                                    *)
-(*                                                                        *)
-(*   All rights reserved.  This file is distributed under the terms of    *)
-(*   the GNU Lesser General Public License version 2.1, with the          *)
-(*   special exception on linking described in the file LICENSE.          *)
-(*                                                                        *)
-(**************************************************************************)
-
-(** Extra labeled libraries.
-
-   This meta-module provides labelized version of the {!Hashtbl},
-   {!Map} and {!Set} modules.
-
-   They only differ by their labels. They are provided to help
-   porting from previous versions of OCaml.
-   The contents of this module are subject to change.
-*)
-
-module Hashtbl : sig
-  type ('a, 'b) t = ('a, 'b) Hashtbl.t
-  val create : ?random:bool -> int -> ('a, 'b) t
-  val clear : ('a, 'b) t -> unit
-  val reset : ('a, 'b) t -> unit
-  val copy : ('a, 'b) t -> ('a, 'b) t
-  val add : ('a, 'b) t -> key:'a -> data:'b -> unit
-  val find : ('a, 'b) t -> 'a -> 'b
-  val find_opt : ('a, 'b) t -> 'a -> 'b option
-  val find_all : ('a, 'b) t -> 'a -> 'b list
-  val mem : ('a, 'b) t -> 'a -> bool
-  val remove : ('a, 'b) t -> 'a -> unit
-  val replace : ('a, 'b) t -> key:'a -> data:'b -> unit
-  val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit
-  val filter_map_inplace:
-    f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit
-  val fold :
-      f:(key:'a -> data:'b -> 'c -> 'c) ->
-        ('a, 'b) t -> init:'c -> 'c
-  val length : ('a, 'b) t -> int
-  val randomize : unit -> unit
-  val is_randomized : unit -> bool
-  type statistics = Hashtbl.statistics
-  val stats : ('a, 'b) t -> statistics
-  module type HashedType = Hashtbl.HashedType
-  module type SeededHashedType = Hashtbl.SeededHashedType
-  module type S =
-    sig
-      type key
-      and 'a t
-      val create : int -> 'a t
-      val clear : 'a t -> unit
-      val reset : 'a t -> unit
-      val copy : 'a t -> 'a t
-      val add : 'a t -> key:key -> data:'a -> unit
-      val remove : 'a t -> key -> unit
-      val find : 'a t -> key -> 'a
-      val find_opt: 'a t -> key -> 'a option
-      val find_all : 'a t -> key -> 'a list
-      val replace : 'a t -> key:key -> data:'a -> unit
-      val mem : 'a t -> key -> bool
-      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
-      val filter_map_inplace:
-        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
-      val fold :
-          f:(key:key -> data:'a -> 'b -> 'b) ->
-          'a t -> init:'b -> 'b
-      val length : 'a t -> int
-      val stats: 'a t -> statistics
-    end
-  module type SeededS =
-    sig
-      type key
-      and 'a t
-      val create : ?random:bool -> int -> 'a t
-      val clear : 'a t -> unit
-      val reset : 'a t -> unit
-      val copy : 'a t -> 'a t
-      val add : 'a t -> key:key -> data:'a -> unit
-      val remove : 'a t -> key -> unit
-      val find : 'a t -> key -> 'a
-      val find_opt : 'a t -> key -> 'a option
-      val find_all : 'a t -> key -> 'a list
-      val replace : 'a t -> key:key -> data:'a -> unit
-      val mem : 'a t -> key -> bool
-      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
-      val filter_map_inplace:
-        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
-      val fold :
-          f:(key:key -> data:'a -> 'b -> 'b) ->
-          'a t -> init:'b -> 'b
-      val length : 'a t -> int
-      val stats: 'a t -> statistics
-    end
-  module Make : functor (H : HashedType) -> S with type key = H.t
-  module MakeSeeded (H : SeededHashedType) : SeededS with type key = H.t
-  val hash : 'a -> int
-  val seeded_hash : int -> 'a -> int
-  val hash_param : int -> int -> 'a -> int
-  val seeded_hash_param : int -> int -> int -> 'a -> int
-end
-
-module Map : sig
-  module type OrderedType = Map.OrderedType
-  module type S =
-    sig
-      type key
-      and (+'a) t
-      val empty : 'a t
-      val is_empty: 'a t -> bool
-      val mem : key -> 'a t -> bool
-      val add : key:key -> data:'a -> 'a t -> 'a t
-      val update: key:key -> f:('a option -> 'a option) -> 'a t -> 'a t
-      val singleton: key -> 'a -> 'a t
-      val remove : key -> 'a t -> 'a t
-      val merge:
-          f:(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
-      val union: f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
-      val compare: cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
-      val equal: cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
-      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
-      val fold :
-          f:(key:key -> data:'a -> 'b -> 'b) ->
-          'a t -> init:'b -> 'b
-      val for_all: f:(key -> 'a -> bool) -> 'a t -> bool
-      val exists: f:(key -> 'a -> bool) -> 'a t -> bool
-      val filter: f:(key -> 'a -> bool) -> 'a t -> 'a t
-      val partition: f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
-      val cardinal: 'a t -> int
-      val bindings: 'a t -> (key * 'a) list
-      val min_binding: 'a t -> (key * 'a)
-      val min_binding_opt: 'a t -> (key * 'a) option
-      val max_binding: 'a t -> (key * 'a)
-      val max_binding_opt: 'a t -> (key * 'a) option
-      val choose: 'a t -> (key * 'a)
-      val choose_opt: 'a t -> (key * 'a) option
-      val split: key -> 'a t -> 'a t * 'a option * 'a t
-      val find : key -> 'a t -> 'a
-      val find_opt: key -> 'a t -> 'a option
-      val find_first : f:(key -> bool) -> 'a t -> key * 'a
-      val find_first_opt : f:(key -> bool) -> 'a t -> (key * 'a) option
-      val find_last : f:(key -> bool) -> 'a t -> key * 'a
-      val find_last_opt : f:(key -> bool) -> 'a t -> (key * 'a) option
-      val map : f:('a -> 'b) -> 'a t -> 'b t
-      val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
-  end
-  module Make : functor (Ord : OrderedType) -> S with type key = Ord.t
-end
-
-module Set : sig
-  module type OrderedType = Set.OrderedType
-  module type S =
-    sig
-      type elt
-      and t
-      val empty : t
-      val is_empty : t -> bool
-      val mem : elt -> t -> bool
-      val add : elt -> t -> t
-      val singleton : elt -> t
-      val remove : elt -> t -> t
-      val union : t -> t -> t
-      val inter : t -> t -> t
-      val diff : t -> t -> t
-      val compare : t -> t -> int
-      val equal : t -> t -> bool
-      val subset : t -> t -> bool
-      val iter : f:(elt -> unit) -> t -> unit
-      val map : f:(elt -> elt) -> t -> t
-      val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
-      val for_all : f:(elt -> bool) -> t -> bool
-      val exists : f:(elt -> bool) -> t -> bool
-      val filter : f:(elt -> bool) -> t -> t
-      val partition : f:(elt -> bool) -> t -> t * t
-      val cardinal : t -> int
-      val elements : t -> elt list
-      val min_elt : t -> elt
-      val min_elt_opt: t -> elt option
-      val max_elt : t -> elt
-      val max_elt_opt: t -> elt option
-      val choose : t -> elt
-      val choose_opt: t -> elt option
-      val split: elt -> t -> t * bool * t
-      val find: elt -> t -> elt
-      val find_opt: elt -> t -> elt option
-      val find_first: f:(elt -> bool) -> t -> elt
-      val find_first_opt: f:(elt -> bool) -> t -> elt option
-      val find_last: f:(elt -> bool) -> t -> elt
-      val find_last_opt: f:(elt -> bool) -> t -> elt option
-      val of_list: elt list -> t
-    end
-  module Make : functor (Ord : OrderedType) -> S with type elt = Ord.t
-end

package/lib/ocaml/node.ml

@@ -1,84 +0,0 @@
-(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
- *
- * 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. *)
-
-(** Placeholder for Node bindings *)
-
-[@@@warning "-49"]
-
-module Path = Node_path
-
-module Fs = Node_fs
-
-module Process = Node_process
-
-module Module =  Node_module
-module Buffer = Node_buffer
-module Child_process = Node_child_process
-
-type node_exports
-type node_module = <
-       id : string ;
-       exports : node_exports ;
-       parrent : node_module Js.null_undefined;
-       (* in REPL V4 it is `undefined`
-          in CLI it can be `null`
-       *)
-
-       filename : string ;
-
-       loaded : bool;
-       children : node_module array ;
-       paths : string array;
->
-(* WARN:
-  its path name should not be changed
-  see [`Ppx_entry`]()
-*)
-
-type node_require = <
-  main : node_module Js.undefined;
-
-  resolve : string -> string [@bs]
-  (* **raise** exception *)
->
-(* WARN:
-  its path name should not be changed
-  see [`Ppx_entry`]()
-*)
-
-type string_buffer (* can be either string or buffer *)
-
-type buffer
-
-type _ string_buffer_kind =
-  | String :  string string_buffer_kind
-  | Buffer :  buffer string_buffer_kind
-
-
-(** We expect a good inliner will eliminate such boxing in the future *)
-let test (type t) (x : string_buffer) : (t string_buffer_kind * t)=
-  if Js.typeof x = "string" then
-    (Obj.magic String : t string_buffer_kind),  (Obj.magic x : t)
-  else
-    (Obj.magic Buffer : t string_buffer_kind), (Obj.magic x : t)

package/lib/ocaml/node_buffer.ml

@@ -1,47 +0,0 @@
-(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
- * 
- * 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. *)
-
-(** Node Buffer API *)
-
-type t = Node.buffer 
-
-external isBuffer : 'a -> bool = "Buffer.isBuffer" 
-[@@bs.val]
-
-external fromString : string -> t = "Buffer.from"
-[@@bs.val]
-
-type encoding = 
-  [ `ascii  | `utf8  | `utf16le  | `usc2  | `base64  | `latin1 | `binary  | `hex ]  
-external fromStringWithEncoding : string -> encoding -> t = "from"
-[@@bs.val] [@@bs.scope "Buffer"]
-
-external toString : t -> string = "toString"
-[@@bs.send]
-
-external toStringWithEncoding : t -> encoding -> string = "toString"
-[@@bs.send]
-
-external concat : t array -> t = "Buffer.concat"
-[@@bs.val]

package/lib/ocaml/node_child_process.ml

@@ -1,50 +0,0 @@
-(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
- *
- * 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. *)
-
-(** Node Child Process API *)
-
-type option
-
-external option : ?cwd:string -> ?encoding:string -> unit -> option = "" [@@bs.obj]
-
-(* TODO: when no option it would return buffer  *)
-external execSync : string -> option -> string = "execSync" [@@bs.module "child_process"]
-
-(*
-  Note we have to make it abstract type, since if you declare it as
-  `< pid : float > Js.t`, then you will create other external
-  functions which will work with this type too, it is not what you want
-*)
-type spawnResult
-
-
-external spawnSync : string -> spawnResult = "spawnSync" [@@bs.module "child_process"]
-
-external readAs : spawnResult ->
-  < pid : int ;
-    status : int Js.null;
-    signal : string Js.null ;
-    stdout : Node.string_buffer Js.null ;
-    stderr : Node.string_buffer Js.null >  =
-  "%identity"