add 'EventEmitter' & 'Event' modules.

Author: austindd

src/Event.re

@@ -0,0 +1,45 @@
+/**
+ * The `Event` type represents the strings/symbols used in Node to
+ * identify event types for `EventEmitter` and its subclasses, including
+ * streams, sockets, and servers.
+ * 
+ * Given a type signature `Event.t('a => 'b, 'ty)`, the first type
+ * variable, `'a => 'b`, denotes the type signature of the event listener
+ * function, and `'ty` denotes the type of the associated `EventEmitter`.
+ * 
+ * These abstract `Event.t` types must be passed to `EventEmitter`
+ * functions to register event listeners or emit events. By encoding the
+ * listener function type in a type variable, we can ensure that each
+ * listener has the correct type. The type parameter for the emitter
+ * prevents two different emitters from using each other's events.
+ * 
+ * While this gives us some degree of type safety, it is still possible
+ * to introduce runtime errors with this API. In particular, two or more
+ * `Event.t` types can be defined from the same string/symbol, but with
+ * different listener types. Therefore, we strongly recommend using
+ * 100% unique strings/symbols to define events.
+ * 
+ */
+type t('listener, 'ty);
+external fromString: string => t('a => 'b, 'ty) = "%identity";
+external fromSymbol: Js.Types.symbol => t('a => 'b, 'ty) = "%identity";
+external unsafeToString: t('a => 'b, 'ty) => string = "%identity";
+external unsafeToSymbol: t('a => 'b, 'ty) => Js.Types.symbol = "%identity";
+type case =
+  | String(string)
+  | Symbol(Js.Types.symbol)
+  | Unknown;
+let classify = evt => {
+  switch (Js.typeof(evt)) {
+  | "string" => String(unsafeToString(evt))
+  | "symbol" => Symbol(unsafeToSymbol(evt))
+  | _ => Unknown
+  };
+};
+let eq = (event1, event2) => {
+  switch (Js.typeof(event1), Js.typeof(event2)) {
+  | ("string", "string") => Obj.magic(event1) === Obj.magic(event2)
+  | ("symbol", "symbol") => Obj.magic(event1) === Obj.magic(event2)
+  | _ => false
+  };
+};

src/EventEmitter.re

@@ -0,0 +1,72 @@
+/**
+ * `Impl` is a functor which generates FFI bindings to Node's `EventEmitter`
+ * class for any type `t`. This is not inherently type-safe. Type-safety can
+ * be achieved by implementing the known `Event.t('a => 'b, t)` types
+ */
+module Impl = (T: {type t;}) => {
+  [@bs.send]
+  external addListener: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t =
+    "addListener";
+  [@bs.send]
+  external emit: (T.t, Event.t('a => 'b, T.t), 'a) => bool = "emit";
+  [@bs.get] external errorMonitor: T.t => Js.Types.symbol = "errorMonitor";
+  [@bs.send]
+  external eventNames:
+    (T.t, Event.t('a => 'b, T.t)) => array(Event.t('a => 'b, T.t)) =
+    "eventNames";
+  [@bs.send] external getMaxListeners: T.t => int = "getMaxListeners";
+  [@bs.send]
+  external listenerCount: (T.t, Event.t('a => 'b, T.t)) => int =
+    "listenerCount";
+  [@bs.send]
+  external listeners: (T.t, Event.t('a => 'b, T.t)) => array('a => 'b) =
+    "listeners";
+  [@bs.send]
+  external on: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t = "on";
+  [@bs.send]
+  external once: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t = "once";
+  [@bs.send]
+  external off: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t = "off";
+  [@bs.send]
+  external prependListener: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t =
+    "prependListener";
+  [@bs.send]
+  external prependOnceListener: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t =
+    "prependOnceListener";
+  [@bs.send] external removeAllListeners: T.t => T.t = "removeAllListeners";
+  [@bs.send]
+  external removeListener: (T.t, Event.t('a => 'b, T.t), 'a => 'b) => T.t =
+    "removeListener";
+  [@bs.send] external setMaxListeners: (T.t, int) => T.t = "setMaxListeners";
+
+  [@bs.send]
+  external onNewListener:
+    (
+      T.t,
+      [@bs.as "newListener"] _,
+      (Event.t('a => 'b, T.t), 'a => 'b) => unit
+    ) =>
+    T.t =
+    "on";
+  [@bs.send]
+  external onRemoveListener:
+    (
+      T.t,
+      [@bs.as "removeListener"] _,
+      (Event.t('a => 'b, T.t), 'a => 'b) => unit
+    ) =>
+    T.t =
+    "on";
+};
+
+/**
+ * A generative functor that creates a unique type `t` with the `EventEmitter`
+ * interface bindings.
+*/
+module Make = (()) => {
+  type t;
+  include Impl({
+    type nonrec t = t;
+  });
+  [@bs.module "events"] [@bs.new] external make: unit => t = "EventEmitter";
+};