···
In combination with `interval` this can be used to group values in chunks regularly.
20
-
|> Wonka.buffer(Wonka.interval(100))
22
-
|> Wonka.subscribe((. buffer) => {
23
-
Js.Array.forEach(num => print_int(num), buffer);
26
-
/* Prints 1 2; 2 3 to the console. */
import { pipe, interval, buffer, take, subscribe } from 'wonka';
36
-
subscribe(buffer => {
37
-
buffer.forEach(x => console.log(x));
25
+
subscribe((buffer) => {
26
+
buffer.forEach((x) => console.log(x));
); // Prints 1 2; 2 3 to the console.
···
`combine` two sources together to a single source. The emitted value will be a combination of the two sources, with all values from the first source being emitted with the first value of the second source _before_ values of the second source are emitted.
48
-
let sourceOne = Wonka.fromArray([|1, 2, 3|]);
49
-
let sourceTwo = Wonka.fromArray([|4, 5, 6|]);
51
-
Wonka.combine(sourceOne)
53
-
|> Wonka.subscribe((. (a, b)) => print_int(a + b));
55
-
/* Prints 56789 (1+4, 2+4, 3+4, 3+5, 3+6) to the console. */
import { fromArray, pipe, combine, subscribe } from 'wonka';
···
`concat` will combine two sources together, subscribing to the next source after the previous source completes.
77
-
let sourceOne = Wonka.fromArray([|1, 2, 3|]);
78
-
let sourceTwo = Wonka.fromArray([|6, 5, 4|]);
80
-
Wonka.concat([|sourceOne, sourceTwo|])
81
-
|> Wonka.subscribe((. x) => print_int(x));
82
-
/* Prints 1 2 3 6 5 4 to the console. */
import { fromArray, pipe, concat, subscribe } from 'wonka';
···
concat([sourceOne, sourceTwo]),
93
-
subscribe(val => console.log(val))
62
+
subscribe((val) => console.log(val))
); // Prints 1 2 3 6 5 4 to the console.
···
It's very similar to `concat`, but instead accepts a source of sources as an input.
105
-
let sourceOne = Wonka.fromArray([|1, 2, 3|]);
106
-
let sourceTwo = Wonka.fromArray([|6, 5, 4|]);
108
-
Wonka.fromList([sourceOne, sourceTwo])
110
-
|> Wonka.subscribe((. x) => print_int(x));
111
-
/* Prints 1 2 3 6 5 4 to the console. */
import { pipe, fromArray, concatAll, subscribe } from 'wonka';
···
fromArray([sourceOne, sourceTwo]),
123
-
subscribe(val => console.log(val))
82
+
subscribe((val) => console.log(val))
); // Prints 1 2 3 6 5 4 to the console.
···
`concatMap` allows you to map values of an outer source to an inner source. The sink will not dispatch the `Pull` signal until the previous value has been emitted. This is in contrast to `mergeMap`, which will dispatch the `Pull` signal for new values even if the previous value has not yet been emitted.
132
-
let source = Wonka.fromArray([|1, 2, 3, 4, 5, 6|]);
135
-
|> Wonka.concatMap((. _val) =>
136
-
Wonka.delay(_val * 1000, Wonka.fromValue(_val))
138
-
|> Wonka.subscribe((. _val) => print_int(_val));
140
-
/* After 1s, 1 will be emitted. After an additional 2s, 2 will be emitted.
141
-
After an additional 3s, 3 will be emitted. After an additional 4s, 4 will be emitted.
142
-
After an additional 5s, 5 will be emitted. After an additional 6s, 6 will be emitted. */
import { fromArray, pipe, concatMap, delay, fromValue, subscribe } from 'wonka';
···
97
+
concatMap((val) => {
98
+
return pipe(fromValue(val), delay(val * 1000));
158
-
subscribe(val => console.log(val))
100
+
subscribe((val) => console.log(val))
`delay` delays all emitted values of a source by the given amount of milliseconds.
167
-
> _Note:_ This operator is only available in JavaScript environments, and will be excluded
168
-
> when compiling natively.
171
-
Wonka.fromList([1, 2])
173
-
|> Wonka.subscribe((. x) => print_int(x));
174
-
/* waits 10ms then prints 1, waits 10ms then prints 2, waits 10ms then ends */
import { pipe, fromArray, delay, subscribe } from 'wonka';
···
a given amount of milliseconds. Once this threshold of silence has been reached, the
last value that has been received will be emitted.
194
-
> _Note:_ This operator is only available in JavaScript environments, and will be excluded
195
-
> when compiling natively.
198
-
let sourceA = Wonka.interval(10)
200
-
let sourceB = Wonka.fromValue(1);
202
-
Wonka.concat([|sourceA, sourceB|])
203
-
|> Wonka.debounce((. _x) => 20)
204
-
|> Wonka.subscribe((. x) => print_int(x));
205
-
/* The five values from sourceA will be omitted */
206
-
/* After these values and after 20ms `1` will be logged */
import { pipe, interval, take, fromValue, concat, debounce, subscribe } from 'wonka';
···
`filter` will remove values from a source by passing them through an iteratee that returns a `bool`.
230
-
let isEven = (. n) => n mod 2 === 0;
232
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
233
-
|> Wonka.filter(isEven)
234
-
|> Wonka.subscribe((. x) => print_int(x));
235
-
/* Prints 246 to the console. */
import { fromArray, filter, subscribe } from 'wonka';
241
-
const isEven = n => n % 2 === 0;
148
+
const isEven = (n) => n % 2 === 0;
fromArray([1, 2, 3, 4, 5, 6]),
246
-
subscribe(val => console.log(val))
153
+
subscribe((val) => console.log(val))
// Prints 246 to the console.
···
`map` will transform values from a source by passing them through an iteratee that returns a new value.
257
-
let square = (. n) => n * n;
259
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
260
-
|> Wonka.map(square)
261
-
|> Wonka.subscribe((. x) => print_int(x));
262
-
/* Prints 1 4 9 16 25 36 to the console. */
import { fromArray, pipe, map, subscribe } from 'wonka';
268
-
const square = n => n * n;
166
+
const square = (n) => n * n;
fromArray([1, 2, 3, 4, 5, 6]),
273
-
subscribe(val => console.log(val))
171
+
subscribe((val) => console.log(val))
// Prints 1 4 9 16 25 36 to the console.
···
`merge` merges an array of sources together into a single source. It subscribes
to all sources that it's passed and emits all their values on the output source.
285
-
let sourceA = Wonka.fromArray([|1, 2, 3|]);
286
-
let sourceB = Wonka.fromArray([|4, 5, 6|]);
288
-
Wonka.merge([|sourceA, sourceB|])
289
-
|> Wonka.subscribe((. x) => print_int(x));
290
-
/* Prints 1 2 3 4 5 6 to the console. */
import { fromArray, pipe, merge, subscribe } from 'wonka';
···
> _Note:_ This operator is also exported as `flatten` which is just an alias for `mergeAll`
313
-
let sourceA = Wonka.fromArray([|1, 2, 3|]);
314
-
let sourceB = Wonka.fromArray([|4, 5, 6|]);
316
-
Wonka.fromList([sourceA, sourceB])
318
-
|> Wonka.subscribe((. x) => print_int(x));
319
-
/* Prints 1 2 3 4 5 6 to the console. */
import { pipe, fromArray, mergeAll, subscribe } from 'wonka';
···
fromArray([sourceOne, sourceTwo]),
331
-
subscribe(val => console.log(val))
210
+
subscribe((val) => console.log(val))
); // Prints 1 2 3 4 5 6 to the console.
···
Unlike `concatMap` all inner sources will be subscribed to at the same time
and all their values will be emitted on the output source as they come in.
345
-
Wonka.fromList([1, 2])
346
-
|> Wonka.mergeMap((. value) =>
347
-
Wonka.fromList([value - 1, value]))
348
-
|> Wonka.subscribe((. x) => print_int(x));
349
-
/* Prints 0 1 1 2 to the console. */
import { pipe, fromArray, mergeMap, subscribe } from 'wonka';
357
-
mergeMap(x => fromArray([x - 1, x])),
358
-
subscribe(val => console.log(val))
228
+
mergeMap((x) => fromArray([x - 1, x])),
229
+
subscribe((val) => console.log(val))
); // Prints 0 1 1 2 to the console.
···
Run a callback when the `End` signal has been sent to the sink by the source, whether by way of the talkback passing the `End` signal or the source being exhausted of values.
368
-
Js.Promise.make((~resolve, ~reject as _) =>
369
-
Js.Global.setTimeout(() => resolve(. "ResolveOne"), 1000) |> ignore
373
-
Js.Promise.make((~resolve, ~reject as _) =>
374
-
Js.Global.setTimeout(() => resolve(. "ResolveTwo"), 2000) |> ignore
377
-
let sourceOne = Wonka.fromPromise(promiseOne);
378
-
let sourceTwo = Wonka.fromPromise(promiseTwo);
380
-
Wonka.concat([|sourceOne, sourceTwo|])
381
-
|> Wonka.onEnd((.) => print_endline("onEnd"))
382
-
|> Wonka.subscribe((. x) => print_endline(x));
384
-
/* Logs ResolveOne after one second, then ResolveTwo after an additional second, then onEnd immediately. */
import { fromPromise, pipe, concat, onEnd, subscribe } from 'wonka';
390
-
const promiseOne = new Promise(resolve => {
240
+
const promiseOne = new Promise((resolve) => {
395
-
const promiseTwo = new Promise(resolve => {
245
+
const promiseTwo = new Promise((resolve) => {
···
concat([sourceOne, sourceTwo]),
onEnd(() => console.log('onEnd')),
407
-
subscribe(val => console.log(val))
257
+
subscribe((val) => console.log(val))
// Logs ResolveOne after one second, then ResolveTwo after an additional second, then onEnd immediately.
···
> _Note:_ This operator is also exported as `tap` which is just an alias for `onPush`
420
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
421
-
|> Wonka.onPush((. x) => print_string({j|Push $x|j}))
422
-
|> Wonka.subscribe((. x) => print_int(x));
423
-
/* Prints Push 1 1 Push 2 2 Push 3 3 Push 4 4 Push 5 5 Push 6 6 to the console. */
import { fromArray, pipe, onPush, subscribe } from 'wonka';
fromArray([1, 2, 3, 4, 5, 6]),
431
-
onPush(val => console.log(`Push ${val}`)),
432
-
subscribe(val => console.log(val))
274
+
onPush((val) => console.log(`Push ${val}`)),
275
+
subscribe((val) => console.log(val))
); // Prints Push 1 1 Push 2 2 Push 3 3 Push 4 4 Push 5 5 Push 6 6 to the console.
···
Run a callback when the `Start` signal is sent to the sink by the source.
442
-
Js.Promise.make((~resolve, ~reject as _) =>
443
-
Js.Global.setTimeout(() => resolve(. "Resolve"), 1000) |> ignore
446
-
Wonka.fromPromise(promise)
447
-
|> Wonka.onStart((.) => print_endline("onStart"))
448
-
|> Wonka.subscribe((. _val) => print_endline(_val));
449
-
/* Logs onStart to the console, pauses for one second to allow the timeout to finish,
450
-
then logs "Resolve" to the console. */
import { pipe, onStart, fromPromise, subscribe } from 'wonka';
456
-
const promise = new Promise(resolve => {
286
+
const promise = new Promise((resolve) => {
···
onStart(() => console.log('onStart')),
465
-
subscribe(val => console.log(val))
295
+
subscribe((val) => console.log(val))
// Logs onStart to the console, pauses for one second to allow the timeout to finish,
···
In combination with `interval` it can be used to get values from a noisy source
482
-
|> Wonka.sample(Wonka.interval(100))
484
-
|> Wonka.subscribe((. x) => print_int(x));
485
-
/* Prints 10 20 to the console. */
import { pipe, interval, sample, take, subscribe } from 'wonka';
495
-
subscribe(x => console.log(x))
317
+
subscribe((x) => console.log(x))
); // Prints 10 20 to the console.
···
Accumulate emitted values of a source in a accumulator, similar to JavaScript `reduce`.
504
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
505
-
|> Wonka.scan((. acc, x) => acc + x, 0)
506
-
|> Wonka.subscribe((. x) => print_int(x));
507
-
/* Prints 1 3 6 10 15 21 to the console. */
import { fromArray, pipe, scan, subscribe } from 'wonka';
fromArray([1, 2, 3, 4, 5, 6]),
scan((acc, val) => acc + val, 0),
516
-
subscribe(val => console.log(val))
331
+
subscribe((val) => console.log(val))
// Prints 1 3 6 10 15 21 to the console.
···
This is especially useful if you introduce side-effects to your sources,
for instance with `onStart`.
540
-
let source = Wonka.never
541
-
|> Wonka.onStart((.) => print_endline("start"))
544
-
/* Without share this would print "start" twice: */
545
-
Wonka.publish(source);
546
-
Wonka.publish(source);
import { pipe, never, onStart, share, publish } from 'wonka';
···
`skip` the specified number of emissions from the source.
568
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
570
-
|> Wonka.subscribe((. x) => print_int(x));
571
-
/* Prints 3 4 5 6 to the console, since the first two emissions from the source were skipped.
import { fromArray, pipe, skip, subscribe } from 'wonka';
···
fromArray([1, 2, 3, 4, 5, 6]),
580
-
subscribe(val => console.log(val))
378
+
subscribe((val) => console.log(val))
···
Skip emissions from an outer source until an inner source (notifier) emits.
589
-
let source = Wonka.interval(100);
590
-
let notifier = Wonka.interval(500);
593
-
|> Wonka.skipUntil(notifier)
594
-
|> Wonka.subscribe((. x) => print_int(x));
596
-
/* Skips all values emitted by source (0, 1, 2, 3) until notifier emits at 500ms.
597
-
Then logs 4 5 6 7 8 9 10... to the console every 500ms. */
import { interval, pipe, skipUntil, subscribe } from 'wonka';
···
609
-
subscribe(val => console.log(val))
395
+
subscribe((val) => console.log(val))
// Skips all values emitted by source (0, 1, 2, 3) until notifier emits at 500ms.
···
Skip values emitted from the source while they return `true` for the provided predicate function.
621
-
let source = Wonka.fromArray([|1, 2, 3, 4, 5, 6|]);
624
-
|> Wonka.skipWhile((. _val) => _val < 5)
625
-
|> Wonka.subscribe((. _val) => print_int(_val));
627
-
/* Prints 5 6 to the console, as 1 2 3 4 all return true for the predicate function. */
import { fromArray, pipe, skipWhile, subscribe } from 'wonka';
fromArray([1, 2, 3, 4, 5, 6]),
635
-
skipWhile(val => val < 5),
636
-
subscribe(val => console.log(val))
411
+
skipWhile((val) => val < 5),
412
+
subscribe((val) => console.log(val))
// Prints 5 6 to the console, as 1 2 3 4 all return true for the predicate function.
···
This is similar to `concatMap` but instead of waiting for the last inner source to complete
before emitting values from the next, `switchMap` just cancels the previous inner source.
655
-
|> Wonka.switchMap((. _value) =>
656
-
Wonka.interval(40))
658
-
|> Wonka.subscribe((. x) => print_int(x));
659
-
/* Prints 1 2 3 to the console. */
660
-
/* The inner interval is cancelled after its first value every time */
import { pipe, interval, switchMap, take, subscribe } from 'wonka';
// The inner interval is cancelled after its first value every time
669
-
switchMap(value => interval(40)),
435
+
switchMap((value) => interval(40)),
671
-
subscribe(x => console.log(x))
437
+
subscribe((x) => console.log(x))
); // Prints 1 2 3 to the console
···
It's very similar to `switchMap`, but instead accepts a source of sources.
685
-
|> Wonka.map((. _value) =>
686
-
Wonka.interval(40))
689
-
|> Wonka.subscribe((. x) => print_int(x));
690
-
/* Prints 1 2 3 to the console. */
import { pipe, interval, map, switchAll, take, subscribe } from 'wonka';
···
701
-
subscribe(x => console.log(x))
457
+
subscribe((x) => console.log(x))
); // Prints 1 2 3 to the console
···
`take` only a specified number of emissions from the source before completing. `take` is the opposite of `skip`.
714
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|])
716
-
|> Wonka.subscribe((. x) => print_int(x));
717
-
/* Prints 1 2 3 to the console. */
import { fromArray, pipe, take, subscribe } from 'wonka';
fromArray([1, 2, 3, 4, 5, 6]),
726
-
subscribe(val => console.log(val))
475
+
subscribe((val) => console.log(val))
// Prints 1 2 3 to the console.
···
`takeLast` will take only the last n emissions from the source.
737
-
Wonka.fromArray([|1, 2, 3, 4, 5, 6|]);
738
-
|> Wonka.takeLast(3)
739
-
|> Wonka.subscribe((. x) => print_int(x));
740
-
/* Prints 4 5 6 to the console. */
import { fromArray, pipe, takeLast, subscribe } from 'wonka';
fromArray([1, 2, 3, 4, 5, 6]),
749
-
subscribe(val => console.log(val))
491
+
subscribe((val) => console.log(val))
// Prints 4 5 6 to the console.
···
Take emissions from an outer source until an inner source (notifier) emits.
760
-
let source = Wonka.interval(100);
761
-
let notifier = Wonka.interval(500);
764
-
|> Wonka.takeUntil(notifier)
765
-
|> Wonka.subscribe((. x) => print_int(x));
767
-
/* Pauses 100ms, prints 0, pauses 100ms, prints 1, pauses 100ms, prints 2, pauses 100ms,
768
-
prints 3, pauses 100, then completes (notifier emits). */
import { interval, pipe, takeUntil, subscribe } from 'wonka';
···
780
-
subscribe(val => console.log(val))
510
+
subscribe((val) => console.log(val))
// Pauses 100ms, prints 0, pauses 100ms, prints 1, pauses 100ms, prints 2, pauses 100ms,
···
Take emissions from the stream while they return `true` for the provided predicate function. If the first emission does not return `true`, no values will be `Push`ed to the sink.
792
-
let source = Wonka.fromArray([|1, 2, 3, 4, 5, 6|]);
795
-
|> Wonka.takeWhile((. x) => x < 5)
796
-
|> Wonka.subscribe((. x) => print_int(x));
798
-
/* Prints 1 2 3 4 to the console. */
import { pipe, fromArray, takeWhile, subscribe } from 'wonka';
···
808
-
takeWhile(val => val < 5),
809
-
subscribe(val => console.log(val))
528
+
takeWhile((val) => val < 5),
529
+
subscribe((val) => console.log(val))
// Prints 1 2 3 4 to the console.
···
This is very similar to `debounce` but instead of waiting for leading time before a
value it waits for trailing time after a value.
824
-
> _Note:_ This operator is only available in JavaScript environments, and will be excluded
825
-
> when compiling natively.
829
-
|> Wonka.throttle((. _x) => 50)
831
-
|> Wonka.subscribe((. x) => print_int(x));
832
-
/* Outputs 0 6 to the console. */
import { pipe, interval, throttle, take, subscribe } from 'wonka';
kitten.sh