Search code examples
javascriptfunctional-programmingv8

Possible implementation of Promise.any on JS

In Promise.race the promise returns as soon that the primary promise returns. In Promise.all returns when all promises resolves, but lasts one problem. If any of all promises rejects all others will be rejected.

Instead of it, exists a proposal for a Promise.any, the returns every promise alone, independent of each other, short-circuiting on a rejection.

const logAfterWait = (seconds) => new Promise((resolve, reject) => {
    return setTimeout(() => resolve(console.log(`${time} time passed`)), seconds)
}) 

const watingList = [
    logAfterWait(convertToSeconds(10)),
    logAfterWait(convertToSeconds(30)),
    logAfterWait(convertToSeconds(5))
]

const logReading = async (fn) => {
    console.log(`${time}: reading file`)
    await fn()
}

const readFiles = (files) => Promise.all(watingList.map(logReading))
    .catch((error) => new Error(error))

The problem here is the block of event loop on the maping cause block on event loop on Promise.all, returning every results on the same time, differ from the expected result, that is, 5, 10, 30 seconds.

Can I avoid this situation on waitingList.map?

Solution

  • Consequently, I came to a conclusion. We create a resolver that is an Either monad(not a pure implementation of the Either monad) that returns [err, response] over a map function.

    The catch blocks are necessary to avoid the Unhandled Promise Rejection Warning.

    const time = () => `${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()}`;

const sleep = (ms, pNumber) => new Promise((resolve, reject) => {
    return pNumber < 3
        ? setTimeout(() => resolve(console.log(`${time()} time passed`)), ms)
        : reject(null)
    }).catch(null)


Promise.prototype.resolver = async (promise) => {
    this._result = await Promise.all([promise])[0];
    
    return this._result == null
        ? ["The time flies", promise]
        : [null, promise]
}

const watingList = [
    Promise.resolver(sleep(0, 0).catch(console.error)),
    Promise.resolver(sleep(3000, 1).catch(console.error)),
    Promise.resolver(sleep(5000, 2).catch(console.error)),
    Promise.resolver(sleep(5000, 3).catch(console.error))
]

const logReading = (list) => {
    return list.map(p => p.then(console.log(`${time()}: reading file`))
        .catch(console.log))
}

((read) => logReading(read))(watingList)

    PS: time function differs from the expected because of the evaluate time.