dtipson

const outputs = await pipe(
    postIds,// array of numbers, which is... already an iterable
    mapGen(fetchById),// generator of an array of eventually all resolved promises (requested in chunks of 3)
    chunkGen(5),// generator of arrays of 5 promises, our "batch"
    spreadBatchesAsyncGen,// async generator of individual resolved promises
    forEachAsyncGen(renderPost)// Promise of an array of numbers
)

dtipson

// spreadBatchesAsyncGen :: Iterator[[...Promises]] -> AsyncGenerator[[...Promises]]
const spreadBatchesAsyncGen = async function* (iterableOfPromises) {
    for (let array of iterableOfPromises) {
        yield* await Promise.all(array)
    }
}

dtipson

await pipe(
    postIds[Symbol.iterator](),// creates a generator from a plain array of postIds
    chunkGen(5),// generator that pulls in 5 numbers and yields them out in arrays of 5
    mapGen(map(fetchById)),// generator that takes in arrays of numbers & turns them into arrays of requests
    spreadBatchesAsyncGen,// async generator that spreads arrays of resolved promises & emits one promise at a time
    forEachAsyncGen(renderPost)// a function that consumes the generator & does something with each result
)

dtipson

export async function* batchTasks(tasks = [], limit = 5, taskCallback = r => r) {
  for (let i = 0; i < tasks.length; i = i + limit) {
    const batch = tasks.slice(i, i + limit)
    yield* await Promise.all(
      batch.map((task) => task().then(taskCallback))
    )
  }
}

dtipson

function throttle(fn, threshhold = 250, scope) {
  var last,
      deferTimer;
  return function () {
    var context = scope || this;

    var now = +new Date,
        args = arguments;
    if (last && now < last + threshhold) {
      // hold on to it

dtipson

document.body.innerHTML = '';

const delay = milliseconds => x => new Promise(resolve => setTimeout(resolve, milliseconds, x));

//requestRecord :: Object (optional) -> Promise Stream
const requestRecord = (config={video:true, audio:true}) => {
  return navigator.mediaDevices && navigator.mediaDevices.getUserMedia ?
    navigator.mediaDevices.getUserMedia(config).then(delay(1400)) : // delay avoid startup flash
    Promise.reject('no support for getUserMedia');

dtipson

// mapping over an array with an async function
// would return an Array of Promises which isn't 
// super useful to work with on its own

async function fooPromise(x){ 
  return Promise.resolve(x*3);
}

const arr = [6,7,8,9];// -> [Promise[18],Promise[21],Promise[24],Promise[27]]]

dtipson

const getProp = prop => object => object[prop]
function KeyedCollection (Iterable, prop){
  if (!(this instanceof KeyedCollection)) {
    return new KeyedCollection(Iterable, prop);
  }
  if(!prop){
    throw new Error('must supply a prop')
  }
  const it_target = []
  const selectPropFrom = getProp(prop)

dtipson

// Finally wrapped your head around Promises? Time to toss out all that knowledge and learn the functional alternative!

// Here's a super simple implementation of a Task "type" 
const __Task = fork => ({fork})

// Absurdly simple! All we're doing is using a function that returns some unknown value, by name, in an object. 
// At this point "fork" is just a cute name though: what matters is how we use it.
// What makes Task a "Task" is that is that the "fork" value here... will be a higher-order function.

// Here's a usage example, already fully functional, already nearly as powerful as Promise!

dtipson

var object = {
  value:5,
  increment(){ return ++this.value; }
};

/*
But of course, even though that value is central to what the object is, 
it's not really a _primitive_ value in the sense that we can directly coerce it into a number or string:
*/