ðŸŠī\zansh.in\js

JavaScript tinkerings.

pooling / limiting promises

Use Set to implement a Promise API that limits the number of concurrently running tasks.

💐  new Set()

const numbers = new Set([1, 2, 3])
function remove() {
numbers.delete(2)
}
function add() {
numbers.add(2)
}

ðŸŒļ  makeCounter()

const { count, up, down } =
makeCounter()
function makeCounter() {
let count = 0
return {
up: () => (count += 1),
down: () => (count -= 1),
count: () => count
}
}

🌚  hold()

const pause = () =>
hold(1).then(n =>
console.log(`took ${n} seconds`)
)
function hold(n) {
return new Promise(resolve =>
setTimeout(resolve, n * 1000, n)
)
}

🌷  makePromise()

const Log = msg => () => console.log(msg)
const [promise, resolve, reject] =
makePromise()
promise
.then(Log('then'))
.catch(Log('catch'))
.finally(Log('finally'))
function makePromise() {
let resolve
let reject
const promise = new Promise((O, X) => {
resolve = O
reject = X
})
return [promise, resolve, reject]
}

ðŸŒŧ  makePromisePool()

const add = makePromisePool(2)
const run = () =>
Promise.allSettled([
add(() => hold(3).then(log)),
add(() => hold(1).then(log)),
add(() => hold(2).then(log))
]).then(() => log('done!'))
run()
function makePromisePool(limit) {
let running = 0
const pending = new Set()
return promiseMakerFn => {
const [promise, O, X] = makePromise()
promise.finally(
() => ((running -= 1), next())
)
pending.add({ promiseMakerFn, O, X })
next()
return promise
}
function next() {
Array.from(pending).every(config => {
if (running < limit) {
running += 1
pending.delete(config)
config
.promiseMakerFn()
.then(config.O, config.X)
return true
}
})
}
}

Google it:

ðŸŒļ addition assignment 🌚 closures 🌷 currying ðŸŒŧ destructuring assignment 🌞 expression statement ðŸŒđ high-order functions 💐 hoisting ðŸŒļ new Set 🌚 Promise 🌷 setTimeout ðŸŒŧ subtraction assignment