Chaining promises in a waterfall

Question

I've been playing around with a few different ways of chaining a collection of functions and can't seem to find one I particularly like. The following is the last one I settled on but am still not keen on it.

Can someone suggest a cleaner and more concise pattern? I don't want to opt for Async.js or a library.

[
  this.connectDatabase.bind(this),
  this.connectServer.bind(this),
  this.listen.bind(this)
].reduce(
  (chain, fn) => {
    let p = new Promise(fn);
    chain.then(p);
    return p;
  },
  Promise.resolve()
);

Ps. any other tips are more than welcomed.

Answer 1

Found this solution on stackoverflow on how you can chain promises dynamically:

iterable.reduce((p, fn) => p.then(fn), Promise.resolve())

The complete post is here: https://stackoverflow.com/a/30823708/4052701

Answer 2

What about ES7 async/await? Strange/old bind(this) in your code, but kept to not confuse with your example.

async function x() {
    try {
        await this.connectDatabase.bind(this);
        await this.connectServer.bind(this);
        await this.listen.bind(this);
    } catch(e) {
        throw e;
    }
}

or more generic

async function () {
    for (let item of yourArray) {
        try {
            await item.bind(this); //strange bind of your code.
        } catch(e) {
            throw e;
        }
    }
}