commit 6a9c5c8ab41378188b3513d0d3340c8c60fdfdca · kitten.sh/wonka

+1 -1

__tests__/wonka_test.re

···

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

     

       1266
       1266
        
             };

     

       1267
       1267
        
       

     

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

     

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

     

       1269
       1269
        
       

     

       1270
       1270
        
             push^();

     

       1271
       1271
        
             push^();

+2 -1

src/index.d.ts

···

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

     

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

     

       2
       2
       +
       

     

       2
       3
        
       export * from './pipe';

     

       3
       4
        
       export * from './wonka';

     

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

+3 -3

src/wonka.d.ts

···

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

     

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

     

       2
       2
        
       

     

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

     

       4
       4
        
       

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       37
       37
        
       

     

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

     

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

     

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

+6 -3

src/wonka.re

···

       878
       878
        
           }

     

       879
       879
        
         });

     

       880
       880
        
       

     

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

     

       882
       882
       -
           ended := true;

     

       883
       883
       -
           talkback^(.Close);

     

       881
       881
       +
         {

     

       882
       882
       +
           unsubscribe: () =>

     

       883
       883
       +
             if (!ended^) {

     

       884
       884
       +
               ended := true;

     

       885
       885
       +
               talkback^(.Close);

     

       886
       886
       +
             }

     

       884
       887
        
         }

     

       885
       888
        
       });

+1 -1

src/wonka.rei

···

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

     

       170
       170
        
          that when called will end the stream immediately.

     

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

     

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

     

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

+4 -9

src/wonka_types.d.ts

···

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

     

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

     

       22
       22
        
       

     

       23
       23
       -
       export interface Observer<A> {

     

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

     

       25
       25
       -
         [1]: () => void

     

       26
       26
       -
       }

     

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

     

       24
       24
       +
       

     

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

     

       27
       26
        
       

     

       28
       28
       -
       export interface Subject<A> {

     

       29
       29
       -
         [0]: Source<A>,

     

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

     

       31
       31
       -
         [2]: () => void

     

       32
       32
       -
       }

     

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

+4

src/wonka_types.re

···

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

     

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

     

       40
       40
        
       

     

       41
       41
       +
       type subscriptionT = {

     

       42
       42
       +
         unsubscribe: unit => unit

     

       43
       43
       +
       };

     

       44
       44
       +
       

     

       41
       45
        
       type observerT('a) = {

     

       42
       46
        
         next: 'a => unit,

     

       43
       47
        
         complete: unit => unit