JavaScript: Fundamental (ES6), part 1, 77–106

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38const field = 'lga';
const zone = 'B';
const idKey = Symbol('id');

const stall = {
  [field]: 'Ikeja',
  [`zone${zone}`]: true,
  zone,
  [1 + 1]: 'row two',
  [idKey]: 4417,
  describe() {
    return `${this[field]} zone ${this.zone}`;
  },
  arrowDescribe: () => `${this === undefined ? 'no this' : 'has this'}`,
};

const keys = Object.keys(stall);
const described = stall.describe();
const arrowSaw = stall.arrowDescribe();

const brokenArrow = { name: 'Yaba', label: () => `stall ${this?.name}` };
const brokenSaid = brokenArrow.label();

const symbolIsHidden = [keys.includes('id'), JSON.stringify(stall).includes('4417')];
const symbolIsReachable = [stall[idKey], Object.getOwnPropertySymbols(stall).length];

const last = 'takings';
const duplicated = { [last]: 1, [last]: 2, takings: 3 };

const special = { __proto__: null, good: 'garri' };
const computed = { ['__proto__']: null, good: 'garri' };
const prototypes = [Object.getPrototypeOf(special), Object.getPrototypeOf(computed) === Object.prototype];
const computedOwnsIt = Object.keys(computed);

console.log('keys   :', keys, '| numeric key:', stall[2]);
console.log('methods:', described, '| arrow:', arrowSaw, brokenSaid);
console.log('symbol :', symbolIsHidden, symbolIsReachable);
console.log('proto  :', prototypes, computedOwnsIt);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49const unit = 'naira';

const wallet = {
  kobo: 500000,
  get [unit]() {
    return this.kobo / 100;
  },
  set [unit](value) {
    if (typeof value !== 'number' || Number.isNaN(value)) throw new TypeError('naira must be a number');
    this.kobo = Math.round(value * 100);
  },
  get label() {
    return `₦${this.naira.toFixed(2)}`;
  },
};

const readAsNumber = [wallet.naira, typeof wallet.naira];
wallet.naira = 62.505;
const afterWrite = [wallet.kobo, wallet.label];

let rejected;
try {
  wallet.naira = 'plenty';
} catch (error) {
  rejected = error.constructor.name;
}
const unchanged = wallet.kobo;

let readOnly;
try {
  wallet.label = 'free';
} catch (error) {
  readOnly = error.constructor.name;
}

const descriptor = Object.getOwnPropertyDescriptor(wallet, 'naira');
const descriptorShape = [typeof descriptor.get, typeof descriptor.set, 'value' in descriptor, descriptor.enumerable];
const keysIncludeAccessors = Object.keys(wallet);
const serialised = JSON.parse(JSON.stringify(wallet));

const copy = { ...wallet };
const copyDescriptor = Object.getOwnPropertyDescriptor(copy, 'naira');
copy.kobo = 1;
const copyWentStale = [copy.naira, typeof copyDescriptor.get, copyDescriptor.value];

console.log('read   :', readAsNumber, '| after write:', afterWrite);
console.log('reject :', rejected, unchanged, '| read-only:', readOnly);
console.log('shape  :', descriptorShape, keysIncludeAccessors);
console.log('copy   :', copy, copyWentStale);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76class Wallet {
  #kobo = 0;
  static #opened = 0;

  constructor(kobo = 0) {
    this.#kobo = Wallet.#check(kobo);
    Wallet.#opened++;
  }

  static #check(kobo) {
    if (!Number.isInteger(kobo) || kobo < 0) throw new RangeError('kobo must be a whole number of at least zero');
    return kobo;
  }

  static fromNaira(naira) {
    return new Wallet(Math.round(naira * 100));
  }

  static get opened() {
    return Wallet.#opened;
  }

  static isWallet(value) {
    return #kobo in value;
  }

  get naira() {
    return this.#kobo / 100;
  }

  credit(kobo) {
    this.#kobo += Wallet.#check(kobo);
    return this;
  }

  toJSON() {
    return { kobo: this.#kobo, naira: this.naira };
  }
}

const a = new Wallet(150000);
const b = Wallet.fromNaira(62.505);
a.credit(50000).credit(1);

const balances = [a.toJSON(), b.toJSON()];
const openedCount = Wallet.opened;
const hiddenFromReflection = [Object.keys(a), JSON.stringify(b), 'kobo' in a];

const brands = [Wallet.isWallet(a), Wallet.isWallet({ kobo: 1 }), Wallet.isWallet(Wallet.prototype)];

let refused;
try {
  new Wallet(-5);
} catch (error) {
  refused = error.constructor.name;
}

let outside;
try {
  outside = new Function('return (w) => w.#kobo;');
} catch (error) {
  outside = error.constructor.name;
}

const detached = a.credit;
let lostThis;
try {
  detached(1);
} catch (error) {
  lostThis = error.constructor.name;
}

console.log('balances:', balances, '| opened:', openedCount);
console.log('hidden  :', hiddenFromReflection);
console.log('brands  :', brands, '| refused:', refused);
console.log('outside :', outside, '| detached:', lostThis);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60const tariff = Object.freeze({
  base: 25000,
  perKm: 1500,
  areas: { Lekki: 2500, Ikeja: 1000 },
  zones: ['A', 'B'],
});

const attempt = (fn) => {
  try {
    fn();
    return 'allowed';
  } catch (error) {
    return error.constructor.name;
  }
};

const changed = attempt(() => {
  tariff.base = 1;
});
const removed = attempt(() => {
  delete tariff.perKm;
});
const added = attempt(() => {
  tariff.surge = 2;
});
const nested = attempt(() => {
  tariff.areas.Lekki = 9999;
});
const pushedInside = attempt(() => {
  tariff.zones.push('C');
});

const stillOriginal = [tariff.base, tariff.perKm, 'surge' in tariff];
const nestedMoved = [tariff.areas.Lekki, tariff.zones];

const frozenList = Object.freeze(['garri', 'rice']);
const pushed = attempt(() => {
  frozenList.push('beans');
});
const sortedInPlace = attempt(() => {
  frozenList.sort();
});

const flags = Object.seal({ open: true, staff: 2 });
const sealedWrite = attempt(() => {
  flags.staff = 3;
});
const sealedAdd = attempt(() => {
  flags.closingTime = '18:00';
});
const states = [Object.isFrozen(tariff), Object.isSealed(tariff), Object.isFrozen(flags), Object.isSealed(flags)];

let rebindable = tariff;
rebindable = { base: 0 };
const primitivesPassThrough = [Object.freeze(5), Object.isFrozen(5)];

console.log('writes :', changed, removed, added, '| nested:', nested, pushedInside);
console.log('after  :', stillOriginal, nestedMoved);
console.log('array  :', pushed, sortedInPlace, '| sealed:', sealedWrite, sealedAdd);
console.log('states :', states, '| rebound:', rebindable.base);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63class Buyer {
  constructor(name) {
    this.name = name;
  }
  shout() {
    return this.name.toUpperCase();
  }
}

const order = {
  ref: 'IK-104',
  buyer: new Buyer('Adaeze'),
  address: { lga: 'Ikeja', street: 'Allen' },
  goods: ['garri', 'rice'],
  placed: new Date(0),
  counts: new Map([['garri', 2]]),
  seen: new Set(['garri']),
  note: undefined,
};

