copperwall

<?php

declare(strict_types = 1);

/**
 * Like array_reduce() but over an iterable, and it returns a single value as
 * the result of calling $cb over the contents of iterable $itr.
 *
 * If $initial is not null, $initial is set to the value of the first element
 * of the iterable, and $cb is called with the first element as the carry value

copperwall

type PromiseFactory = () => Promise<any>;
function promiseAllBatched(
  promiseFactories: PromiseFactory[],
  batchSize: number
): Promise<any> {
  let completed = 0;
  let upNext = 0;
  let results: any[] = [];

  const initialBatchSize = Math.min(batchSize, promiseFactories.length);

copperwall

function *range(min, max) {
  while (min < max) {
    yield min
    min += 1
  }
}

// Doesn't run out of memory
for (const num of range(1, 1000000000000000000)) {
  console.log(num)

copperwall

function getBirthday(userid) {
  let birthday
  
  DB.getUser(userid).then(user => {
    birthday = user.birthday
  })
  
  return birthday
}

copperwall

async function api() {
  const res = await fetch("/api/2.0/guides");
  const json = await res.json();
  
  return json
}

async function getGuides() {
  let results = [];
  

copperwall

function *sortOfAsyncFunction() {
  const ivysaur = yield fetch('https://pokeapi.co/api/v2/pokemon/ivysaur');
  
  return ivysaur.name.toUpperCase();
}

// "IVYSAUR"
runner(sortOfAsyncFunction).then(result => console.log(result));

copperwall

const util = require('util');
const S3 = require('aws-sdk/clients/s3');

const client = new S3();
const createBucket = util.promisify(client.createBucket);
const upload = util.promisify(client.upload);
const getObject = util.promisify(client.getObject);

client.createBucket = createBucket;
client.upload = upload;

copperwall

const test = {
  spy: function(fn) {
    const calls = [];
    return new Proxy(stuff, {
      apply(target, thisArg, args) {
        const result = target.apply(thisArg, args);
        calls.push([args, result]);
      },

      get(target, p){

copperwall

const myObject = {};
const loudObject = new Proxy({}, {
  get(target, p) {
    console.log(`Accessing key ${String(p)} at ${(new Error()).stack}`);
    return target[p];
  },

  set(target, p, value) {
    console.log(`Setting key ${String(p)} to ${String(value)} at ${(new Error()).stack}`);
    target[p] = value;

copperwall

function runner(gen, ...args) {
  // Initialize the generator.
  let iterator = gen(...args);    
  
  // handleNext is responsible for restarting the generator with new input.
  return Promise.resolve().then(function handleNext(value) {
    // next can be a promise or a sync value.
    let next = iterator.next(value);
    
    // handleResult is responsible for taking the output of the generator