Add solutions for 5th chapter

Author: kasymbayaman

05-promises-async-patterns/5.1-promise-all.js

@@ -0,0 +1,48 @@
+/*
+Implement your own version of Promise.
+all() leveraging promises, async/await, or a combination of the two.
+The function must be functionally equivalent to its original counterpart.
+*/
+
+// 1. Promise.all using async await
+async function promiseAll(promises) {
+  try {
+    for (const promise of promises) {
+      await promise;
+    }
+  } catch (e) {
+    console.log('Error in promiseAll', e);
+  }
+}
+
+//  2. Promise.all using promises
+async function promiseAll2(promises) {
+  return new Promise((resolve, reject) => {
+
+    let resolvedPromises = 0;
+    promises.forEach((promise) => {
+
+      promise.then(() => {
+        resolvedPromises++;
+        if (resolvedPromises === promises.length) resolve();
+      }, reject);
+
+    })
+  });
+}
+
+
+
+// testing
+function wait(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`Resolved ${ms}`);
+      resolve('Resolved successfully');
+    }, ms);
+  });
+}
+
+promiseAll2([wait(150), wait(399), wait(1500), wait(400), wait(5000), wait(5000)]).then(() => {
+  console.log('ALL promises are resolved');
+})

05-promises-async-patterns/5.2-taskqueue-promises.js

@@ -0,0 +1,58 @@
+/* Migrate the TaskQueue class internals from
+promises to async/await where possible. Hint: you won't be able to use
+async/await everywhere.
+*/
+
+export class TaskQueue {
+  constructor(concurrency) {
+    this.concurrency = concurrency
+    this.running = 0
+    this.queue = []
+  }
+
+  // cannot be migrated to async because of error handling issues
+  runTask(task) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(() => {
+        return task().then(resolve, reject)
+      })
+
+      process.nextTick(this.next.bind(this))
+    })
+  }
+
+  async next() {
+    while (this.running < this.concurrency && this.queue.length) {
+      const task = this.queue.shift();
+      this.running++
+      try {
+        await task();
+      } finally {
+        this.running--
+        this.next()
+      }
+    }
+  }
+}
+
+const MAX_CONCURRENCY = 4;
+const queue = new TaskQueue(MAX_CONCURRENCY);
+
+function wait(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`Resolved ${ms}`);
+      resolve('Resolved successfully');
+    }, ms);
+  });
+}
+
+function taskCreator (ms) {
+  return async function () {
+    await wait(ms);
+  }
+}
+
+[taskCreator(3000), taskCreator(3000), taskCreator(3000), taskCreator(3000), taskCreator(3000)].forEach((task) => {
+  queue.runTask(task);
+})

05-promises-async-patterns/5.3-producer-consumer.js

@@ -0,0 +1,85 @@
+/*
+5.3 Producer-consumer with promises: Update the TaskQueuePC class
+internal methods so that they use just promises, removing any use of the
+async/await syntax. Hint: the infinite loop must become an asynchronous
+recursion. Beware of the recursive Promise resolution memory leak!
+*/
+
+export class TaskQueuePC {
+  constructor(concurrency) {
+    this.taskQueue = [];
+    this.consumerQueue = [];
+
+    // spawn consumers
+    for (let i = 0; i < concurrency; i++) {
+      this.consumer();
+    }
+  }
+
+  async consumer() {
+  // ===== changed lines
+    return new Promise((resolve, reject) => {
+      const consumeTask = () => {
+        this.getNextTask()
+        .then(task => task())
+        .then(() => consumeTask())
+        .catch(error => reject(error));
+      }
+
+      consumeTask();
+    });
+    // ======
+  }
+
+  async getNextTask() {
+    return new Promise((resolve) => {
+      if (this.taskQueue.length !== 0) {
+        return resolve(this.taskQueue.shift());
+      }
+
+      this.consumerQueue.push(resolve);
+    })
+  }
+
+  async runTask(task) {
+    return new Promise((resolve, reject) => {
+      const taskWrapper = () => {
+        const taskPromise = task();
+        taskPromise.then(resolve, reject);
+        return taskPromise;
+      }
+
+      if (this.consumerQueue.length !== 0) {
+        const consumer = this.consumerQueue.shift();
+        consumer(taskWrapper);
+      } else {
+        this.taskQueue.push(taskWrapper);
+      }
+    })
+  }
+
+}
+
+// === TESTING
+
+const MAX_CONCURRENCY = 4;
+const queue = new TaskQueuePC(MAX_CONCURRENCY);
+
+function wait(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`Resolved ${ms}`);
+      resolve('Resolved successfully');
+    }, ms);
+  });
+}
+
+function taskCreator (ms) {
+  return async function () {
+    await wait(ms);
+  }
+}
+
+[taskCreator(3000), taskCreator(3000), taskCreator(3000), taskCreator(3000), taskCreator(3000)].forEach((task) => {
+  queue.runTask(task);
+})

05-promises-async-patterns/5.4-async-map.js

@@ -0,0 +1,63 @@
+/*
+5.4 An asynchronous map() : Implement a parallel asynchronous version
+of Array.map() that supports promises and a concurrency limit. The
+function should not directly leverage the TaskQueue or TaskQueuePC
+classes we presented in this chapter, but it can use the underlying patterns.
+The function, which we will define as mapAsync(iterable, callback,
+concurrency) , will accept the following as inputs:
+• An iterable , such as an array.
+• A callback , which will receive as the input each item of the iterable
+(exactly like in the original Array.map() ) and can return either
+a Promise or a simple value.
+• A concurrency , which defines how many items in the iterable can
+be processed by callback in parallel at each given time.
+*/
+
+async function mapAsync(iterable, callback, concurrency) {
+  // trigger calls while running operations count is less than concurrency
+  // when reached concurrency do nothing
+  // when all operations resolved return
+
+  // after getting concurrency result decrement running operations
+  // if (not reached) trigger calling operations
+
+  let id = 0;
+  let runningOps = 0;
+  let resolvedOps = 0;
+  const resultArr = [];
+
+  return new Promise((resolve, reject) => {
+    const runCallbacks = () => {
+      while (runningOps < concurrency && id < iterable.length) {
+        runningOps++;
+        const currentOpId = id;
+        callback(iterable[id]).then((result) => {
+          resultArr[currentOpId] = result;
+          runningOps--;
+          resolvedOps++;
+          runCallbacks();
+        }).catch(reject);
+        id++;
+      }
+
+      if (resolvedOps === iterable.length) return resolve(resultArr);
+    }
+
+    runCallbacks();
+  });
+}
+
+// TESTING
+function wait(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`Resolved ${ms}`);
+      resolve(`Resolved ${ms}`);
+    }, ms);
+  });
+}
+
+
+const MAX_CONCURRENCY = 2;
+
+mapAsync([1000, 3000, 500, 1500, 2000], wait, MAX_CONCURRENCY).then((res) => console.log('RESOLVED ALL', res));