const shallow = { ...order };
const deep = structuredClone(order);

shallow.address.street = 'Awolowo';
const originalMovedWithShallow = order.address.street;

deep.address.street = 'Toyin';
const originalIgnoredDeep = order.address.street;
const sharedReferences = [shallow.address === order.address, deep.address === order.address];

deep.goods.push('beans');
const goodsStayed = order.goods.length;

const dateSurvived = [deep.placed instanceof Date, deep.placed.getTime()];
const collectionsSurvived = [deep.counts instanceof Map, [...deep.counts], deep.seen.has('garri')];
const undefinedSurvived = ['note' in deep, deep.note === undefined];

const cyclic = { lga: 'Ikeja' };
cyclic.itself = cyclic;
const clonedCycle = structuredClone(cyclic);
const cycleHeld = [clonedCycle.itself === clonedCycle, clonedCycle !== cyclic];
let jsonOnCycle;
try {
  JSON.stringify(cyclic);
} catch (error) {
  jsonOnCycle = error.constructor.name;
}

const prototypeLost = [order.buyer.shout(), deep.buyer instanceof Buyer, deep.buyer.name, typeof deep.buyer.shout];
let withFunction;
try {
  structuredClone({ price: () => 1 });
} catch (error) {
  withFunction = error.name;
}

const throughJson = JSON.parse(JSON.stringify({ placed: new Date(0), note: undefined, counts: new Map([['a', 1]]) }));
const jsonFlattens = [typeof throughJson.placed, 'note' in throughJson, throughJson.counts];

console.log('shallow:', originalMovedWithShallow, '| deep:', originalIgnoredDeep);
console.log('shared :', sharedReferences, '| goods:', goodsStayed);
console.log('kept   :', dateSurvived, collectionsSurvived, undefinedSurvived);
console.log('lost   :', prototypeLost, withFunction, '| json:', jsonFlattens);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61const store = new WeakMap();
const registered = new WeakSet();

class Account {
  constructor(holder, kobo) {
    this.holder = holder;
    store.set(this, { kobo });
    registered.add(this);
  }

  get kobo() {
    return store.get(this).kobo;
  }

  credit(kobo) {
    const state = store.get(this);
    if (!state) throw new TypeError('not an account this ledger knows');
    state.kobo += kobo;
    return this;
  }
}

const one = new Account('Adaeze', 150000);
const two = new Account('Bola', 20000);
one.credit(50000);

const balances = [one.kobo, two.kobo];
const nothingOnTheObject = [Object.keys(one), JSON.stringify(one), Object.getOwnPropertyNames(one)];
const noApi = [typeof store.size, typeof store[Symbol.iterator], typeof store.keys, typeof store.forEach];

let primitiveKey;
try {
  store.set('Adaeze', { kobo: 1 });
} catch (error) {
  primitiveKey = error.constructor.name;
}
const symbolKeysAreFine = (() => {
  const tag = Symbol('tag');
  const wm = new WeakMap();
  wm.set(tag, 'held');
  return wm.get(tag);
})();

const impostor = Object.create(Account.prototype);
impostor.holder = 'Nobody';
let refused;
try {
  impostor.credit(1);
} catch (error) {
  refused = error.constructor.name;
}
const membership = [registered.has(one), registered.has(impostor), store.has(one)];

const forgotten = new Account('Chidi', 100);
const removed = store.delete(forgotten);
const afterDelete = [store.has(forgotten), store.get(forgotten) === undefined];

console.log('balances:', balances);
console.log('object  :', nothingOnTheObject);
console.log('api     :', noApi, '| primitive key:', primitiveKey);
console.log('brand   :', membership, '| refused:', refused, '| deleted:', removed, afterDelete);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61let produced = 0;

class SeatBlock {
  constructor(rows, perRow) {
    this.rows = rows;
    this.perRow = perRow;
    this.closes = 0;
  }

  *[Symbol.iterator]() {
    try {
      for (let r = 0; r < this.rows; r++) {
        for (let s = 1; s <= this.perRow; s++) {
          produced++;
          yield `${String.fromCharCode(65 + r)}${s}`;
        }
      }
    } finally {
      this.closes++;
    }
  }
}

const block = new SeatBlock(2, 3);

const all = [...block];
const producedBySpread = produced;

produced = 0;
const [firstSeat, secondSeat] = block;
const producedByPattern = produced;

produced = 0;
const found = [];
for (const seat of block) {
  found.push(seat);
  if (seat === 'A2') break;
}
const producedByBreak = produced;

const closesSoFar = block.closes;
const asSet = new Set(block);
const reIterable = [asSet.size, [...block].length];

const bareGenerator = block[Symbol.iterator]();
const firstPull = bareGenerator.next().value;
const drained = [...bareGenerator].length;
const secondTime = [...bareGenerator].length;

const nextButNotIterable = { next: () => ({ value: 'A1', done: false }) };
let spreadFailed;
try {
  spreadFailed = [...nextButNotIterable];
} catch (error) {
  spreadFailed = error.constructor.name;
}

console.log('all    :', all, '| produced:', producedBySpread);
console.log('pattern:', firstSeat, secondSeat, '| produced:', producedByPattern);
console.log('break  :', found, '| produced:', producedByBreak, '| closes:', closesSoFar);
console.log('bare   :', firstPull, drained, secondTime, '| not iterable:', spreadFailed);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67function* rows(n) {
  for (let i = 1; i <= n; i++) yield `row ${i}`;
  return n;
}

function* block() {
  const counted = yield* rows(2);
  yield `counted ${counted}`;
  return 'block done';
}

const spreadSees = [...block()];
const stepped = [];
const it = block();
let step = it.next();
while (!step.done) {
  stepped.push(step.value);
  step = it.next();
}
const finalStep = [step.value, step.done];

function* mixed() {
  yield 'start';
  yield* ['garri', 'rice'];
  yield* 'NG';
  yield* rows(1);
}
const anyIterable = [...mixed()];

function* doubling(kobo) {
  let current = kobo;
  while (true) {
    yield current;
    current *= 2;
  }
}

const take = (n, iterable) => {
  const out = [];
  for (const value of iterable) {
    out.push(value);
    if (out.length === n) break;
  }
  return out;
};
const firstFive = take(5, doubling(100));

const stoppable = doubling(100);
const beforeStop = [stoppable.next().value, stoppable.next().value];
const stopped = stoppable.return('closed');
const afterStop = stoppable.next();

function* countingDown(from) {
  let n = from;
  while (n > 0) yield n--;
  return 'liftoff';
}
const inner = countingDown(3);
const outerValues = [...(function* () {
  const ending = yield* inner;
  yield ending;
})()];

console.log('spread :', spreadSees);
console.log('stepped:', stepped, '| final:', finalStep);
console.log('mixed  :', anyIterable);
console.log('endless:', firstFive, '| stop:', beforeStop, stopped, afterStop);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71const zones = [
  ['Ikeja', 'Agege', 'Ojota'],
  ['Yaba', 'Surulere', 'Lekki'],
  ['Ajah', 'Ikorodu', 'Epe'],
];

let visits = 0;
const findCell = (grid, wanted) => {
  let found = null;
  outer: for (let r = 0; r < grid.length; r++) {
    for (let c = 0; c < grid[r].length; c++) {
      visits++;
      if (grid[r][c] === wanted) {
        found = [r, c];
        break outer;                  // leaves BOTH loops
      }
    }
  }
  return found;
};
const cell = findCell(zones, 'Surulere');
const cellVisits = visits;
const cellsInGrid = zones.flat().length;

