commit ee639330b0cfd1ed44851fe561bb5f646544af90 · kitten.sh/wonka

+22 -20

src/wonka_operators.re

···

       340
        
       

     

       341
        
               innerSource((. signal) =>

     

       342
        
                 switch (signal) {

     

       343
       -
                 | End =>

     

       344
       -
                   state.innerTalkbacks =

     

       345
       -
                     Rebel.Array.filter(state.innerTalkbacks, x => x !== talkback^);

     

       346
       -
                   if (state.ended && Rebel.Array.size(state.innerTalkbacks) === 0) {

     

       347
       -
                     sink(. End);

     

       348
       -
                   };

     

       349
        
                 | Start(tb) =>

     

       350
        
                   talkback := tb;

     

       351
        
                   state.innerTalkbacks =

     
···

       355
        
                   sink(. Push(x));

     

       356
        
                   talkback^(. Pull);

     

       357
        
                 | Push(_) => ()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       358
        
                 }

     

       359
        
               );

     

       360
        
             };

     
···

       378
        
             sink(.

     

       379
        
               Start(

     

       380
        
                 (. signal) =>

     

       381
       -
                   switch (signal) {

     

       382
       -
                   | Close when !state.ended =>

     

       383
       -
                     let tbs = state.innerTalkbacks;

     

       384
       -
                     state.innerTalkbacks = Rebel.Array.makeEmpty();

     

       385
       -
                     state.outerTalkback(. signal);

     

       386
       -
                     Rebel.Array.forEach(tbs, tb => tb(. signal));

     

       387
       -
                   | Close => ()

     

       388
       -
                   | Pull when !state.ended =>

     

       389
       -
                     if (!state.outerPulled) {

     

       390
       -
                       state.outerPulled = true;

     

       391
       -
                       state.outerTalkback(. Pull);

     

       392
       -
                     };

     

       0
        
       
     

       393
        
       

     

       394
       -
                     Rebel.Array.forEach(state.innerTalkbacks, tb => tb(. Pull));

     

       395
       -
                   | Pull => ()

     

       396
        
                   },

     

       397
        
               ),

     

       398
        
             );

···

       340
        
       

     

       341
        
               innerSource((. signal) =>

     

       342
        
                 switch (signal) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       343
        
                 | Start(tb) =>

     

       344
        
                   talkback := tb;

     

       345
        
                   state.innerTalkbacks =

     
···

       349
        
                   sink(. Push(x));

     

       350
        
                   talkback^(. Pull);

     

       351
        
                 | Push(_) => ()

     

       352
       +
                 | End when Rebel.Array.size(state.innerTalkbacks) !== 0 =>

     

       353
       +
                   state.innerTalkbacks =

     

       354
       +
                     Rebel.Array.filter(state.innerTalkbacks, x => x !== talkback^);

     

       355
       +
                   if (state.ended && Rebel.Array.size(state.innerTalkbacks) === 0) {

     

       356
       +
                     sink(. End);

     

       357
       +
                   };

     

       358
       +
                 | End => ()

     

       359
        
                 }

     

       360
        
               );

     

       361
        
             };

     
···

       379
        
             sink(.

     

       380
        
               Start(

     

       381
        
                 (. signal) =>

     

       382
       +
                   if (!state.ended) {

     

       383
       +
                     switch (signal) {

     

       384
       +
                     | Close =>

     

       385
       +
                       let tbs = state.innerTalkbacks;

     

       386
       +
                       state.ended = true;

     

       387
       +
                       state.innerTalkbacks = Rebel.Array.makeEmpty();

     

       388
       +
                       state.outerTalkback(. signal);

     

       389
       +
                       Rebel.Array.forEach(tbs, tb => tb(. signal));

     

       390
       +
                     | Pull =>

     

       391
       +
                       if (!state.outerPulled) {

     

       392
       +
                         state.outerPulled = true;

     

       393
       +
                         state.outerTalkback(. Pull);

     

       394
       +
                       };

     

       395
        
       

     

       396
       +
                       Rebel.Array.forEach(state.innerTalkbacks, tb => tb(. Pull));

     

       397
       +
                     };

     

       398
        
                   },

     

       399
        
               ),

     

       400
        
             );

+28 -2

src/wonka_operators.test.ts

···

       201
        
         This isn't a strict requirement, but some operators should ensure that

     

       202
        
         all sources are well behaved. This is particularly true for operators

     

       203
        
         that either Close sources themselves or may operate on multiple sources. */

     

       204
       -
       const passesStrictEnd = (operator: types.operatorT<any, any>) =>

     

       205
        
         it('stops all signals after End has been received (spec: strict end)', () => {

     

       206
        
           let pulls = 0;

     

       207
        
           const signals = [];

     
···

       231
        
           expect(signals).toEqual([deriving.end()]);

     

       232
        
           expect(pulls).toBe(1);

     

       233
        
         });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       234
        
       

     

       235
        
       /* This tests an immediately closing operator for End signals to

     

       236
        
         the sink and Close signals to the source.

     
···

       968
        
         passesSinkClose(noop);

     

       969
        
         passesSourceEnd(noop);

     

       970
        
         passesSingleStart(noop);

     

       971
       -
         passesStrictEnd(noop);

     

       972
        
         passesAsyncSequence(noop);

     

       973
        
       

     

       974
        
         const ending = operators.takeWhile(() => false);

···

       201
        
         This isn't a strict requirement, but some operators should ensure that

     

       202
        
         all sources are well behaved. This is particularly true for operators

     

       203
        
         that either Close sources themselves or may operate on multiple sources. */

     

       204
       +
       const passesStrictEnd = (operator: types.operatorT<any, any>) => {

     

       205
        
         it('stops all signals after End has been received (spec: strict end)', () => {

     

       206
        
           let pulls = 0;

     

       207
        
           const signals = [];

     
···

       231
        
           expect(signals).toEqual([deriving.end()]);

     

       232
        
           expect(pulls).toBe(1);

     

       233
        
         });

     

       234
       +
       

     

       235
       +
         it('stops all signals after Close has been received (spec: strict close)', () => {

     

       236
       +
           const signals = [];

     

       237
       +
       

     

       238
       +
           const source: types.sourceT<any> = sink => {

     

       239
       +
             sink(deriving.start(tb => {

     

       240
       +
               if (tb === deriving.close) {

     

       241
       +
                 sink(deriving.push(123));

     

       242
       +
               }

     

       243
       +
             }));

     

       244
       +
           };

     

       245
       +
       

     

       246
       +
           const sink: types.sinkT<any> = signal => {

     

       247
       +
             if (deriving.isStart(signal)) {

     

       248
       +
               deriving.unboxStart(signal)(deriving.close);

     

       249
       +
             } else {

     

       250
       +
               signals.push(signal);

     

       251
       +
             }

     

       252
       +
           };

     

       253
       +
       

     

       254
       +
           operator(source)(sink);

     

       255
       +
       

     

       256
       +
           // The Push signal should've been dropped

     

       257
       +
           jest.runAllTimers();

     

       258
       +
           expect(signals).toEqual([]);

     

       259
       +
         });

     

       260
       +
       };

     

       261
        
       

     

       262
        
       /* This tests an immediately closing operator for End signals to

     

       263
        
         the sink and Close signals to the source.

     
···

       995
        
         passesSinkClose(noop);

     

       996
        
         passesSourceEnd(noop);

     

       997
        
         passesSingleStart(noop);

     

       0
        
       
     

       998
        
         passesAsyncSequence(noop);

     

       999
        
       

     

       1000
        
         const ending = operators.takeWhile(() => false);