commit 00c9ac25a7546eb0db84003e3939e53b5c1f1150 · kitten.sh/wonka

+44 -18

src/wonka_operators.re

···

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

     

       435
       435
        
         curry(source =>

     

       436
       436
        
           curry(sink => {

     

       437
       437
       +
             let ended = ref(false);

     

       437
       438
        
             source((. signal) =>

     

       438
       439
        
               switch (signal) {

     

       439
       440
        
               | Start(talkback) =>

     

       440
       441
        
                 sink(.

     

       441
       442
        
                   Start(

     

       442
       442
       -
                     (. signal) => {

     

       443
       443
       -
                       switch (signal) {

     

       444
       444
       -
                       | Close => f(.)

     

       445
       445
       -
                       | _ => ()

     

       446
       446
       -
                       };

     

       447
       447
       -
                       talkback(. signal);

     

       448
       448
       -
                     },

     

       443
       443
       +
                     (. signal) =>

     

       444
       444
       +
                       if (! ended^) {

     

       445
       445
       +
                         switch (signal) {

     

       446
       446
       +
                         | Pull => talkback(. signal)

     

       447
       447
       +
                         | Close =>

     

       448
       448
       +
                           ended := true;

     

       449
       449
       +
                           talkback(. signal);

     

       450
       450
       +
                           f(.);

     

       451
       451
       +
                         };

     

       452
       452
       +
                       },

     

       449
       453
        
                   ),

     

       450
       454
        
                 )

     

       451
       451
       -
               | End =>

     

       455
       455
       +
               | Push(_) when ! ended^ => sink(. signal)

     

       456
       456
       +
               | Push(_) => ()

     

       457
       457
       +
               | End when ! ended^ =>

     

       458
       458
       +
                 ended := true;

     

       452
       459
        
                 sink(. signal);

     

       453
       460
        
                 f(.);

     

       454
       454
       -
               | _ => sink(. signal)

     

       461
       461
       +
               | End => ()

     

       455
       462
        
               }

     

       456
       456
       -
             )

     

       463
       463
       +
             );

     

       457
       464
        
           })

     

       458
       465
        
         );

     

       459
       466
        
       

     

       460
       467
        
       [@genType]

     

       461
       468
        
       let onPush = (f: (. 'a) => unit): operatorT('a, 'a) =>

     

       462
       469
        
         curry(source =>

     

       463
       463
       -
           curry(sink =>

     

       470
       470
       +
           curry(sink => {

     

       471
       471
       +
             let ended = ref(false);

     

       464
       472
        
             source((. signal) => {

     

       465
       473
        
               switch (signal) {

     

       466
       466
       -
               | Push(x) => f(. x)

     

       467
       467
       -
               | _ => ()

     

       468
       468
       -
               };

     

       469
       469
       -
       

     

       470
       470
       -
               sink(. signal);

     

       471
       471
       -
             })

     

       472
       472
       -
           )

     

       474
       474
       +
               | Start(talkback) =>

     

       475
       475
       +
                 sink(.

     

       476
       476
       +
                   Start(

     

       477
       477
       +
                     (. signal) =>

     

       478
       478
       +
                       if (! ended^) {

     

       479
       479
       +
                         switch (signal) {

     

       480
       480
       +
                         | Pull => talkback(. signal)

     

       481
       481
       +
                         | Close =>

     

       482
       482
       +
                           ended := true;

     

       483
       483
       +
                           talkback(. signal);

     

       484
       484
       +
                         };

     

       485
       485
       +
                       },

     

       486
       486
       +
                   ),

     

       487
       487
       +
                 )

     

       488
       488
       +
               | Push(x) when ! ended^ =>

     

       489
       489
       +
                 f(. x);

     

       490
       490
       +
                 sink(. signal);

     

       491
       491
       +
               | Push(_) => ()

     

       492
       492
       +
               | End when ! ended^ =>

     

       493
       493
       +
                 ended := true;

     

       494
       494
       +
                 sink(. signal);

     

       495
       495
       +
               | End => ()

     

       496
       496
       +
               }

     

       497
       497
       +
             });

     

       498
       498
       +
           })

     

       473
       499
        
         );

     

       474
       500
        
       

     

       475
       501
        
       [@genType]

src/wonka_operators.test.ts

···

       758
       758
        
         passesActivePush(noop);

     

       759
       759
        
         passesSinkClose(noop);

     

       760
       760
        
         passesSourceEnd(noop);

     

       761
       761
       +
         passesStrictEnd(noop);

     

       761
       762
        
         passesSingleStart(noop);

     

       762
       763
        
         passesAsyncSequence(noop);

     

       763
       764
        
       

     
···

       781
       782
        
         passesActivePush(noop);

     

       782
       783
        
         passesSinkClose(noop);

     

       783
       784
        
         passesSourceEnd(noop);

     

       785
       785
       +
         passesStrictEnd(noop);

     

       784
       786
        
         passesSingleStart(noop);

     

       785
       787
        
         passesAsyncSequence(noop);

     

       786
       788