const innerOnly = [];
for (const row of zones) {
  for (const area of row) {
    if (area.startsWith('A')) break;  // only the inner loop; the outer one carries on
    innerOnly.push(area);
  }
}

const clean = [];
rows: for (const row of zones) {
  for (const area of row) {
    if (area === 'Lekki') continue rows;   // give up on this row entirely
  }
  clean.push(row[0]);
}

const viaReturn = (grid, wanted) => {
  for (let r = 0; r < grid.length; r++) {
    for (let c = 0; c < grid[r].length; c++) {
      if (grid[r][c] === wanted) return [r, c];
    }
  }
  return null;
};
const returned = [viaReturn(zones, 'Surulere'), viaReturn(zones, 'Abuja')];

const band = (kobo) => {
  let label = 'none';
  check: {
    if (kobo <= 0) break check;
    label = 'small';
    if (kobo < 100000) break check;
    label = 'large';
  }
  return label;
};
const bands = [band(0), band(50000), band(500000)];

const parse = (src) => {
  try { new Function(src); return 'compiled'; } catch (error) { return error.constructor.name; }
};
const refused = [parse('check: { continue check; }'), parse('outer: for (const x of [1]) { break nope; }')];

console.log('found     :', cell, '| cells visited:', cellVisits, 'of', cellsInGrid);
console.log('bare break:', innerOnly);
console.log('continue  :', clean, '| by return:', returned);
console.log('block      :', bands, '| refused:', refused);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26const naiveKobo = (text) => Math.round(Number(String(text).replace(/[^0-9.]/g, '')) * 100);

const kobo = (text) => {
  const cleaned = String(text).replace(/[^0-9.]/g, '');
  if (cleaned === '') return null;
  const naira = Number(cleaned);
  return Number.isFinite(naira) ? Math.round(naira * 100) : null;
};

const wholeOrNothing = [Number.isNaN(Number('12abc')), parseInt('12abc', 10), parseFloat('3.5kg')];
const exponent = [parseInt('1e3', 10), Number('1e3'), parseFloat('1e3')];
const blanks = [Number(''), Number('   '), naiveKobo('free')];
const guarded = [kobo('₦1,250.50'), kobo('free'), kobo(' 200 ')];
const commaStops = parseFloat('1,250.50');
const tinyNumber = parseInt(0.0000005, 10);

const integers = [Number.isInteger(5.0), Number.isInteger(5e20), Number.isInteger('5'), Number.isSafeInteger(2 ** 53)];
const unsafe = [2 ** 53 === 2 ** 53 + 1, Number.MAX_SAFE_INTEGER];
const nanCheck = [isNaN('abc'), Number.isNaN('abc'), Number.isNaN(Number('abc'))];
const separators = [1_000, Number.isNaN(Number('1_000'))];

console.log('whole     :', wholeOrNothing, '| exponent:', exponent);
console.log('blanks    :', blanks, '| guarded:', guarded);
console.log('comma     :', commaStops, '| 0.0000005 ->', tinyNumber);
console.log('isInteger :', integers, '| unsafe:', unsafe);
console.log('NaN       :', nanCheck, '| separators:', separators);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54const fareAsync = async (km) => km * 1500;
const pending = fareAsync(10);
const kind = [typeof pending.then, pending instanceof Promise];
const fare = await pending;

const trace = [];
const dispatch = async () => {
  trace.push('body');
  await null;                       // the first suspension, however trivial
  trace.push('after');
};
const running = dispatch();
const atOnce = [...trace];
await running;
const atEnd = [...trace];

let thenCalls = 0;
const thenable = {
  then(resolve) {
    thenCalls++;
    resolve('paid by thenable');
  },
};
const fromThenable = await thenable;

const dry = async () => {
  throw new Error('no fuel');
};
let caught;
try {
  await dry();
} catch (error) {
  caught = error.message;
}
const viaCatch = await dry().catch((error) => `handled: ${error.message}`);

const inner = Promise.resolve('adopted');
const outer = async () => inner;         // returning a promise, not a value
const once = await outer();
const twice = await await Promise.resolve('one level only');

const native = Promise.resolve(1);
const identity = [Promise.resolve(native) === native, Promise.resolve(thenable) === thenable];

const parse = (src) => {
  try { new Function(src); return 'compiled'; } catch (error) { return error.constructor.name; }
};
const outsideAsync = parse('return await Promise.resolve(1);');

console.log('returned  :', kind, '| value:', fare);
console.log('trace     :', atOnce, '->', atEnd);
console.log('thenable  :', fromThenable, '| then called', thenCalls, 'time(s)');
console.log('rejection :', caught, '|', viaCatch);
console.log('adoption  :', once, twice, '| identity:', identity, '| outside async:', outsideAsync);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61const settle = (value) => Promise.resolve(value);      // stands in for one request

const arrived = [];
for await (const name of ['Adaeze', 'Chinedu', 'Yetunde'].map(settle)) arrived.push(name);

let closes = 0;
async function* riders(names) {
  try {
    for (const name of names) {
      const checked = await settle(name.toUpperCase());
      yield checked;
    }
  } finally {
    closes++;                                          // runs however the loop ends
  }
}

const upper = [];
for await (const name of riders(['adaeze', 'chinedu'])) upper.push(name);
const closesAfterFull = closes;

const partial = [];
for await (const name of riders(['adaeze', 'chinedu', 'yetunde'])) {
  partial.push(name);
  if (partial.length === 1) break;
}
const closesAfterBreak = closes;

const woven = [];
async function* two() {
  woven.push('yielded a');
  yield 'a';
  woven.push('yielded b');
  yield 'b';
}
for await (const value of two()) woven.push('body ' + value);

const seen = [];
let loopError;
try {
  for await (const one of [settle('ok'), Promise.reject(new Error('rider offline')), settle('never read')]) {
    seen.push(one);
  }
} catch (error) {
  loopError = error.message;
}

const plainValues = [];
for await (const kobo of [12000, 25000]) plainValues.push(kobo);

const it = riders(['bola'])[Symbol.asyncIterator]();
const isOwnIterator = it[Symbol.asyncIterator]() === it;
const step = await it.next();
const end = await it.next();
const byHand = [step.value, step.done, end.done, end.value === undefined];

console.log('promises  :', arrived, '| plain values:', plainValues);
console.log('generator :', upper, '| closes after a full loop:', closesAfterFull);
console.log('break     :', partial, '| closes after a break:', closesAfterBreak);
console.log('interleave:', woven);
console.log('rejection :', seen, loopError, '| by hand:', byHand, isOwnIterator);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72const after = (ticks, value) => {
  let p = Promise.resolve();
  for (let i = 0; i < ticks; i++) p = p.then((v) => v);
  return p.then(() => value);
};

const finished = [];
const quote = (market, ticks) =>
  after(ticks, market).then((name) => {
    finished.push(name);
    return name;
  });
const outOfStock = (market, ticks) =>
  after(ticks, market).then(() => {
    finished.push(market + ' failed');
    throw new Error(market + ' is out of stock');
  });

