async

Time monad - ap.

Time monad - >>=.

Make any promise cancellable.

Example:

let { promise, cancel } = async.cancellable(
    async.timeout(() => "Job done!", 2000)
)

promise.then(utils.to_("resolved")).catch(utils.to_("rejected"))

cancel("I've changed my mind")

Mutual exclusion for asynchronous functions.

Example:

const mutex = async.createMutex()

let f = async m => {
    let val = await m.lock()
    return `Freed with val: ${val}`
}

f(mutex).then(utils.to_("success")).catch(utils.to_("failure"))

mutex.resolve(42)  //  mutex.reject("ERROR")

Create mutex with watchdog (10 minutes by default).

barrier, in contrast to mutex, is preventing node process from exiting.

Example:

const barrier = createBarrier<void>();

setTimeout(() => { barrier.resolve("Released!"); }, 2000);

await barrier.lock();

Delay current async execution by time miliseconds.

Example:

(async () => {
    await async.delay()
    console.log("Hello ...")
    await async.delay()
    console.log("... world")
})()

setInterval in Promise / async skin.

Example 1:

global.x = 0
async.interval(
    c => {
        if (global.x === 10) { c("tada") }
        else { global.x += 1 }
        console.log("ping", Date.now())
    }
)
.then(utils.to_("success"))
.catch(utils.to_("failure"))

Example 2:

interval(
    () => { console.log("Hey!"); return 42 },
    c => timeout(() => c(), 4 * timeUnit.second)
)
.then(x => console.log("Finished:", x))
.catch(c => console.log("Error:", c))

Time monad - liftr.

Asynchronous version of standard Array.prototype.map function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.map(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Asynchronous version of standard Array.prototype.map function.

Implementation that does paralell execution.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.parMap(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Imperative promise pool.

const pool = promisePool(128);
for (element of dataSeries) {
    let r = await pool.exec(async () => {
        // ...
    });
    if (r.status === "fulfilled") {
        // ...
    } else if (r.status === "rejected") {
        // ...
    }
}
let rest = await pool.finish();

Resolve or reject when any of the promises passed as arguments resolve or reject.

Mirror of the standard function Promise.race().

Example:

m1 = async.createMutex()
m2 = async.createMutex()

async.race(m1.lock(), m2.lock())
    .then(utils.to_("resolved"))
    .catch(utils.to_("rejected"))

m1.resolve("All right!")  //  or, e.g: m2.reject("Some left!")

Time monad - =<<.

Asynchronous version of standard Array.prototype.reduce function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • acc - accumulates the f's return values; it is the accumulated value previously returned in the last invocation of f, or initAcc, if supplied.
  • element - currently processed element
  • index - current index
• initAcc - value to use as the first argument to the first call of the f. If no initial value is supplied, the first element in the array will be used.

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.reduce(
        array.range(10),
        (acc, x) => async.timeout(() => acc+x, 100*x),
        0
    )
    console.log(x)
})()

Repeat f (sync. or async.) while condition evaluates to true.

Resolves with result of last f execution when condition evaluates to false.

setTimeout in Promise / async skin.

Example:

async.timeout(
    () => { console.log("Hey!"); return 42 }, 2000,
    c => async.timeout(() => c("Cancelled!"), 1000)
)
.then(x => console.log("Success:", x))
.catch(c => console.log("Error or cancel:", c))

Time monad - return.

Time monad - ap.

Time monad - >>=.

Make any promise cancellable.

Example:

let { promise, cancel } = async.cancellable(
    async.timeout(() => "Job done!", 2000)
)

promise.then(utils.to_("resolved")).catch(utils.to_("rejected"))

cancel("I've changed my mind")

Mutual exclusion for asynchronous functions.

Example:

const mutex = async.createMutex()

let f = async m => {
    let val = await m.lock()
    return `Freed with val: ${val}`
}

f(mutex).then(utils.to_("success")).catch(utils.to_("failure"))

mutex.resolve(42)  //  mutex.reject("ERROR")

Create mutex with watchdog (10 minutes by default).

barrier, in contrast to mutex, is preventing node process from exiting.

Example:

const barrier = createBarrier<void>();

setTimeout(() => { barrier.resolve("Released!"); }, 2000);

await barrier.lock();

Delay current async execution by time miliseconds.

