···

       
1265
       
 
       
        sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       
1266
       
 
       
      };

     

       
1267
       
 
       


     

       
1268
       
-
       
      let unsubscribe = Wonka.subscribe(x => ignore(Js.Array.push(x, nums)), source);

     

       
1269
       
 
       


     

       
1270
       
 
       
      push^();

     

       
1271
       
 
       
      push^();

     

···

       
1265
       
 
       
        sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       
1266
       
 
       
      };

     

       
1267
       
 
       


     

       
1268
       
+
       
      let { unsubscribe } = Wonka.subscribe(x => ignore(Js.Array.push(x, nums)), source);

     

       
1269
       
 
       


     

       
1270
       
 
       
      push^();

     

       
1271
       
 
       
      push^();

     

···

       
1
       
-
       
export { Talkback, Signal, Sink, Source, Operator, Observer, Subject } from './wonka_types';

     

       
0
       
 
       

     

       
2
       
 
       
export * from './pipe';

     

       
3
       
 
       
export * from './wonka';

     

       
4
       
 
       
export * from './web/wonkaJs';

     

···

       
1
       
+
       
export { Talkback, Signal, Sink, Subscription, Source, Operator, Observer, Subject } from './wonka_types';

     

       
2
       
+
       


     

       
3
       
 
       
export * from './pipe';

     

       
4
       
 
       
export * from './wonka';

     

       
5
       
 
       
export * from './web/wonkaJs';

     

···

       
1
       
-
       
import { List, Sink, Source, Operator, Observer, Subject } from './wonka_types';

     

       
2
       
 
       


     

       
3
       
 
       
export const makeSubject: <A>() => Subject<A>;

     

       
4
       
 
       


     
···

       
32
       
 
       
export const takeWhile: <A>(f: (x: A) => boolean) => Operator<A, A>;

     

       
33
       
 
       
export const takeUntil: <A>(signal: Source<any>) => Operator<A, A>;

     

       
34
       
 
       
export const skip: <A>(max: number) => Operator<A, A>;

     

       
35
       
-
       
export const skipWhile: <A>(f: (value: A) => boolean) => Operator<A, A>;

     

       
36
       
 
       
export const skipUntil: <A>(signal: Source<any>) => Operator<A, A>;

     

       
37
       
 
       


     

       
38
       
 
       
export const forEach: <A>(f: (x: A) => void) => (source: Source<A>) => void;

     

       
39
       
-
       
export const subscribe: <A>(f: (x: A) => void) => (source: Source<A>) => (() => void);

     

···

       
1
       
+
       
import { List, Sink, Source, Subscription, Operator, Observer, Subject } from './wonka_types';

     

       
2
       
 
       


     

       
3
       
 
       
export const makeSubject: <A>() => Subject<A>;

     

       
4
       
 
       


     
···

       
32
       
 
       
export const takeWhile: <A>(f: (x: A) => boolean) => Operator<A, A>;

     

       
33
       
 
       
export const takeUntil: <A>(signal: Source<any>) => Operator<A, A>;

     

       
34
       
 
       
export const skip: <A>(max: number) => Operator<A, A>;

     

       
35
       
+
       
export const skipWhile: <A>(f: (x: A) => boolean) => Operator<A, A>;

     

       
36
       
 
       
export const skipUntil: <A>(signal: Source<any>) => Operator<A, A>;

     

       
37
       
 
       


     

       
38
       
 
       
export const forEach: <A>(f: (x: A) => void) => (source: Source<A>) => void;

     

       
39
       
+
       
export const subscribe: <A>(f: (x: A) => void) => (source: Source<A>) => Subscription;

     

···

       
878
       
 
       
    }

     

       
879
       
 
       
  });

     

       
880
       
 
       


     

       
881
       
-
       
  () => if (!ended^) {

     

       
882
       
-
       
    ended := true;

     

       
883
       
-
       
    talkback^(.Close);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
884
       
 
       
  }

     

       
885
       
 
       
});

     

···

       
878
       
 
       
    }

     

       
879
       
 
       
  });

     

       
880
       
 
       


     

       
881
       
+
       
  {

     

       
882
       
+
       
    unsubscribe: () =>

     

       
883
       
+
       
      if (!ended^) {

     

       
884
       
+
       
        ended := true;

     

       
885
       
+
       
        talkback^(.Close);

     

       
886
       
+
       
      }

     

       
887
       
 
       
  }

     

       
888
       
 
       
});

     

···

       
169
       
 
       
/* Similar to the `forEach` sink factory, but returns an anonymous function

     

       
170
       
 
       
   that when called will end the stream immediately.

     

       
171
       
 
       
   Ending the stream will propagate an End signal upwards to the root source. */

     

       
172
       
-
       
let subscribe: ('a => unit, sourceT('a)) => (unit => unit);

     

···

       
169
       
 
       
/* Similar to the `forEach` sink factory, but returns an anonymous function

     

       
170
       
 
       
   that when called will end the stream immediately.

     

       
171
       
 
       
   Ending the stream will propagate an End signal upwards to the root source. */

     

       
172
       
+
       
let subscribe: ('a => unit, sourceT('a)) => subscriptionT;

     

···

       
20
       
 
       
export interface Source<A> { (sink: Sink<A>): void; }

     

       
21
       
 
       
export interface Operator<A, B> { (source: Source<A>): Source<B>; }

     

       
22
       
 
       


     

       
23
       
-
       
export interface Observer<A> {

     

       
24
       
-
       
  [0]: (value: A) => void,

     

       
25
       
-
       
  [1]: () => void

     

       
26
       
-
       
}

     

       
27
       
 
       


     

       
28
       
-
       
export interface Subject<A> {

     

       
29
       
-
       
  [0]: Source<A>,

     

       
30
       
-
       
  [1]: (value: A) => void,

     

       
31
       
-
       
  [2]: () => void

     

       
32
       
-
       
}

     

···

       
20
       
 
       
export interface Source<A> { (sink: Sink<A>): void; }

     

       
21
       
 
       
export interface Operator<A, B> { (source: Source<A>): Source<B>; }

     

       
22
       
 
       


     

       
23
       
+
       
export type Subscription = [() => void];

     

       
24
       
+
       


     

       
25
       
+
       
export type Observer<A> = [(value: A) => void, () => void];

     

       
0
       
 
       

     

       
26
       
 
       


     

       
27
       
+
       
export type Subject<A> = [Source<A>, (value: A) => void, () => void];

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
38
       
 
       
type sinkT('a) = (.signalT('a)) => unit;

     

       
39
       
 
       
type sourceT('a) = sinkT('a) => unit;

     

       
40
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
41
       
 
       
type observerT('a) = {

     

       
42
       
 
       
  next: 'a => unit,

     

       
43
       
 
       
  complete: unit => unit

     

···

       
38
       
 
       
type sinkT('a) = (.signalT('a)) => unit;

     

       
39
       
 
       
type sourceT('a) = sinkT('a) => unit;

     

       
40
       
 
       


     

       
41
       
+
       
type subscriptionT = {

     

       
42
       
+
       
  unsubscribe: unit => unit

     

       
43
       
+
       
};

     

       
44
       
+
       


     

       
45
       
 
       
type observerT('a) = {

     

       
46
       
 
       
  next: 'a => unit,

     

       
47
       
 
       
  complete: unit => unit