let allError;
try {
  await Promise.all([quote('Balogun', 1), outOfStock('Oyingbo', 3), quote('Mile12', 9)]);
} catch (error) {
  allError = error.message;
}
const atRejection = [...finished];
await after(20, null);
const afterwards = [...finished];

const settled = (await Promise.allSettled([quote('Ketu', 1), outOfStock('Ojota', 2)])).map((one) => [
  one.status,
  one.status === 'fulfilled' ? one.value : one.reason.message,
]);

const anyValue = await Promise.any([outOfStock('Agege', 1), quote('Yaba', 4), quote('Epe', 8)]);

let aggregate;
try {
  await Promise.any([outOfStock('Ajah', 1), outOfStock('Ikorodu', 2)]);
} catch (error) {
  aggregate = [error.constructor.name, error.errors.map((e) => e.message)];
}

const raced = await Promise.race([quote('Surulere', 5), quote('Lekki', 1)]);
let racedError;
try {
  await Promise.race([outOfStock('Badagry', 1), quote('Apapa', 5)]);
} catch (error) {
  racedError = error.message;
}

const emptyAll = await Promise.all([]);
const emptySettled = await Promise.allSettled([]);
let emptyAny;
try {
  await Promise.any([]);
} catch (error) {
  emptyAny = [error.constructor.name, error.errors.length];
}

let raceEmptyDone = false;
Promise.race([]).then(() => { raceEmptyDone = true; }, () => { raceEmptyDone = true; });
await after(30, null);
const raceEmptyPending = raceEmptyDone === false;

const inOrder = await Promise.all([quote('slow', 9), quote('fast', 1)]);

