···

       
94
       
 
       
};

     

       
95
       
 
       


     

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

     

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

     

       
98
       
 
       
  let size = Array.length(sources);

     

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

     

       
100
       
 
       


     
···

       
139
       
 
       


     

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

     

       
141
       
 
       
  let size = Array.length(sources);

     

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

     

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

     

       
144
       
 
       
    if (i < size) {

     

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

     
···

       
174
       
 
       
  let state = {

     

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

     

       
176
       
 
       
    idCounter: 0,

     

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

     

       
178
       
 
       
    ended: false,

     

       
179
       
 
       
    gotSignal: false

     

       
180
       
 
       
  };

     
···

       
232
       
 
       


     

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

     

       
234
       
 
       
  let state = {

     

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

     

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

     

       
237
       
 
       
    lastValA: None,

     

       
238
       
 
       
    lastValB: None,

     

       
239
       
 
       
    gotSignal: false,

     
···

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

     

       
313
       
 
       
  let state: takeStateT = {

     

       
314
       
 
       
    taken: 0,

     

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

     

       
316
       
 
       
  };

     

       
317
       
 
       


     

       
318
       
 
       
  source(signal => {

     
···

       
371
       
 
       


     

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

     

       
373
       
 
       
  let ended = ref(false);

     

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

     

       
375
       
 
       


     

       
376
       
 
       
  source(signal => {

     

       
377
       
 
       
    switch (signal) {

     
···

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

     

       
420
       
 
       
  let state: takeUntilStateT = {

     

       
421
       
 
       
    ended: false,

     

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

     

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

     

       
424
       
 
       
  };

     

       
425
       
 
       


     

       
426
       
 
       
  source(signal => {

     
···

       
513
       
 
       
    skip: true,

     

       
514
       
 
       
    ended: false,

     

       
515
       
 
       
    gotSignal: false,

     

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

     

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

     

       
518
       
 
       
  };

     

       
519
       
 
       


     

       
520
       
 
       
  source(signal => {

     
···

       
576
       
 
       


     

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

     

       
578
       
 
       
  let state: flattenStateT = {

     

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

     

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

     

       
581
       
 
       
    sourceEnded: false,

     

       
582
       
 
       
    innerEnded: true

     

       
583
       
 
       
  };

     
···

       
639
       
 
       
  });

     

       
640
       
 
       


     

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

     

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

     

       
643
       
 
       
  let ended = ref(false);

     

       
644
       
 
       


     

       
645
       
 
       
  source(signal => {

     

···

       
94
       
 
       
};

     

       
95
       
 
       


     

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

     

       
97
       
+
       
  let noop = talkbackPlaceholder;

     

       
98
       
 
       
  let size = Array.length(sources);

     

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

     

       
100
       
 
       


     
···

       
139
       
 
       


     

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

     

       
141
       
 
       
  let size = Array.length(sources);

     

       
142
       
+
       
  let talkback = ref(talkbackPlaceholder);

     

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

     

       
144
       
 
       
    if (i < size) {

     

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

     
···

       
174
       
 
       
  let state = {

     

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

     

       
176
       
 
       
    idCounter: 0,

     

       
177
       
+
       
    talkback: talkbackPlaceholder,

     

       
178
       
 
       
    ended: false,

     

       
179
       
 
       
    gotSignal: false

     

       
180
       
 
       
  };

     
···

       
232
       
 
       


     

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

     

       
234
       
 
       
  let state = {

     

       
235
       
+
       
    talkbackA: talkbackPlaceholder,

     

       
236
       
+
       
    talkbackB: talkbackPlaceholder,

     

       
237
       
 
       
    lastValA: None,

     

       
238
       
 
       
    lastValB: None,

     

       
239
       
 
       
    gotSignal: false,

     
···

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

     

       
313
       
 
       
  let state: takeStateT = {

     

       
314
       
 
       
    taken: 0,

     

       
315
       
+
       
    talkback: talkbackPlaceholder

     

       
316
       
 
       
  };

     

       
317
       
 
       


     

       
318
       
 
       
  source(signal => {

     
···

       
371
       
 
       


     

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

     

       
373
       
 
       
  let ended = ref(false);

     

       
374
       
+
       
  let talkback = ref(talkbackPlaceholder);

     

       
375
       
 
       


     

       
376
       
 
       
  source(signal => {

     

       
377
       
 
       
    switch (signal) {

     
···

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

     

       
420
       
 
       
  let state: takeUntilStateT = {

     

       
421
       
 
       
    ended: false,

     

       
422
       
+
       
    sourceTalkback: talkbackPlaceholder,

     

       
423
       
+
       
    notifierTalkback: talkbackPlaceholder

     

       
424
       
 
       
  };

     

       
425
       
 
       


     

       
426
       
 
       
  source(signal => {

     
···

       
513
       
 
       
    skip: true,

     

       
514
       
 
       
    ended: false,

     

       
515
       
 
       
    gotSignal: false,

     

       
516
       
+
       
    sourceTalkback: talkbackPlaceholder,

     

       
517
       
+
       
    notifierTalkback: talkbackPlaceholder

     

       
518
       
 
       
  };

     

       
519
       
 
       


     

       
520
       
 
       
  source(signal => {

     
···

       
576
       
 
       


     

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

     

       
578
       
 
       
  let state: flattenStateT = {

     

       
579
       
+
       
    sourceTalkback: talkbackPlaceholder,

     

       
580
       
+
       
    innerTalkback: talkbackPlaceholder,

     

       
581
       
 
       
    sourceEnded: false,

     

       
582
       
 
       
    innerEnded: true

     

       
583
       
 
       
  };

     
···

       
639
       
 
       
  });

     

       
640
       
 
       


     

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

     

       
642
       
+
       
  let talkback = ref(talkbackPlaceholder);

     

       
643
       
 
       
  let ended = ref(false);

     

       
644
       
 
       


     

       
645
       
 
       
  source(signal => {

     

···

       
1
       
 
       
open Wonka_types;

     

       
2
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
5
       
 
       


     

       
6
       
 
       
  source(signal => {

     

       
7
       
 
       
    switch (signal) {

     

···

       
1
       
 
       
open Wonka_types;

     

       
2
       
 
       


     

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

     

       
4
       
+
       


     

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

     

       
6
       
+
       
  let talkback = ref(talkbackPlaceholder);

     

       
7
       
 
       


     

       
8
       
 
       
  source(signal => {

     

       
9
       
 
       
    switch (signal) {