commit 07ecb07af61f2f63bd8b3d10949fe89244035f6f · kitten.sh/wonka

+14 -14

src/wonka.re

···

       94
       94
        
       };

     

       95
       95
        
       

     

       96
       96
        
       let merge = (sources, sink) => {

     

       97
       97
       -
         let noop = (_: talkbackT) => ();

     

       97
       97
       +
         let noop = talkbackPlaceholder;

     

       98
       98
        
         let size = Array.length(sources);

     

       99
       99
        
         let talkbacks = Array.map((_) => noop, sources);

     

       100
       100
        
       

     
···

       139
       139
        
       

     

       140
       140
        
       let concat = (sources, sink) => {

     

       141
       141
        
         let size = Array.length(sources);

     

       142
       142
       -
         let talkback = ref((_: talkbackT) => ());

     

       142
       142
       +
         let talkback = ref(talkbackPlaceholder);

     

       143
       143
        
         let rec nextSource = (i: int) =>

     

       144
       144
        
           if (i < size) {

     

       145
       145
        
             let source = Array.unsafe_get(sources, i);

     
···

       174
       174
        
         let state = {

     

       175
       175
        
           sinks: Belt.MutableMap.Int.make(),

     

       176
       176
        
           idCounter: 0,

     

       177
       177
       -
           talkback: (_: talkbackT) => (),

     

       177
       177
       +
           talkback: talkbackPlaceholder,

     

       178
       178
        
           ended: false,

     

       179
       179
        
           gotSignal: false

     

       180
       180
        
         };

     
···

       232
       232
        
       

     

       233
       233
        
       let combine = (sourceA, sourceB, sink) => {

     

       234
       234
        
         let state = {

     

       235
       235
       -
           talkbackA: (_: talkbackT) => (),

     

       236
       236
       -
           talkbackB: (_: talkbackT) => (),

     

       235
       235
       +
           talkbackA: talkbackPlaceholder,

     

       236
       236
       +
           talkbackB: talkbackPlaceholder,

     

       237
       237
        
           lastValA: None,

     

       238
       238
        
           lastValB: None,

     

       239
       239
        
           gotSignal: false,

     
···

       312
       312
        
       let take = (max, source, sink) => {

     

       313
       313
        
         let state: takeStateT = {

     

       314
       314
        
           taken: 0,

     

       315
       315
       -
           talkback: (_: talkbackT) => ()

     

       315
       315
       +
           talkback: talkbackPlaceholder

     

       316
       316
        
         };

     

       317
       317
        
       

     

       318
       318
        
         source(signal => {

     
···

       371
       371
        
       

     

       372
       372
        
       let takeWhile = (predicate, source, sink) => {

     

       373
       373
        
         let ended = ref(false);

     

       374
       374
       -
         let talkback = ref((_: talkbackT) => ());

     

       374
       374
       +
         let talkback = ref(talkbackPlaceholder);

     

       375
       375
        
       

     

       376
       376
        
         source(signal => {

     

       377
       377
        
           switch (signal) {

     
···

       419
       419
        
       let takeUntil = (notifier, source, sink) => {

     

       420
       420
        
         let state: takeUntilStateT = {

     

       421
       421
        
           ended: false,

     

       422
       422
       -
           sourceTalkback: (_: talkbackT) => (),

     

       423
       423
       -
           notifierTalkback: (_: talkbackT) => ()

     

       422
       422
       +
           sourceTalkback: talkbackPlaceholder,

     

       423
       423
       +
           notifierTalkback: talkbackPlaceholder

     

       424
       424
        
         };

     

       425
       425
        
       

     

       426
       426
        
         source(signal => {

     
···

       513
       513
        
           skip: true,

     

       514
       514
        
           ended: false,

     

       515
       515
        
           gotSignal: false,

     

       516
       516
       -
           sourceTalkback: (_: talkbackT) => (),

     

       517
       517
       -
           notifierTalkback: (_: talkbackT) => ()

     

       516
       516
       +
           sourceTalkback: talkbackPlaceholder,

     

       517
       517
       +
           notifierTalkback: talkbackPlaceholder

     

       518
       518
        
         };

     

       519
       519
        
       

     

       520
       520
        
         source(signal => {

     
···

       576
       576
        
       

     

       577
       577
        
       let flatten = (source, sink) => {

     

       578
       578
        
         let state: flattenStateT = {

     

       579
       579
       -
           sourceTalkback: (_: talkbackT) => (),

     

       580
       580
       -
           innerTalkback: (_: talkbackT) => (),

     

       579
       579
       +
           sourceTalkback: talkbackPlaceholder,

     

       580
       580
       +
           innerTalkback: talkbackPlaceholder,

     

       581
       581
        
           sourceEnded: false,

     

       582
       582
        
           innerEnded: true

     

       583
       583
        
         };

     
···

       639
       639
        
         });

     

       640
       640
        
       

     

       641
       641
        
       let subscribe = (f, source) => {

     

       642
       642
       -
         let talkback = ref((_: talkbackT) => ());

     

       642
       642
       +
         let talkback = ref(talkbackPlaceholder);

     

       643
       643
        
         let ended = ref(false);

     

       644
       644
        
       

     

       645
       645
        
         source(signal => {

+3 -1

src/wonka_helpers.re

···

       1
       1
        
       open Wonka_types;

     

       2
       2
        
       

     

       3
       3
       +
       let talkbackPlaceholder = (_: talkbackT) => ();

     

       4
       4
       +
       

     

       3
       5
        
       let captureTalkback = (source: (signalT('a) => unit) => unit, sinkWithTalkback: [@bs] (signalT('a), talkbackT => unit) => unit) => {

     

       4
       4
       -
         let talkback = ref((_: talkbackT) => ());

     

       6
       6
       +
         let talkback = ref(talkbackPlaceholder);

     

       5
       7
        
       

     

       6
       8
        
         source(signal => {

     

       7
       9
        
           switch (signal) {