Bluebird: Waiting for one promise to settle

Question

At the risk of sounding stupid: What's the most efficient way to wait for one promise to settle? Say I have promise A and I want to create promise B. The fulfillment of B does not depend on the final value of A. It should proceed even if A is rejected. The process shouldn't start, however, until A is settled one way or the other.

What I have currently looks like the following:

var prevResult;

function doStuff() {
    if (prevResult) {
        prevResult = promise.settle([ prevResult ]).then(function() {
            return doStuff();
        })
    } else {
        prevResult = updateDB().finally(function() {
            prevResult = null;
        });
    }
    return prevResult;
}

The code is a bit non-obvious. I'm also a bit worried about chaining a bunch of promises from settle() together, seeing how it's function for performing less trivial kind of coordination. Seems like there ought to be a simpler way of doing this.

You mean you want to have two promises and even if Promise A is rejected, you ll ignore it and want to proceed? — thefourtheye, Apr 19 '15 at 09:25
@thefourtheye. Yes. The operations that generate A and B are independent. They just can't happen concurrently. — cleong, Apr 19 '15 at 09:48
Yes, your code is very non-obvious, especially that `prevResult = null` thing. What exactly is this for? What is `doStuff`? — Bergi, Apr 19 '15 at 12:44
Setting `prevResult` to null allow the next operation to proceed. I guess the code would be a bit more obvious if I make the condition `prevResult && !prevResult.isFulfilled())` and remove the finally(). That'd mean the fulfillment value doesn't get gc'ed though. — cleong, Apr 20 '15 at 10:06

Benjamin Gruenbaum · Accepted Answer · 2015-04-20T11:41:53.737

3

Recently, .reflect was introduced as a more flexible .settle and a better abstraction altogether. Your use case sounds like something that's easy to do with .reflect

A.reflect().then(function(){
   return doSomethingThatReturnsB();
});

A full example with your code:

var prevResult;
function doStuff() {
    prevResult = Promise.resolve(prevResult).reflect().then(function(){
        return updateDB();
    });
    return prevResult;
}

edited Apr 20 '15 at 11:41

answered Apr 19 '15 at 14:38

Benjamin Gruenbaum

270,886
87
504
504

2

`.reflect` seems to have gained some momentum. I would find `.inspectify` more intuitive. – Roamer-1888 Apr 19 '15 at 20:33
3

You know I <3 you dude but that's a terrible name :D – Benjamin Gruenbaum Apr 19 '15 at 20:34
1

Trouble with "reflect" here is that it's figurative. Literally, reflection is what happens in a mirror, or as [modelled mathematically](http://en.wikipedia.org/wiki/Transformation_matrix#Reflection). The only way I'll ever remember Petkaantonov's usage is `"reflect" == "inspectify"` :D – Roamer-1888 Apr 19 '15 at 21:28
Relaxation also means looking at oneself http://en.m.wikipedia.org/wiki/Reflection_%28computer_programming%29 – Benjamin Gruenbaum Apr 19 '15 at 21:30
Thanks for the answer. I don't think the second example is correct though. – cleong Apr 20 '15 at 09:55
@cleong glad I could help, feel free to suggest an edit to the second example :) – Benjamin Gruenbaum Apr 20 '15 at 10:06
I fixed your example, I think. – cleong Apr 20 '15 at 15:40
@Roamer-1888, reflect also has a precedent in computer science https://en.wikipedia.org/wiki/Reflection_(computer_programming) – Rene Wooller Jun 30 '16 at 04:40

score 0 · Answer 2 · answered Apr 19 '15 at 09:29

You can use finally, which fires regardless of the outcome of the previous promise.

Following code is from the bluebird github doco.

function ajaxGetAsync(url) {
    return new Promise(function (resolve, reject) {
        var xhr = new XMLHttpRequest;
        xhr.addEventListener("error", reject);
        xhr.addEventListener("load", resolve);
        xhr.open("GET", url);
        xhr.send(null);
    }).finally(function() {
        $("#ajax-loader-animation").hide();
    });
}

finally() returns a promise that yields the value of the promise on which it's called (and not the return value of the callback). — cleong, Apr 19 '15 at 09:51

score 0 · Answer 3 · answered Apr 19 '15 at 10:46

Let's assume you have two promise-returning functions doAsync_A and doAsync_B.

The following expression will execute doAsync_A, wait for its promise to settle (to become fulfilled or rejected), then execute doAsync_B

Promise.settle([doAsync_A()]).then(doAsync_B);

doAsync_B will be passed a "PromiseInspection" array (here a single element). If necessary, you can test whether doAsync_A was successful or failed.

function doAsync_B(results) {
    var r = results[0];
    if (r.isFulfilled()) {  // check if was successful
        console.log(r.value()); // the promise's return value
    } else if (r.isRejected()) { // check if the read failed
        console.log(r.reason()); // the promise's rejection reason
    }
}

adapted from the bluebird documentation

score 0 · Answer 4 · edited May 23 '17 at 12:31

0

I think the best way would be to put doStuff as both fulfillment and rejection handler:

prevResult = prevResult.then(function() { return doStuff(); },
                             function() { return doStuff(); });

Or alternatively

prevResult = prevResult.catch(ignore).then(function() { return doStuff(); });

It seems you are trying to queue updateDB operations. I would recommend not to reset prevResult to null, but instead just make it a promise that is fulfilled when all queued operations are done. Have a look at this example.

edited May 23 '17 at 12:31

Community

1
1

answered Apr 19 '15 at 12:40

Bergi

630,263
148
957
1,375

Why the anonymous wrappers? Why not just `.then(doStuff, doStuff)`? – jfriend00 Apr 19 '15 at 15:24
@jfriend00: Depends on whether you want any arguments to `doStuff` or not. If you don't care, then `.then(doStuff, doStuff)` is certainly better. – Bergi Apr 19 '15 at 15:41

Bluebird: Waiting for one promise to settle

4 Answers4