console.log('all       :', allError, '| at the rejection:', atRejection);
console.log('losers    :', afterwards);
console.log('allSettled:', settled, '| any:', anyValue);
console.log('all failed:', aggregate, '| race:', raced, racedError);
console.log('empty     :', emptyAll, emptySettled, emptyAny, '| race([]) pending:', raceEmptyPending);
console.log('order     :', inOrder);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97const makeClock = () => {
  let now = 0;
  let waiting = [];
  const drain = async () => {
    for (let i = 0; i < 40; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait(ms) {
      return new Promise((resolve) => waiting.push({ at: now + ms, resolve }));
    },
    async advance(ms) {
      const target = now + ms;
      await drain();                                    // let waits register FIRST
      let due = waiting.filter((w) => w.at <= target).sort((a, b) => a.at - b.at)[0];
      while (due) {
        waiting = waiting.filter((w) => w !== due);
        now = due.at;
        due.resolve();
        await drain();                                  // whatever woke up may wait again
        due = waiting.filter((w) => w.at <= target).sort((a, b) => a.at - b.at)[0];
      }
      now = target;
      await drain();
    },
  };
};

const trip = (name, ms) => async (clock) => {
  await clock.wait(ms);
  return name + '@' + clock.now();
};

const sequential = async (clock, jobs) => {
  const out = [];
  for (const job of jobs) out.push(await job(clock));
  return out;
};
const parallel = (clock, jobs) => Promise.all(jobs.map((job) => job(clock)));

const three = () => [trip('Ikeja', 100), trip('Yaba', 100), trip('Lekki', 100)];

const c1 = makeClock();
const seqRun = sequential(c1, three());
await c1.advance(300);
const seq = await seqRun;
const seqAt = c1.now();

const c2 = makeClock();
const parRun = parallel(c2, three());
await c2.advance(100);
const par = await parRun;
const parAt = c2.now();

const c3 = makeClock();
const held1 = trip('first', 100)(c3);                   // called now
const held2 = trip('second', 100)(c3);                  // called now as well
await c3.advance(100);
const bothStarted = [await held1, await held2, c3.now()];

const c4 = makeClock();
const mixedPar = parallel(c4, [trip('quick', 50), trip('slow', 250)]);
await c4.advance(250);
const mixedParOut = [await mixedPar, c4.now()];

const c5 = makeClock();
const mixedSeq = sequential(c5, [trip('quick', 50), trip('slow', 250)]);
await c5.advance(300);
const mixedSeqOut = [await mixedSeq, c5.now()];

const c6 = makeClock();
const cancelled = async (clock) => {
  await clock.wait(30);
  throw new Error('rider cancelled');
};
const guarded = Promise.all([cancelled(c6), trip('other', 200)(c6)]).catch((error) => error.message);
await c6.advance(30);
const failure = [await guarded, c6.now()];

const c7 = makeClock();
const lookupFare = async (clock, area) => {
  await clock.wait(80);
  return area === 'Lekki' ? 250000 : 120000;
};
const applyPromo = async (clock, kobo) => {
  await clock.wait(20);
  return kobo - 20000;
};
const chained = (async () => applyPromo(c7, await lookupFare(c7, 'Lekki')))();
await c7.advance(100);
const chainedOut = [await chained, c7.now()];

console.log('sequential:', seq, 'at', seqAt);
console.log('parallel  :', par, 'at', parAt);
console.log('two calls :', bothStarted);
console.log('uneven    :', mixedParOut, 'against', mixedSeqOut);
console.log('rejection :', failure, '| dependent chain:', chainedOut);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43const deepEquals = (a, b) => {
  if (a === b) return true;                                   // primitives, and the same reference
  if (Number.isNaN(a) && Number.isNaN(b)) return true;        // the one thing === gets wrong
  if (typeof a !== 'object' || typeof b !== 'object') return false;
  if (a === null || b === null) return false;
  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
  if (a instanceof Date) return a.getTime() === b.getTime();
  if (Array.isArray(a)) return a.length === b.length && a.every((v, i) => deepEquals(v, b[i]));
  if (a instanceof Map) {
    if (a.size !== b.size) return false;
    for (const [k, v] of a) if (!b.has(k) || !deepEquals(v, b.get(k))) return false;
    return true;
  }
  if (a instanceof Set) {
    if (a.size !== b.size) return false;
    for (const v of a) if (!b.has(v)) return false;
    return true;
  }
  const keys = Object.keys(a);
  if (keys.length !== Object.keys(b).length) return false;
  return keys.every((k) => Object.hasOwn(b, k) && deepEquals(a[k], b[k]));
};

const joined = '2022-05-01T00:00:00.000Z';
const left = { name: 'Chidi', lga: 'Surulere', roles: ['rider', 'lead'], meta: { tier: 2, since: new Date(joined) } };
const right = { name: 'Chidi', lga: 'Surulere', roles: ['rider', 'lead'], meta: { tier: 2, since: new Date(joined) } };
const reordered = { lga: 'Surulere', meta: { since: new Date(joined), tier: 2 }, roles: ['rider', 'lead'], name: 'Chidi' };
const oneLeafOff = { ...right, meta: { ...right.meta, tier: 3 } };
const arrayLike = { 0: 'rider', 1: 'lead', length: 2 };

const stockA = new Map([['GRP-1', 2], ['GRP-2', 5]]);
const stockB = new Map([['GRP-2', 5], ['GRP-1', 2]]);
const stockShort = new Map([['GRP-1', 2]]);
const zonesA = new Set(['ikeja', 'yaba', 'lekki']);
const zonesB = new Set(['lekki', 'yaba', 'ikeja']);

const withUndefined = { id: 'AC-9', otp: undefined };
const withoutOtp = { id: 'AC-9' };

console.log('same data   :', deepEquals(left, right), '| same object:', left === right);
console.log('key order   :', deepEquals(right, reordered), '| one leaf off:', deepEquals(left, oneLeafOff));
console.log('collections :', deepEquals(stockA, stockB), deepEquals(zonesA, zonesB));
console.log('undefined   :', deepEquals(withUndefined, withoutOtp), '| JSON says:', same(withUndefined, withoutOtp));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55const deepClone = (value, seen = new WeakMap()) => {
  if (value === null || typeof value !== 'object') return value;   // primitives and functions
  if (seen.has(value)) return seen.get(value);                     // the cycle stops here
  if (value instanceof Date) return new Date(value.getTime());
  if (value instanceof Map) {
    const copy = new Map();
    seen.set(value, copy);
    for (const [k, v] of value) copy.set(deepClone(k, seen), deepClone(v, seen));
    return copy;
  }
  if (value instanceof Set) {
    const copy = new Set();
    seen.set(value, copy);
    for (const v of value) copy.add(deepClone(v, seen));
    return copy;
  }
  const copy = Array.isArray(value) ? [] : {};
  seen.set(value, copy);                                           // BEFORE filling it
  for (const [k, v] of Object.entries(value)) copy[k] = deepClone(v, seen);
  return copy;
};

const REF = Symbol('internal ref');
const vendor = {
  name: 'Ngozi Traders',
  stock: [{ sku: 'GRP-1', units: 12 }, { sku: 'GRP-2', units: 3 }],
  joined: new Date('2023-02-14T00:00:00.000Z'),
  tags: new Set(['wholesale', 'verified']),
  prices: new Map([['GRP-1', 4500]]),
  greet() { return 'Nno'; },
};
vendor[REF] = 'v-01';

const copy = deepClone(vendor);
const unitsBefore = copy.stock[0].units;
copy.stock[0].units = 99;
const unitsInCopy = copy.stock[0].units;
const unitsInOriginal = vendor.stock[0].units;

const branch = { name: 'Onitsha', parent: null };
const chain = { name: 'HQ', branches: [branch] };
branch.parent = chain;                                             // the cycle
const chainCopy = deepClone(chain);

const shared = { vat: 0.075 };
const twice = { retail: shared, wholesale: shared };
const twiceCopy = deepClone(twice);

let jsonError = 'no error';
try { JSON.stringify(chain); } catch (e) { jsonError = e.constructor.name; }

console.log('deep copy :', copy.name, copy.stock, '| original:', vendor.stock[0].units);
console.log('cycle     :', chainCopy.branches[0].parent === chainCopy);
console.log('alias     :', twiceCopy.retail === twiceCopy.wholesale);
console.log('JSON      :', jsonError);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44const looksLikeIndex = (key) => String(Number(key)) === String(key) && Number(key) >= 0;

const getPath = (obj, path, fallback) => {
  const keys = Array.isArray(path) ? path : String(path).split('.');
  let cursor = obj;
  for (const key of keys) {
    if (cursor === null || cursor === undefined) return fallback;
    cursor = cursor[key];
  }
  return cursor === undefined ? fallback : cursor;
};

const setPath = (obj, path, value) => {
  const keys = Array.isArray(path) ? [...path] : String(path).split('.');
  const leaf = keys.pop();
  let cursor = obj;
  for (const [i, key] of keys.entries()) {
    const next = cursor[key];
    if (next === null || typeof next !== 'object') {
      cursor[key] = looksLikeIndex(keys[i + 1] ?? leaf) ? [] : {};
    }
    cursor = cursor[key];
  }
  cursor[leaf] = value;
  return obj;
};

const order = {
  id: 'ORD-771',
  buyer: { name: 'Amaka', address: { lga: 'Yaba', city: 'Lagos' } },
  lines: [{ sku: 'GRP-1', units: 2 }, { sku: 'GRP-2', units: 1 }],
};
const hollow = { a: { b: undefined } };
const odd = { 'buyer.name': 'Ngozi' };

const built = setPath({}, 'vendor.contact.phone', '0803 000 0000');
const withArray = setPath({}, 'lines.0.sku', 'GRP-9');
const target = { buyer: { address: { lga: 'Yaba' } } };
const returned = setPath(target, 'buyer.address.lga', 'Surulere');

console.log('get    :', getPath(order, 'buyer.address.lga'), '| missing:', getPath(order, 'buyer.bank.name', 'unknown'));
console.log('index  :', getPath(order, 'lines.1.sku'));
console.log('built  :', built, '| array:', withArray);
console.log('dotted key:', getPath(odd, 'buyer.name', 'missing'), getPath(odd, ['buyer.name'], 'missing'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32const pick = (source, keys) =>
  Object.fromEntries(keys.filter((k) => k in source).map((k) => [k, source[k]]));

const omit = (source, keys) =>
  Object.fromEntries(Object.entries(source).filter(([k]) => !keys.includes(k)));

const pickBy = (source, keep) =>
  Object.fromEntries(Object.entries(source).filter(([k, v]) => keep(v, k)));

const invert = (source) =>
  Object.fromEntries(Object.entries(source).map(([k, v]) => [v, k]));

const account = { id: 'AC-9', name: 'Bisi Adeyemi', bank: 'GTBank', balance: 48500, pin: '1234', otp: null };

const publicView = pick(account, ['name', 'bank']);
const withAbsentKey = pick(account, ['name', 'nin']);
const withoutSecrets = omit(account, ['pin', 'otp']);
const keysStillThere = Object.keys(account).length;
const filled = pickBy(account, (value) => value !== null);

const { pin, otp, ...rest } = account;
const restMatchesOmit = same(rest, withoutSecrets);

const zones = invert({ lekki: 'zone-a', ikeja: 'zone-b' });
const collapsed = invert({ ada: 'north', obi: 'north' });
const numbered = invert({ lekki: 1, ikeja: 2 });
const roundTrip = invert(numbered);

console.log('pick   :', publicView, '| absent key:', Object.keys(withAbsentKey));
console.log('omit   :', withoutSecrets, '| original keys:', keysStillThere);
console.log('invert :', zones, '| duplicates:', collapsed);
console.log('numbers:', numbered, '| back again:', roundTrip);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50const keyFn = (key) => (typeof key === 'function' ? key : (item) => item[key]);

const groupBy = (items, key) => {
  const of = keyFn(key);
  const out = new Map();
  for (const item of items) {
    const k = of(item);
    if (!out.has(k)) out.set(k, []);
    out.get(k).push(item);
  }
  return out;
};

const countBy = (items, key) => {
  const of = keyFn(key);
  const out = new Map();
  for (const item of items) {
    const k = of(item);
    out.set(k, (out.get(k) ?? 0) + 1);
  }
  return out;
};

const indexBy = (items, key) => {
  const of = keyFn(key);
  return new Map(items.map((item) => [of(item), item]));
};

const riders = [
  { name: 'Chidi', lga: 'Yaba', trips: 41 },
  { name: 'Amaka', lga: 'Ikeja', trips: 12 },
  { name: 'Bisi', lga: 'Yaba', trips: 33 },
  { name: 'Tunde', lga: 'Ikeja', trips: 12 },
  { name: 'Ngozi', lga: 'Surulere', trips: 7 },
];

const names = (list) => list.map((r) => r.name);
const byLga = [...groupBy(riders, 'lga')].map(([k, v]) => [k, names(v)]);
const byBand = [...groupBy(riders, (r) => (r.trips >= 30 ? 'busy' : 'quiet'))].map(([k, v]) => [k, names(v)]);
const perLga = [...countBy(riders, 'lga')];
const perTripCount = [...countBy(riders, 'trips')];
const numericKeyType = typeof [...countBy(riders, 'trips').keys()][0];
const lastPerLga = indexBy(riders, 'lga');
const asObject = Object.fromEntries(countBy(riders, 'trips'));
const boolKeys = [...groupBy(riders, (r) => r.trips > 20).keys()];

console.log('by lga  :', byLga);
console.log('by band :', byBand);
console.log('counts  :', perLga, '| by trips:', perTripCount);
console.log('indexed :', [...lastPerLga.keys()], '| Yaba ->', lastPerLga.get('Yaba').name);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47const chunk = (items, size) => {
  if (!Number.isInteger(size) || size < 1) throw new RangeError('size must be a positive integer');
  const out = [];
  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
  return out;
};

const zip = (...lists) => {
  const length = Math.min(...lists.map((l) => l.length));           // stop at the shortest
  return Array.from({ length }, (_, i) => lists.map((l) => l[i]));
};

const zipLong = (...lists) => {
  const length = Math.max(...lists.map((l) => l.length));           // pad instead
  return Array.from({ length }, (_, i) => lists.map((l) => l[i] ?? null));
};

const unzip = (rows) => zip(...rows);

const partition = (items, keep) => {
  const yes = [];
  const no = [];
  for (const item of items) (keep(item) ? yes : no).push(item);
  return [yes, no];
};

const skus = ['GRP-1', 'GRP-2', 'GRP-3', 'GRP-4', 'GRP-5'];
const units = [12, 3, 40, 7, 25];
const shelves = ['A1', 'A2'];

const pages = chunk(skus, 2);
const exact = chunk(skus.slice(0, 4), 2);
const emptyChunked = chunk([], 3);
const rows = zip(skus, units);
const backAgain = unzip(rows);
const short = zip(skus, shelves);
const padded = zipLong(shelves, units);
const [plenty, scarce] = partition(units, (n) => n >= 10);
const [none, alsoNone] = partition([], (n) => n > 0);

let badSize = 'no error';
try { chunk(skus, 0); } catch (e) { badSize = e.constructor.name; }

console.log('chunk    :', pages);
console.log('zip      :', rows.slice(0, 2), '| shortest wins:', short.length);
console.log('unzip    :', backAgain);
console.log('partition:', plenty, scarce, '| bad size:', badSize);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41const uniq = (items) => [...new Set(items)];

const uniqBy = (items, key) => {
  const of = typeof key === 'function' ? key : (item) => item[key];
  const seen = new Set();
  const out = [];
  for (const item of items) {
    const k = of(item);
    if (!seen.has(k)) {
      seen.add(k);
      out.push(item);
    }
  }
  return out;
};

const payments = [
  { ref: 'PX-1', phone: '0803 111 2222', amount: 5000 },
  { ref: 'PX-2', phone: '08031112222', amount: 5000 },
  { ref: 'PX-3', phone: '0805 333 4444', amount: 1500 },
  { ref: 'PX-4', phone: '0803 111 2222', amount: 7000 },
];
const digitsOnly = (text) => [...text].filter((c) => c !== ' ').join('');
const refs = (list) => list.map((p) => p.ref);

const plain = uniq(['yaba', 'ikeja', 'yaba', 'lekki', 'ikeja']);
const nanCount = uniq([NaN, NaN, NaN]).length;
const indexOfNaN = [NaN].indexOf(NaN);
const zeroCount = uniq([0, -0]).length;
const looseCount = uniq(['1', 1]).length;
const objectCount = uniq([{ lga: 'Yaba' }, { lga: 'Yaba' }]).length;

const byPhone = refs(uniqBy(payments, 'phone'));
const byNormalised = refs(uniqBy(payments, (p) => digitsOnly(p.phone)));
const keptAmounts = uniqBy(payments, 'phone').map((p) => p.amount);
const byPair = refs(uniqBy(payments, (p) => `${digitsOnly(p.phone)}|${p.amount}`));

console.log('uniq      :', plain);
console.log('NaN       :', nanCount, '| indexOf says:', indexOfNaN);
console.log('by phone  :', byPhone, '| normalised:', byNormalised);
console.log('by pair   :', byPair);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48const byKey = (key, direction = 'asc') => {
  const of = typeof key === 'function' ? key : (item) => item[key];
  const sign = direction === 'desc' ? -1 : 1;
  return (a, b) => {
    const x = of(a);
    const y = of(b);
    return (x < y ? -1 : x > y ? 1 : 0) * sign;
  };
};

const then = (...comparators) => (a, b) => {
  for (const compare of comparators) {
    const answer = compare(a, b);
    if (answer !== 0) return answer;
  }
  return 0;
};

const stalls = [
  { stall: 'A12', market: 'Balogun', takings: 12000 },
  { stall: 'B03', market: 'Alaba', takings: 30000 },
  { stall: 'A07', market: 'Balogun', takings: 30000 },
  { stall: 'C21', market: 'Alaba', takings: 9000 },
];
const ids = (list) => list.map((s) => s.stall);

const byTakings = ids([...stalls].sort(byKey('takings')));
const byTakingsDesc = ids([...stalls].sort(byKey('takings', 'desc')));
const grouped = ids([...stalls].sort(then(byKey('market'), byKey('takings', 'desc'))));
const byNameLength = ids([...stalls].sort(byKey((s) => s.market.length)));

const inPlace = [...stalls];
const returnedSame = inPlace.sort(byKey('takings')) === inPlace;
const originalUntouched = stalls[0].stall;

const asText = [10, 9, 100].sort();
const codeUnits = ['ada', 'Zainab', 'bola'].sort(byKey((s) => s));
const withLocale = ['ada', 'Zainab', 'bola'].sort((a, b) => a.localeCompare(b, 'en'));

const boolish = (a, b) => a > b;
const bothWays = [Number(boolish(1, 2)), Number(boolish(2, 1))];
const subtractive = (a, b) => a - b;
const onStrings = subtractive('bola', 'ada');

console.log('takings :', byTakings, '| desc:', byTakingsDesc);
console.log('grouped :', grouped);
console.log('default :', asText, '| code units:', codeUnits, '| locale:', withLocale);
console.log('boolean :', bothWays, '| subtraction on text:', onStrings);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42const byScore = (a, b) => a.score - b.score;
const names = (list) => list.map((e) => e.name);

const entries = [
  { name: 'Chidi', score: 70 },
  { name: 'Amaka', score: 85 },
  { name: 'Bisi', score: 70 },
  { name: 'Tunde', score: 85 },
  { name: 'Ngozi', score: 61 },
];

const ascending = names([...entries].sort(byScore));

// The pre-2019 workaround: carry the original index and use it as the last word.
const decorated = names(
  entries
    .map((item, i) => ({ item, i }))
    .sort((a, b) => byScore(a.item, b.item) || a.i - b.i)
    .map(({ item }) => item)
);
const trickIsRedundant = same(ascending, decorated);

const upThenReversed = names([...entries].sort(byScore).reverse());
const straightDown = names([...entries].sort((a, b) => byScore(b, a)));

// A comparator that never returns 0 claims both orders at once.
const never0 = (a, b) => (a.score < b.score ? -1 : 1);
const contradiction = [never0(entries[0], entries[2]), never0(entries[2], entries[0])];

let sawUndefined = false;
const counting = (a, b) => {
  if (a === undefined || b === undefined) sawUndefined = true;
  return a - b;
};
const withHole = [3, undefined, 1].sort(counting).map((v) => (v === undefined ? 'undefined' : v));

const allEqual = names([...entries].sort(() => 0));

console.log('ascending :', ascending);
console.log('decorated :', decorated, '| redundant:', trickIsRedundant);
console.log('reversed  :', upThenReversed);
console.log('descending:', straightDown);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48function* range(start, stop, step = 1) {
  if (stop === undefined) {
    stop = start;
    start = 0;
  }
  if (step === 0) throw new RangeError('step must not be 0');
  if (step > 0) for (let i = start; i < stop; i += step) yield i;
  else for (let i = start; i > stop; i += step) yield i;
}

const sum = (iterable) => {
  let total = 0;
  for (const n of iterable) total += n;
  return total;
};

const mean = (iterable) => {
  let total = 0;
  let count = 0;
  for (const n of iterable) {
    total += n;
    count++;
  }
  return count === 0 ? NaN : total / count;
};

const fiveDays = [...range(5)];
const midweek = [...range(2, 6)];
const countdown = [...range(10, 0, -2)];
const wrongWay = [...range(0, 5, -1)];

const takings = [4500, 12000, 9000, 30000];
const asSet = new Set(takings);
const asMap = new Map([['A12', 4500], ['B03', 12000], ['A07', 9000], ['C21', 30000]]);
const fourWays = [sum(takings), sum(asSet), sum(asMap.values()), sum(range(1, 4))];
const average = mean(takings);
const emptySum = sum([]);
const emptyMean = mean([]);
const drift = sum([0.1, 0.2]);

const lazy = range(0, 5, 0);                 // the body has not run yet
let onIteration = 'no error';
try { [...lazy]; } catch (e) { onIteration = e.constructor.name; }

console.log('range   :', fiveDays, midweek, countdown);
console.log('sum     :', fourWays, '| mean:', average);
console.log('empty   :', emptySum, emptyMean);
console.log('step 0  :', typeof lazy.next, '->', onIteration);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59function* naturals() {
  let n = 1;
  while (true) yield n++;   // endless on purpose: only take() decides when to stop
}

function* metered(iterable, meter) {
  for (const value of iterable) {
    meter.count++;
    yield value;
  }
}

function* lazyMap(fn, iterable) {
  for (const value of iterable) yield fn(value);
}

function* lazyFilter(keep, iterable) {
  for (const value of iterable) if (keep(value)) yield value;
}

function* take(n, iterable) {
  if (n <= 0) return;
  let left = n;
  for (const value of iterable) {
    yield value;
    if (--left === 0) return;   // stop PULLING, not just stop yielding
  }
}

const meter = { count: 0 };
const squaresOfThrees = take(4, lazyMap((n) => n * n, lazyFilter((n) => n % 3 === 0, metered(naturals(), meter))));
const firstFour = [...squaresOfThrees];
const pulled = meter.count;

const zeroMeter = { count: 0 };
const nothing = [...take(0, metered(naturals(), zeroMeter))];
const pulledForNothing = zeroMeter.count;

const oneShot = take(3, naturals());
const firstPass = [...oneShot];
const secondPass = [...oneShot];
const freshRun = [...take(3, naturals())];

const shortSource = [...take(10, ['GRP-1', 'GRP-2', 'GRP-3'])];
const eager = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].filter((n) => n % 3 === 0).map((n) => n * n);

const stallRow = {
  from: 3,
  to: 6,
  *[Symbol.iterator]() {
    for (let i = this.from; i <= this.to; i++) yield i;
  },
};
const spread = [...stallRow];

console.log('first four :', firstFour, '| source values pulled:', pulled);
console.log('take(0)    :', nothing, '| pulled:', pulledForNothing);
console.log('one shot   :', firstPass, 'then', secondPass);
console.log('custom     :', spread);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57const before = (n, fn) => {
  let calls = 0;
  let last;
  return (...args) => {
    calls++;
    if (calls < n) last = fn(...args);
    return last;
  };
};

const after = (n, fn) => {
  let calls = 0;
  return (...args) => {
    calls++;
    return calls >= n ? fn(...args) : undefined;
  };
};

let discounts = 0;
const applyDiscount = (amount) => {
  discounts++;
  return Math.round(amount * 0.9);
};
const firstTwoOrders = before(3, applyDiscount);
const prices = [firstTwoOrders(10000), firstTwoOrders(20000), firstTwoOrders(30000), firstTwoOrders(40000)];
const discountsRun = discounts;

let alerts = 0;
const raiseAlert = (reason) => {
  alerts++;
  return `alert: ${reason}`;
};
const afterThree = after(3, raiseAlert);
const outcomes = [afterThree('timeout'), afterThree('timeout'), afterThree('declined'), afterThree('bounced')].map((v) => v ?? 'quiet');
const alertsRun = alerts;

let charges = 0;
const charge = (amount) => {
  charges++;
  return amount;
};
const onceLike = before(2, charge);
const onceResults = [onceLike(500), onceLike(900), onceLike(1300)];
const chargesAfterOnce = charges;

const perOrder = before(2, charge);
const perRider = before(2, charge);
const twoWrappers = [perOrder(1), perRider(2)];
const chargesTotal = charges;

const swallowed = after(2, () => 'ran')('first call');
const swallowedShape = [swallowed === undefined, JSON.stringify([swallowed])];

console.log('before(3) :', prices, '| real calls:', discountsRun);
console.log('after(3)  :', outcomes, '| real calls:', alertsRun);
console.log('once      :', onceResults, '| real calls:', chargesAfterOnce);
console.log('swallowed :', swallowedShape);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44const isPlain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);

const deepMerge = (base, override) => {
  const out = { ...base };
  for (const [key, value] of Object.entries(override)) {
    if (isPlain(value) && isPlain(out[key])) out[key] = deepMerge(out[key], value);
    else if (value !== undefined) out[key] = value;      // undefined means "no opinion"
  }
  return out;
};

const fillMissing = (target, fallbacks) => {
  const out = { ...target };
  for (const [key, value] of Object.entries(fallbacks)) out[key] ??= value;
  return out;
};

const shipped = {
  currency: 'NGN',
  delivery: { fee: 1500, zones: ['Yaba', 'Ikeja'], window: { open: '09:00', close: '18:00' } },
  retries: 3,
};
const tenant = {
  delivery: { fee: 2000, window: { close: '20:00' } },
  retries: undefined,
};

const merged = deepMerge(shipped, tenant);
const shallow = { ...shipped, ...tenant };
const withZones = deepMerge(shipped, { delivery: { zones: ['Lekki'] } });
const baseFeeStillThere = shipped.delivery.fee;
const branchIsNew = merged.delivery === shipped.delivery;
const zonesAreShared = merged.delivery.zones === shipped.delivery.zones;

const spreadDefaults = { ...{ fee: 1500, currency: 'USD' }, ...{ fee: undefined, currency: 'NGN' } };
const filledDefaults = fillMissing({ fee: undefined, currency: 'NGN' }, { fee: 1500, currency: 'USD' });

const risky = deepMerge({}, JSON.parse('{"__proto__":{"surcharge":9999}}'));
const pollution = [Object.hasOwn(risky, '__proto__'), risky.surcharge, JSON.stringify(risky), ({}).surcharge === undefined];

console.log('merged  :', merged);
console.log('shallow :', shallow);
console.log('defaults:', spreadDefaults, '| filled:', filledDefaults);
console.log('proto   :', pollution);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77class Emitter {
  #handlers = new Map();

  on(event, handler) {
    if (!this.#handlers.has(event)) this.#handlers.set(event, new Set());
    this.#handlers.get(event).add(handler);
    return () => this.off(event, handler);          // an unsubscribe, not a boolean
  }

  once(event, handler) {
    const wrapped = (...args) => {
      this.off(event, wrapped);
      handler(...args);
    };
    return this.on(event, wrapped);
  }

  off(event, handler) {
    const set = this.#handlers.get(event);
    if (!set) return false;
    const removed = set.delete(handler);
    if (set.size === 0) this.#handlers.delete(event);
    return removed;
  }

  emit(event, ...args) {
    const set = this.#handlers.get(event);
    if (!set) return 0;
    let called = 0;
    for (const handler of [...set]) {               // a copy, so growth waits its turn
      handler(...args);
      called++;
    }
    return called;
  }

  count(event) {
    return this.#handlers.get(event)?.size ?? 0;
  }
}

const log = [];
const bus = new Emitter();
const offReceipt = bus.on('paid', (ref, amount) => log.push(`receipt ${ref} ${amount}`));
bus.on('paid', (ref) => log.push(`ledger ${ref}`));
const firstEmit = bus.emit('paid', 'ORD-771', 4500);

offReceipt();
const secondEmit = bus.emit('paid', 'ORD-772', 900);
const noHandlers = bus.emit('refunded', 'ORD-773');

bus.once('shipped', (ref) => log.push(`sms ${ref}`));
const onceFirst = bus.emit('shipped', 'ORD-771');
const onceSecond = bus.emit('shipped', 'ORD-772');
const shippedLeft = bus.count('shipped');

const audit = (ref) => log.push(`audit ${ref}`);
bus.on('closed', audit);
bus.on('closed', audit);
const closedCount = bus.count('closed');
const closedCalls = bus.emit('closed', 'ORD-771');

const removedUnknown = bus.off('paid', () => {});
const paidLeft = bus.count('paid');

let lateCalls = 0;
const grower = new Emitter();
grower.on('tick', () => grower.on('tick', () => { lateCalls++; }));
const firstTick = grower.emit('tick');
const secondTick = grower.emit('tick');

const shape = [Object.keys(bus).length, JSON.stringify(bus)];

console.log('log     :', log);
console.log('emits   :', firstEmit, secondEmit, noHandlers);
console.log('once    :', onceFirst, onceSecond, '| left:', shippedLeft);
console.log('growth  :', firstTick, secondTick, '| late calls:', lateCalls);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70class LruCache {
  #max;
  #items = new Map();

  constructor(max) {
    if (!Number.isInteger(max) || max < 1) throw new RangeError('max must be a positive integer');
    this.#max = max;
  }

  get(key) {
    if (!this.#items.has(key)) return undefined;
    const value = this.#items.get(key);
    this.#items.delete(key);            // a read is a use: move it to the newest end
    this.#items.set(key, value);
    return value;
  }

  set(key, value) {
    if (this.#items.has(key)) this.#items.delete(key);
    this.#items.set(key, value);
    if (this.#items.size > this.#max) {
      const oldest = this.#items.keys().next().value;
      this.#items.delete(oldest);
    }
    return this;
  }

  has(key) {
    return this.#items.has(key);        // deliberately NOT a use
  }

  get size() {
    return this.#items.size;
  }

  keys() {
    return [...this.#items.keys()];     // oldest first
  }
}

const quotes = new LruCache(3);
quotes.set('yaba-ikeja', 1500).set('lekki-vi', 2500).set('ojota-ikeja', 1800);
const orderBefore = quotes.keys();

const hit = quotes.get('yaba-ikeja');
const orderAfterRead = quotes.keys();

quotes.set('surulere-yaba', 900);
const orderAfterEvict = quotes.keys();
const evictedRead = quotes.get('lekki-vi') === undefined;
const sizeCapped = quotes.size;

quotes.set('ojota-ikeja', 2000);
const orderAfterUpdate = quotes.keys();
const sizeAfterUpdate = quotes.size;

const present = quotes.has('yaba-ikeja');
const orderAfterHas = quotes.keys();

quotes.set('kano-kaduna', undefined);
const holdsUndefined = [quotes.has('kano-kaduna'), quotes.get('kano-kaduna') === undefined, quotes.has('nowhere')];
const finalKeys = quotes.keys();

let badMax = 'no error';
try { new LruCache(0); } catch (e) { badMax = e.constructor.name; }

console.log('inserted :', orderBefore);
console.log('after read:', orderAfterRead, '| hit:', hit);
console.log('evicted  :', orderAfterEvict, '| size:', sizeCapped);
console.log('final    :', finalKeys, '| bad max:', badMax);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44const segments = (path) => (Array.isArray(path) ? path : String(path).split('.'));

const setIn = (target, path, value) => {
  const [head, ...rest] = segments(path);
  if (head === undefined) return value;                       // the base case: replace it all
  const nested = rest.length ? setIn(target?.[head] ?? {}, rest, value) : value;
  if (Array.isArray(target)) {
    const copy = [...target];
    copy[Number(head)] = nested;
    return copy;
  }
  return { ...target, [head]: nested };
};

const getIn = (target, path) => segments(path).reduce((acc, key) => acc?.[key], target);
const updateIn = (target, path, fn) => setIn(target, path, fn(getIn(target, path)));

const state = {
  user: { name: 'Amaka', address: { lga: 'Yaba', city: 'Lagos' } },
  cart: { items: [{ sku: 'GRP-1', units: 2 }, { sku: 'GRP-2', units: 1 }], note: 'gate 3' },
};

const moved = setIn(state, 'user.address.lga', 'Surulere');
const pathIsNew = [moved !== state, moved.user !== state.user, moved.user.address !== state.user.address];
const restIsShared = [moved.cart === state.cart, moved.user.name === state.user.name];

const restocked = setIn(state, 'cart.items.0.units', 5);
const arrayShape = [Array.isArray(restocked.cart.items), restocked.cart.items[0].units, state.cart.items[0].units];
const otherItemShared = restocked.cart.items[1] === state.cart.items[1];

const bumped = updateIn(state, 'cart.items.0.units', (n) => n + 10);
const created = setIn(state, 'user.bank.name', 'GTBank');

const frozen = Object.freeze({ vendor: { name: 'Ngozi Traders' }, tier: 1 });
const promoted = setIn(frozen, 'tier', 2);
let writeError = 'no error';
try { frozen.tier = 2; } catch (e) { writeError = e.constructor.name; }

const wholesale = setIn(state, [], 'replaced entirely');

console.log('moved  :', moved.user.address, '| original:', state.user.address);
console.log('shared :', restIsShared, '| path copied:', pathIsNew);
console.log('array  :', arrayShape, '| sibling shared:', otherItemShared);
console.log('frozen :', promoted.tier, frozen.tier, writeError);