commit 00c9ac25a7546eb0db84003e3939e53b5c1f1150 · kitten.sh/wonka

+44 -18

src/wonka_operators.re

···

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

     

       435
        
         curry(source =>

     

       436
        
           curry(sink => {

     

       0
        
       
     

       437
        
             source((. signal) =>

     

       438
        
               switch (signal) {

     

       439
        
               | Start(talkback) =>

     

       440
        
                 sink(.

     

       441
        
                   Start(

     

       442
       -
                     (. signal) => {

     

       443
       -
                       switch (signal) {

     

       444
       -
                       | Close => f(.)

     

       445
       -
                       | _ => ()

     

       446
       -
                       };

     

       447
       -
                       talkback(. signal);

     

       448
       -
                     },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       449
        
                   ),

     

       450
        
                 )

     

       451
       -
               | End =>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       452
        
                 sink(. signal);

     

       453
        
                 f(.);

     

       454
       -
               | _ => sink(. signal)

     

       455
        
               }

     

       456
       -
             )

     

       457
        
           })

     

       458
        
         );

     

       459
        
       

     

       460
        
       [@genType]

     

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

     

       462
        
         curry(source =>

     

       463
       -
           curry(sink =>

     

       0
        
       
     

       464
        
             source((. signal) => {

     

       465
        
               switch (signal) {

     

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

     

       467
       -
               | _ => ()

     

       468
       -
               };

     

       469
       -
       

     

       470
       -
               sink(. signal);

     

       471
       -
             })

     

       472
       -
           )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       473
        
         );

     

       474
        
       

     

       475
        
       [@genType]

···

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

     

       435
        
         curry(source =>

     

       436
        
           curry(sink => {

     

       437
       +
             let ended = ref(false);

     

       438
        
             source((. signal) =>

     

       439
        
               switch (signal) {

     

       440
        
               | Start(talkback) =>

     

       441
        
                 sink(.

     

       442
        
                   Start(

     

       443
       +
                     (. signal) =>

     

       444
       +
                       if (! ended^) {

     

       445
       +
                         switch (signal) {

     

       446
       +
                         | Pull => talkback(. signal)

     

       447
       +
                         | Close =>

     

       448
       +
                           ended := true;

     

       449
       +
                           talkback(. signal);

     

       450
       +
                           f(.);

     

       451
       +
                         };

     

       452
       +
                       },

     

       453
        
                   ),

     

       454
        
                 )

     

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

     

       456
       +
               | Push(_) => ()

     

       457
       +
               | End when ! ended^ =>

     

       458
       +
                 ended := true;

     

       459
        
                 sink(. signal);

     

       460
        
                 f(.);

     

       461
       +
               | End => ()

     

       462
        
               }

     

       463
       +
             );

     

       464
        
           })

     

       465
        
         );

     

       466
        
       

     

       467
        
       [@genType]

     

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

     

       469
        
         curry(source =>

     

       470
       +
           curry(sink => {

     

       471
       +
             let ended = ref(false);

     

       472
        
             source((. signal) => {

     

       473
        
               switch (signal) {

     

       474
       +
               | Start(talkback) =>

     

       475
       +
                 sink(.

     

       476
       +
                   Start(

     

       477
       +
                     (. signal) =>

     

       478
       +
                       if (! ended^) {

     

       479
       +
                         switch (signal) {

     

       480
       +
                         | Pull => talkback(. signal)

     

       481
       +
                         | Close =>

     

       482
       +
                           ended := true;

     

       483
       +
                           talkback(. signal);

     

       484
       +
                         };

     

       485
       +
                       },

     

       486
       +
                   ),

     

       487
       +
                 )

     

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

     

       489
       +
                 f(. x);

     

       490
       +
                 sink(. signal);

     

       491
       +
               | Push(_) => ()

     

       492
       +
               | End when ! ended^ =>

     

       493
       +
                 ended := true;

     

       494
       +
                 sink(. signal);

     

       495
       +
               | End => ()

     

       496
       +
               }

     

       497
       +
             });

     

       498
       +
           })

     

       499
        
         );

     

       500
        
       

     

       501
        
       [@genType]

src/wonka_operators.test.ts

···

       758
        
         passesActivePush(noop);

     

       759
        
         passesSinkClose(noop);

     

       760
        
         passesSourceEnd(noop);

     

       0
        
       
     

       761
        
         passesSingleStart(noop);

     

       762
        
         passesAsyncSequence(noop);

     

       763
        
       

     
···

       781
        
         passesActivePush(noop);

     

       782
        
         passesSinkClose(noop);

     

       783
        
         passesSourceEnd(noop);

     

       0
        
       
     

       784
        
         passesSingleStart(noop);

     

       785
        
         passesAsyncSequence(noop);

     

       786

···

       758
        
         passesActivePush(noop);

     

       759
        
         passesSinkClose(noop);

     

       760
        
         passesSourceEnd(noop);

     

       761
       +
         passesStrictEnd(noop);

     

       762
        
         passesSingleStart(noop);

     

       763
        
         passesAsyncSequence(noop);

     

       764
        
       

     
···

       782
        
         passesActivePush(noop);

     

       783
        
         passesSinkClose(noop);

     

       784
        
         passesSourceEnd(noop);

     

       785
       +
         passesStrictEnd(noop);

     

       786
        
         passesSingleStart(noop);

     

       787
        
         passesAsyncSequence(noop);

     

       788