commit d0ee5131d6db0332a9b2385be10c97999848f824 · kitten.sh/wonka

+5 -14

src/wonka_operators.re

···

       412
       412
        
       let onEnd = (f: (. unit) => unit): operatorT('a, 'a) =>

     

       413
       413
        
         curry(source =>

     

       414
       414
        
           curry(sink => {

     

       415
       415
       -
             let ended = ref(false);

     

       416
       416
       -
       

     

       417
       415
        
             source((. signal) =>

     

       418
       416
        
               switch (signal) {

     

       419
       417
        
               | Start(talkback) =>

     
···

       421
       419
        
                   Start(

     

       422
       420
        
                     (. signal) => {

     

       423
       421
        
                       switch (signal) {

     

       424
       424
       -
                       | Close when ! ended^ =>

     

       425
       425
       -
                         ended := true;

     

       426
       426
       -
                         f(.);

     

       427
       427
       -
                       | Close

     

       428
       428
       -
                       | Pull => ()

     

       422
       422
       +
                       | Close => f(.)

     

       423
       423
       +
                       | _ => ()

     

       429
       424
        
                       };

     

       430
       430
       -
       

     

       431
       425
        
                       talkback(. signal);

     

       432
       426
        
                     },

     

       433
       427
        
                   ),

     

       434
       428
        
                 )

     

       435
       429
        
               | End =>

     

       436
       436
       -
                 if (! ended^) {

     

       437
       437
       -
                   ended := true;

     

       438
       438
       -
                   sink(. signal);

     

       439
       439
       -
                   f(.);

     

       440
       440
       -
                 }

     

       430
       430
       +
                 sink(. signal);

     

       431
       431
       +
                 f(.);

     

       441
       432
        
               | _ => sink(. signal)

     

       442
       433
        
               }

     

       443
       443
       -
             );

     

       434
       434
       +
             )

     

       444
       435
        
           })

     

       445
       436
        
         );

     

       446
       437

-1

src/wonka_operators.test.ts

···

       538
       538
        
         passesSinkClose(noop);

     

       539
       539
        
         passesSourceEnd(noop);

     

       540
       540
        
         passesSingleStart(noop);

     

       541
       541
       -
         // TODO: passesStrictEnd(noop);

     

       542
       541
        
         passesAsyncSequence(noop);

     

       543
       542
        
       

     

       544
       543
        
         it('maps over values given a transform function', () => {

+40 -11

src/wonka_sources.re

···

       46
       46
        
                   ended := true;

     

       47
       47
        
                   sink(. Push(x));

     

       48
       48
        
                   sink(. End);

     

       49
       49
       -
                 | _ => ()

     

       49
       49
       +
                 | Pull => ()

     

       50
       50
       +
                 | Close => ended := true

     

       50
       51
        
                 },

     

       51
       52
        
             ),

     

       52
       53
        
           );

     

       53
       54
        
         });

     

       54
       55
        
       

     

       56
       56
       +
       type makeStateT = {

     

       57
       57
       +
         mutable teardown: (. unit) => unit,

     

       58
       58
       +
         mutable ended: bool,

     

       59
       59
       +
       };

     

       60
       60
       +
       

     

       55
       61
        
       [@genType]

     

       56
       62
        
       let make = (f: (. observerT('a)) => teardownT): sourceT('a) =>

     

       57
       63
        
         curry(sink => {

     

       58
       58
       -
           let teardown = ref((.) => ());

     

       64
       64
       +
           let state: makeStateT = {teardown: (.) => (), ended: false};

     

       59
       65
        
       

     

       60
       66
        
           sink(.

     

       61
       67
        
             Start(

     

       62
       68
        
               (. signal) =>

     

       63
       69
        
                 switch (signal) {

     

       64
       64
       -
                 | Close => teardown^(.)

     

       65
       65
       -
                 | Pull => ()

     

       70
       70
       +
                 | Close when !state.ended =>

     

       71
       71
       +
                   state.ended = true;

     

       72
       72
       +
                   state.teardown(.);

     

       73
       73
       +
                 | _ => ()

     

       66
       74
        
                 },

     

       67
       75
        
             ),

     

       68
       76
        
           );

     

       69
       77
        
       

     

       70
       70
       -
           teardown :=

     

       78
       78
       +
           state.teardown =

     

       71
       79
        
             f(. {

     

       72
       72
       -
               next: value => sink(. Push(value)),

     

       73
       73
       -
               complete: () => sink(. End),

     

       80
       80
       +
               next: value =>

     

       81
       81
       +
                 if (!state.ended) {

     

       82
       82
       +
                   sink(. Push(value));

     

       83
       83
       +
                 },

     

       84
       84
       +
               complete: () =>

     

       85
       85
       +
                 if (!state.ended) {

     

       86
       86
       +
                   state.ended = true;

     

       87
       87
       +
                   sink(. End);

     

       88
       88
       +
                 },

     

       74
       89
        
             });

     

       75
       90
        
         });

     

       76
       91
        
       

     
···

       91
       106
        
           sink(.

     

       92
       107
        
             Start(

     

       93
       108
        
               (. signal) =>

     

       94
       94
       -
                 if (signal === Close) {

     

       95
       95
       -
                   state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);

     

       109
       109
       +
                 switch (signal) {

     

       110
       110
       +
                 | Close =>

     

       111
       111
       +
                   state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink)

     

       112
       112
       +
                 | _ => ()

     

       96
       113
        
                 },

     

       97
       114
        
             ),

     

       98
       115
        
           );

     
···

       114
       131
        
       

     

       115
       132
        
       [@genType]

     

       116
       133
        
       let empty = (sink: sinkT('a)): unit => {

     

       117
       117
       -
         sink(. Start(talkbackPlaceholder));

     

       118
       118
       -
         sink(. End);

     

       134
       134
       +
         let ended = ref(false);

     

       135
       135
       +
         sink(.

     

       136
       136
       +
           Start(

     

       137
       137
       +
             (. signal) => {

     

       138
       138
       +
               switch (signal) {

     

       139
       139
       +
               | Close => ended := true

     

       140
       140
       +
               | _ => ()

     

       141
       141
       +
               }

     

       142
       142
       +
             },

     

       143
       143
       +
           ),

     

       144
       144
       +
         );

     

       145
       145
       +
         if (! ended^) {

     

       146
       146
       +
           sink(. End);

     

       147
       147
       +
         };

     

       119
       148
        
       };

     

       120
       149
        
       

     

       121
       150
        
       [@genType]