Fix up several types and output

.terser.config.json

···
   "keep_fnames": true,
   "ie8": false,
   "compress": {
+    "pure_getters": true,
     "toplevel": true,
     "booleans_as_integers": false,
     "keep_fnames": true,

__tests__/wonka_test.re

···
       let talkback = ref((._: Wonka_types.talkbackT) => ());
       let num = ref(1);
 
-      let source = Wonka.scan((acc, x) => acc + x, 0, sink => sink(.Start((.signal) => {
+      let source = Wonka.scan((.acc, x) => acc + x, 0, sink => sink(.Start((.signal) => {
         switch (signal) {
         | Pull => {
           let i = num^;
···
     });
 
     testPromise("follows the spec for listenables", () => {
-      Wonka_thelpers.testWithListenable(Wonka.scan((_, x) => x, 0))
+      Wonka_thelpers.testWithListenable(Wonka.scan((._, x) => x, 0))
         |> Js.Promise.then_(x => {
           expect(x)
             |> toEqual(([||], [| Push(1), Push(2), End |]))
···
     testPromise("ends itself and source when its talkback receives the End signal", () => {
       let end_: talkbackT = Close;
 
-      Wonka_thelpers.testTalkbackEnd(Wonka.scan((_, x) => x, 0))
+      Wonka_thelpers.testTalkbackEnd(Wonka.scan((._, x) => x, 0))
         |> Js.Promise.then_(x => {
           expect(x)
             |> toEqual(([| end_ |], [| Push(1) |]))
···
          [|Push(40), Push(50)|],
        );
   });
-});
+});

src/index.js

···
 export * from './pipe';
 export * from './wonka';
-export * from './web/wonkaJs';

src/operators/wonka_operator_combine.d.ts

···
 import { Source } from '../wonka_types';
 
-export const combine: <A, B>(a: Source<A>, b: Source<B>) => Source<[A, B]>;
+export const combine: <A, B>(a: Source<A>) => (b: Source<B>) => Source<[A, B]>;

src/operators/wonka_operator_combine.re

···
   mutable ended: bool,
 };
 
-let combine = (sourceA, sourceB) => curry(sink => {
+let combine = sourceA => curry(sourceB => curry(sink => {
   let state = {
     talkbackA: talkbackPlaceholder,
     talkbackB: talkbackPlaceholder,
···
       }
     };
   }));
-});
+}));

src/operators/wonka_operator_scan.re

···
   source((.signal) => sink(.
     switch (signal) {
     | Push(x) => {
-      acc := f(acc^, x);
+      acc := f(.acc^, x);
       Push(acc^)
     }
     | Start(x) => Start(x)

src/operators/wonka_operator_scan.rei

···
 open Wonka_types;
 
-let scan: (('b, 'a) => 'b, 'b, sourceT('a), sinkT('b)) => unit;
+let scan: ((.'b, 'a) => 'b, 'b, sourceT('a), sinkT('b)) => unit;

src/wonka.d.ts

···
 /* sinks */
 export * from './sinks/wonka_sink_publish';
 export * from './sinks/wonka_sink_subscribe';
+
+export * from './web/wonkaJs';