Example:

(async () => {
    await async.delay()
    console.log("Hello ...")
    await async.delay()
    console.log("... world")
})()

setInterval in Promise / async skin.

Example 1:

global.x = 0
async.interval(
    c => {
        if (global.x === 10) { c("tada") }
        else { global.x += 1 }
        console.log("ping", Date.now())
    }
)
.then(utils.to_("success"))
.catch(utils.to_("failure"))

Example 2:

interval(
    () => { console.log("Hey!"); return 42 },
    c => timeout(() => c(), 4 * timeUnit.second)
)
.then(x => console.log("Finished:", x))
.catch(c => console.log("Error:", c))

Time monad - liftr.

Asynchronous version of standard Array.prototype.map function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.map(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Asynchronous version of standard Array.prototype.map function.

Implementation that does paralell execution.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.parMap(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Imperative promise pool.

const pool = promisePool(128);
for (element of dataSeries) {
    let r = await pool.exec(async () => {
        // ...
    });
    if (r.status === "fulfilled") {
        // ...
    } else if (r.status === "rejected") {
        // ...
    }
}
let rest = await pool.finish();

Resolve or reject when any of the promises passed as arguments resolve or reject.

Mirror of the standard function Promise.race().

Example:

m1 = async.createMutex()
m2 = async.createMutex()

async.race(m1.lock(), m2.lock())
    .then(utils.to_("resolved"))
    .catch(utils.to_("rejected"))

m1.resolve("All right!")  //  or, e.g: m2.reject("Some left!")

Time monad - =<<.

Asynchronous version of standard Array.prototype.reduce function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • acc - accumulates the f's return values; it is the accumulated value previously returned in the last invocation of f, or initAcc, if supplied.
  • element - currently processed element
  • index - current index
• initAcc - value to use as the first argument to the first call of the f. If no initial value is supplied, the first element in the array will be used.

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.reduce(
        array.range(10),
        (acc, x) => async.timeout(() => acc+x, 100*x),
        0
    )
    console.log(x)
})()

Repeat f (sync. or async.) while condition evaluates to true.

Resolves with result of last f execution when condition evaluates to false.

setTimeout in Promise / async skin.

Example:

async.timeout(
    () => { console.log("Hey!"); return 42 }, 2000,
    c => async.timeout(() => c("Cancelled!"), 1000)
)
.then(x => console.log("Success:", x))
.catch(c => console.log("Error or cancel:", c))

Time monad - return.

Time monad - ap.

Time monad - >>=.

Make any promise cancellable.

Example:

let { promise, cancel } = async.cancellable(
    async.timeout(() => "Job done!", 2000)
)

promise.then(utils.to_("resolved")).catch(utils.to_("rejected"))

cancel("I've changed my mind")

Mutual exclusion for asynchronous functions.

Example:

const mutex = async.createMutex()

let f = async m => {
    let val = await m.lock()
    return `Freed with val: ${val}`
}

f(mutex).then(utils.to_("success")).catch(utils.to_("failure"))

mutex.resolve(42)  //  mutex.reject("ERROR")

Create mutex with watchdog (10 minutes by default).

barrier, in contrast to mutex, is preventing node process from exiting.

Example:

const barrier = createBarrier<void>();

setTimeout(() => { barrier.resolve("Released!"); }, 2000);

await barrier.lock();

Delay current async execution by time miliseconds.

Example:

(async () => {
    await async.delay()
    console.log("Hello ...")
    await async.delay()
    console.log("... world")
})()

setInterval in Promise / async skin.

Example 1:

global.x = 0
async.interval(
    c => {
        if (global.x === 10) { c("tada") }
        else { global.x += 1 }
        console.log("ping", Date.now())
    }
)
.then(utils.to_("success"))
.catch(utils.to_("failure"))

Example 2:

interval(
    () => { console.log("Hey!"); return 42 },
    c => timeout(() => c(), 4 * timeUnit.second)
)
.then(x => console.log("Finished:", x))
.catch(c => console.log("Error:", c))

Time monad - liftr.

