Bacon.js, delay each value in the stream by 1 second

Question

I have this:

var bulk = array[1,2,3,4]
var finalResult = Bacon
    .fromArray(bulk)
    .flatMap(isValInCouchDb)
    .filter(onesThatExist)
    .flatMap(putValInCouchDb)

I need right after the filter to delay the whole stream by 1 second and then run putValInCouchDb Something like this really:

var bulk = array[1,2,3,4]
var finalResult = Bacon
    .fromArray(bulk)
    .flatMap(isValInCouchDb)
    .filter(onesThatExist)
    .delay(1000)
    .flatMap(putValInCouchDb)

But I think I'm missing something because .delay(1000) is delaying everything for as many seconds as there are items and then runs them all once all the time has lapsed.

Any ideas ?

UPDATE

Just to clarify based on the answer from Alex

What I would need is:

1 "filter" 1
2 "filter" 2
3 "filter" 3
4 "filter" 4
[waits 1 second]
1004 "flatMap" 1
[waits 1 second]
2004 "flatMap" 2
[waits 1 second]
3005 "flatMap" 3
[waits 1 second]
4006 "flatMap" 4

UPDATE 2 - With Solution Used

From the answer from Bergi, using .zip with an interval actually worked but what happens with .zip is that .interval creates an event every second and then each event from .interval waits for each event from my database checks. A lot of database checks happen in bulk and very fast so 'excessive buffering' occurs (which is what the bacon docs warn you).

So I decided to do it this way instead:

var bulk = array[1,2,3,4]
var finalResult = Bacon
    .fromArray(bulk)
    .flatMap(isValInCouchDb)
    .filter(onesThatExist)
    .fold([], function(a, b){ a.push(b); return a })
    .flatMap(function(a){return Bacon.sequentially(1500, a)})
    .flatMap(putValInCouchDb)

This worked nicely since folding the filtered results and sequentially creating events from them is natural, very descriptive, and without side effects.

Bacon is quite awesome

score 2 · Accepted Answer · answered Apr 12 '14 at 18:37

.delay(1000) is delaying everything for as many seconds as there are items and then runs them all once all the time has lapsed.

Yes, that's just what delay is supposed to do: take each event and fire it after a given delay.

There is no extra function that does delay and buffer at the same time, both throttle and debounce will swallow events that occured too fast.

What you can do is:

Use Bacon.sequentially to which you can pass the 1s-interval instead of the plain Bacon.fromArray to construct your stream
Use zip to join your existing event stream into events that occur at the expected time:
```
Bacon.fromArray(bulk)….zip(Bacon.interval(1000), _.id)
```

I'm not sure though how your .flatMap(isValInCouchDb) manipulates the stream.

Was using sequentially initially but I started refactoring it because the checks if the item exists in the DB can happen right away, but the inserts in the DB have to wait for a second between each other. Zip on the other hand is looking interesting. Will try that — haknick, Apr 12 '14 at 19:01
Problem could be that if the checks happen too slow, then a bunch of events from `interval` might have accumulated and would then execute in quick succession. — Bergi, Apr 12 '14 at 21:00

score 1 · Answer 2 · answered Apr 12 '14 at 13:45

Unless you are doing something fancy in putValInCouchDb, your code appears to work exactly as you wish it would. E.g, running

var t = new Date().getTime();
function timestamp(label, x) { console.log(new Date().getTime() - t, label, x); }
var s = Bacon.fromArray([1,2,3,4])
             .filter(function(x) { timestamp("filter", x); return true })
             .delay(1000)
             .flatMap(function(x) { timestamp("flatMap", x); return Bacon.constant(x) })
s.onValue(function(x) {})

outputs something like

1 "filter" 1
2 "filter" 2
3 "filter" 3
4 "filter" 4
[waits 1 second]
1004 "flatMap" 1
1004 "flatMap" 2
1005 "flatMap" 3
1006 "flatMap" 4

I see the confusion. So what I want is something like this: 1 "filter" 1 2 "filter" 2 3 "filter" 3 4 "filter" 4 [waits 1 second] 1004 "flatMap" 1 [waits 1 second] 2004 "flatMap" 2 [waits 1 second] 3005 "flatMap" 3 [waits 1 second] 4006 "flatMap" 4 — haknick, Apr 12 '14 at 14:30

Bacon.js, delay each value in the stream by 1 second

2 Answers2