@tellahq/rescript 10.1.0-alpha.1

package/lib/ocaml/mapm.cppo.mli

@@ -0,0 +1,138 @@
+(* 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

@@ -0,0 +1,22 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 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

@@ -0,0 +1,198 @@
+(**************************************************************************)
+(*                                                                        *)
+(*                                 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

@@ -0,0 +1,84 @@
+(* 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

@@ -0,0 +1,47 @@
+(* 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

@@ -0,0 +1,50 @@
+(* 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"