Asynchronous version of standard Array.prototype.map function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.map(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Asynchronous version of standard Array.prototype.map function.

Implementation that does paralell execution.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.parMap(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Imperative promise pool.

const pool = promisePool(128);
for (element of dataSeries) {
    let r = await pool.exec(async () => {
        // ...
    });
    if (r.status === "fulfilled") {
        // ...
    } else if (r.status === "rejected") {
        // ...
    }
}
let rest = await pool.finish();

Resolve or reject when any of the promises passed as arguments resolve or reject.

Mirror of the standard function Promise.race().

Example:

m1 = async.createMutex()
m2 = async.createMutex()

async.race(m1.lock(), m2.lock())
    .then(utils.to_("resolved"))
    .catch(utils.to_("rejected"))

m1.resolve("All right!")  //  or, e.g: m2.reject("Some left!")

Time monad - =<<.

Asynchronous version of standard Array.prototype.reduce function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • acc - accumulates the f's return values; it is the accumulated value previously returned in the last invocation of f, or initAcc, if supplied.
  • element - currently processed element
  • index - current index
• initAcc - value to use as the first argument to the first call of the f. If no initial value is supplied, the first element in the array will be used.

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.reduce(
        array.range(10),
        (acc, x) => async.timeout(() => acc+x, 100*x),
        0
    )
    console.log(x)
})()

Repeat f (sync. or async.) while condition evaluates to true.

Resolves with result of last f execution when condition evaluates to false.

setTimeout in Promise / async skin.

Example:

async.timeout(
    () => { console.log("Hey!"); return 42 }, 2000,
    c => async.timeout(() => c("Cancelled!"), 1000)
)
.then(x => console.log("Success:", x))
.catch(c => console.log("Error or cancel:", c))

Time monad - return.

Time monad - ap.

Time monad - >>=.

Make any promise cancellable.

Example:

let { promise, cancel } = async.cancellable(
    async.timeout(() => "Job done!", 2000)
)

promise.then(utils.to_("resolved")).catch(utils.to_("rejected"))

cancel("I've changed my mind")

Mutual exclusion for asynchronous functions.

Example:

const mutex = async.createMutex()

let f = async m => {
    let val = await m.lock()
    return `Freed with val: ${val}`
}

f(mutex).then(utils.to_("success")).catch(utils.to_("failure"))

mutex.resolve(42)  //  mutex.reject("ERROR")

Create mutex with watchdog (10 minutes by default).

barrier, in contrast to mutex, is preventing node process from exiting.

Example:

const barrier = createBarrier<void>();

setTimeout(() => { barrier.resolve("Released!"); }, 2000);

await barrier.lock();

Delay current async execution by time miliseconds.

Example:

(async () => {
    await async.delay()
    console.log("Hello ...")
    await async.delay()
    console.log("... world")
})()

setInterval in Promise / async skin.

Example 1:

global.x = 0
async.interval(
    c => {
        if (global.x === 10) { c("tada") }
        else { global.x += 1 }
        console.log("ping", Date.now())
    }
)
.then(utils.to_("success"))
.catch(utils.to_("failure"))

Example 2:

interval(
    () => { console.log("Hey!"); return 42 },
    c => timeout(() => c(), 4 * timeUnit.second)
)
.then(x => console.log("Finished:", x))
.catch(c => console.log("Error:", c))

Time monad - liftr.

Asynchronous version of standard Array.prototype.map function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.map(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Asynchronous version of standard Array.prototype.map function.

Implementation that does paralell execution.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.parMap(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Imperative promise pool.

const pool = promisePool(128);
for (element of dataSeries) {
    let r = await pool.exec(async () => {
        // ...
    });
    if (r.status === "fulfilled") {
        // ...
    } else if (r.status === "rejected") {
        // ...
    }
}
let rest = await pool.finish();

Resolve or reject when any of the promises passed as arguments resolve or reject.

Mirror of the standard function Promise.race().

Example:

m1 = async.createMutex()
m2 = async.createMutex()

async.race(m1.lock(), m2.lock())
    .then(utils.to_("resolved"))
    .catch(utils.to_("rejected"))

m1.resolve("All right!")  //  or, e.g: m2.reject("Some left!")

Time monad - =<<.

Asynchronous version of standard Array.prototype.reduce function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • acc - accumulates the f's return values; it is the accumulated value previously returned in the last invocation of f, or initAcc, if supplied.
  • element - currently processed element
  • index - current index
• initAcc - value to use as the first argument to the first call of the f. If no initial value is supplied, the first element in the array will be used.

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.reduce(
        array.range(10),
        (acc, x) => async.timeout(() => acc+x, 100*x),
        0
    )
    console.log(x)
})()

Repeat f (sync. or async.) while condition evaluates to true.

Resolves with result of last f execution when condition evaluates to false.

setTimeout in Promise / async skin.

Example:

async.timeout(
    () => { console.log("Hey!"); return 42 }, 2000,
    c => async.timeout(() => c("Cancelled!"), 1000)
)
.then(x => console.log("Success:", x))
.catch(c => console.log("Error or cancel:", c))

Time monad - return.

Time monad - ap.

Time monad - >>=.

Make any promise cancellable.

Example:

let { promise, cancel } = async.cancellable(
    async.timeout(() => "Job done!", 2000)
)

promise.then(utils.to_("resolved")).catch(utils.to_("rejected"))

cancel("I've changed my mind")

Mutual exclusion for asynchronous functions.

Example:

const mutex = async.createMutex()

let f = async m => {
    let val = await m.lock()
    return `Freed with val: ${val}`
}

f(mutex).then(utils.to_("success")).catch(utils.to_("failure"))

mutex.resolve(42)  //  mutex.reject("ERROR")

Create mutex with watchdog (10 minutes by default).

barrier, in contrast to mutex, is preventing node process from exiting.

Example:

const barrier = createBarrier<void>();

setTimeout(() => { barrier.resolve("Released!"); }, 2000);

await barrier.lock();

Delay current async execution by time miliseconds.

Example:

(async () => {
    await async.delay()
    console.log("Hello ...")
    await async.delay()
    console.log("... world")
})()

setInterval in Promise / async skin.

Example 1:

global.x = 0
async.interval(
    c => {
        if (global.x === 10) { c("tada") }
        else { global.x += 1 }
        console.log("ping", Date.now())
    }
)
.then(utils.to_("success"))
.catch(utils.to_("failure"))

Example 2:

interval(
    () => { console.log("Hey!"); return 42 },
    c => timeout(() => c(), 4 * timeUnit.second)
)
.then(x => console.log("Finished:", x))
.catch(c => console.log("Error:", c))

Time monad - liftr.

Asynchronous version of standard Array.prototype.map function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.map(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Asynchronous version of standard Array.prototype.map function.

Implementation that does paralell execution.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • element - currently processed element
  • index - current index

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.parMap(
        array.range(10),
        x => async.timeout(() => 4*x, 100*x)
    )
    console.log(x)
})()

Imperative promise pool.

const pool = promisePool(128);
for (element of dataSeries) {
    let r = await pool.exec(async () => {
        // ...
    });
    if (r.status === "fulfilled") {
        // ...
    } else if (r.status === "rejected") {
        // ...
    }
}
let rest = await pool.finish();

Resolve or reject when any of the promises passed as arguments resolve or reject.

Mirror of the standard function Promise.race().

Example:

m1 = async.createMutex()
m2 = async.createMutex()

async.race(m1.lock(), m2.lock())
    .then(utils.to_("resolved"))
    .catch(utils.to_("rejected"))

m1.resolve("All right!")  //  or, e.g: m2.reject("Some left!")

Time monad - =<<.

Asynchronous version of standard Array.prototype.reduce function.

• arr - array to operate on
• f - async or sync function with signature:
  • this - bound to arr
  • acc - accumulates the f's return values; it is the accumulated value previously returned in the last invocation of f, or initAcc, if supplied.
  • element - currently processed element
  • index - current index
• initAcc - value to use as the first argument to the first call of the f. If no initial value is supplied, the first element in the array will be used.

f can return Promise.<unknown> or <unknown>

Example:

(async () => {
    let x = await async.reduce(
        array.range(10),
        (acc, x) => async.timeout(() => acc+x, 100*x),
        0
    )
    console.log(x)
})()

Repeat f (sync. or async.) while condition evaluates to true.

Resolves with result of last f execution when condition evaluates to false.

setTimeout in Promise / async skin.

Example:

async.timeout(
    () => { console.log("Hey!"); return 42 }, 2000,
    c => async.timeout(() => c("Cancelled!"), 1000)
)
.then(x => console.log("Success:", x))
.catch(c => console.log("Error or cancel:", c))

Time monad - return.