JavaScript: Fundamental (ES6), part 1, 107–136

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
62class Result {
  #ok;
  #value;
  #error;

  constructor(ok, value, error) {
    this.#ok = ok;
    this.#value = value;
    this.#error = error;
  }

  static ok(value) { return new Result(true, value, undefined); }
  static err(error) { return new Result(false, undefined, error); }

  get isOk() { return this.#ok; }

  map(fn) { return this.#ok ? Result.ok(fn(this.#value)) : this; }
  mapErr(fn) { return this.#ok ? this : Result.err(fn(this.#error)); }
  andThen(fn) { return this.#ok ? fn(this.#value) : this; }
  unwrapOr(fallback) { return this.#ok ? this.#value : fallback; }
  match(handlers) { return this.#ok ? handlers.ok(this.#value) : handlers.err(this.#error); }

  toJSON() { return this.#ok ? { ok: true, value: this.#value } : { ok: false, error: this.#error }; }
}

const parseAmount = (text) => {
  const n = Number(text);
  if (text.trim() === '' || Number.isNaN(n)) return Result.err(`not a number: ${text}`);
  if (n <= 0) return Result.err('amount must be positive');
  return Result.ok(n);
};
const withinLimit = (n) => (n <= 50000 ? Result.ok(n) : Result.err('above the single-transfer limit'));

let conversions = 0;
const toKobo = (n) => {
  conversions++;
  return n * 100;
};

const good = parseAmount('4500').andThen(withinLimit).map(toKobo);
const tooBig = parseAmount('90000').andThen(withinLimit).map(toKobo);
const notANumber = parseAmount('abeg').andThen(withinLimit).map(toKobo);
const negative = parseAmount('-5');
const conversionsRun = conversions;

const failed = parseAmount('abeg');
const mapWasSkipped = failed.map(toKobo) === failed;
const shouted = failed.mapErr((e) => e.toUpperCase());
const untouched = good.mapErr((e) => e.toUpperCase()) === good;

const fallbacks = [good.unwrapOr(0), notANumber.unwrapOr(0)];
const messages = [good, tooBig].map((r) => r.match({ ok: (n) => `transfer ${n} kobo`, err: (e) => `declined: ${e}` }));

class Bare {
  #hidden = 'nothing to see';
}
const bareShape = JSON.stringify(new Bare());

console.log('good    :', JSON.stringify(good), '| too big:', JSON.stringify(tooBig));
console.log('skipped :', conversionsRun, 'conversions for four chains');
console.log('messages:', messages);
console.log('bare    :', bareShape);

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
65const memoByObject = (fn) => {
  const cache = new WeakMap();
  return (subject) => {
    if (cache.has(subject)) return cache.get(subject);
    const value = fn(subject);
    cache.set(subject, value);
    return value;
  };
};

let computations = 0;
const totalOf = (invoice) => {
  computations++;
  return invoice.lines.reduce((sum, line) => sum + line.units * line.price, 0);
};
const cachedTotal = memoByObject(totalOf);

const invoice = { ref: 'INV-9', lines: [{ units: 2, price: 4500 }, { units: 1, price: 1800 }] };
const twin = { ref: 'INV-9', lines: [{ units: 2, price: 4500 }, { units: 1, price: 1800 }] };

const first = cachedTotal(invoice);
const again = cachedTotal(invoice);
const callsAfterRepeat = computations;
const forTwin = cachedTotal(twin);
const callsAfterTwin = computations;

invoice.lines[0].units = 5;                 // the object changed; the cache did not notice
const stale = cachedTotal(invoice);
const truth = totalOf(invoice);
const callsAfterMutation = computations;

const secondMemo = memoByObject(totalOf);
const recomputed = secondMemo(invoice);
const callsAfterSecondMemo = computations;

let zeroCalls = 0;
const emptyTotal = memoByObject((inv) => {
  zeroCalls++;
  return inv.lines.length;
});
const empty = { ref: 'INV-0', lines: [] };
const zeros = [emptyTotal(empty), emptyTotal(empty), zeroCalls];

const weak = new WeakMap();
let keyError = 'no error';
try { weak.set('INV-9', 1); } catch (e) { keyError = e.constructor.name; }
const primitiveLookup = weak.has('INV-9');
const surface = [typeof weak.size, typeof weak.keys, typeof weak.forEach];

const strong = new Map();
strong.set({ ref: 'INV-1' }, 'held for ever');
const strongHolds = [...strong.keys()].length;

const secrets = new WeakMap();
class Wallet {
  constructor(pin) { secrets.set(this, { pin }); }
  matches(guess) { return secrets.get(this).pin === guess; }
}
const wallet = new Wallet('1234');
const walletShape = [JSON.stringify(wallet), Object.keys(wallet).length, wallet.matches('1234'), wallet.matches('0000')];

console.log('cached   :', first, again, '| calls:', callsAfterRepeat);
console.log('twin     :', forTwin, '| calls:', callsAfterTwin);
console.log('stale    :', stale, 'but the truth is', truth);
console.log('weakmap  :', keyError, primitiveLookup, surface);

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 guarded = (target, rules) =>
  new Proxy(target, {
    set(obj, key, value) {
      const rule = rules[key];
      if (!rule) throw new TypeError(`unknown field: ${String(key)}`);
      if (!rule.check(value)) throw new TypeError(`${String(key)}: ${rule.why}`);
      return Reflect.set(obj, key, value);
    },
    deleteProperty(obj, key) {
      throw new TypeError(`${String(key)} cannot be removed`);
    },
  });

const rules = {
  name: { check: (v) => typeof v === 'string' && v.length > 0, why: 'must be a non-empty string' },
  balanceKobo: { check: (v) => Number.isInteger(v) && v >= 0, why: 'must be a whole, non-negative number of kobo' },
  lga: { check: (v) => ['Yaba', 'Ikeja', 'Eti-Osa'].includes(v), why: 'must be a serviced LGA' },
};

const raw = { name: 'Ngozi Traders', balanceKobo: 450000, lga: 'Yaba' };
const account = guarded(raw, rules);

account.balanceKobo = 500000;
const accepted = [account.balanceKobo, raw.balanceKobo];

let rangeMessage = 'no error';
try { account.balanceKobo = -1; } catch (e) { rangeMessage = e.message; }
const afterReject = raw.balanceKobo;

let unknownMessage = 'no error';
try { account.blance = 1; } catch (e) { unknownMessage = e.message; }
const keyCountAfterTypo = Object.keys(raw).length;

let deleteMessage = 'no error';
try { delete account.lga; } catch (e) { deleteMessage = e.message; }

const readThrough = [account.name, account.lga, Object.keys(account)];

raw.balanceKobo = -999;                       // straight past the door
const bypassed = [account.balanceKobo, raw.balanceKobo];

const readOnly = new Proxy({ tier: 1 }, { set: () => false });
let refusal = 'no error';
try { readOnly.tier = 2; } catch (e) { refusal = e.constructor.name; }

console.log('accepted :', accepted);
console.log('rejected :', rangeMessage, '| target still:', afterReject);
console.log('unknown  :', unknownMessage, '| delete:', deleteMessage);
console.log('bypass   :', bypassed, '| false trap:', refusal);

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 withDefaults = (target, fallback) =>
  new Proxy(target, {
    get(obj, key, receiver) {
      if (Object.hasOwn(obj, key)) return Reflect.get(obj, key, receiver);
      return typeof fallback === 'function' ? fallback(key) : fallback;
    },
  });

const salesByDay = { mon: 12000, tue: 9000 };
const sales = withDefaults(salesByDay, 0);
const named = withDefaults(salesByDay, (key) => `no sales for ${String(key)}`);

const present = sales.mon;
const missing = sales.sun;
const explained = named.sun;
const inDisagrees = ['sun' in sales, sales.sun];
const stillHonest = [Object.keys(sales), JSON.stringify(sales), { ...sales }];

const basket = {
  units: 3,
  price: 4500,
  get subtotal() { return this.units * this.price; },
  get total() { return this.subtotal + this.deliveryFee; },   // deliveryFee is not here
};
const tally = withDefaults(basket, 0);
const noReceiver = new Proxy(basket, {
  get(obj, key) {
    return Object.hasOwn(obj, key) ? Reflect.get(obj, key) : 0;   // receiver dropped
  },
});

const throughProxy = [tally.subtotal, tally.total];
const straightAtTheObject = Number.isNaN(basket.total);
const withoutReceiver = Number.isNaN(noReceiver.total);

const reflectBasics = [Reflect.get(salesByDay, 'mon'), Reflect.has(salesByDay, 'sun'), Reflect.ownKeys({ a: 1, b: 2 })];

console.log('defaults :', present, missing, '| named:', explained);
console.log('in says  :', inDisagrees, '| keys:', stillHonest[0]);
console.log('receiver :', throughProxy);
console.log('without  :', withoutReceiver, '| direct:', straightAtTheObject);

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/* A clock you drive by hand. advance() drains pending microtasks BEFORE moving the
   time, so work that is about to register its next wait does so against the right now. */
const makeClock = () => {
  let now = 0;
  let seq = 0;
  const timers = [];
  const drainMicrotasks = async () => {
    for (let i = 0; i < 50; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait: (ms) => new Promise((resolve) => timers.push({ at: now + ms, seq: seq++, resolve })),
    async runAll() {
      await drainMicrotasks();
      while (timers.length) {
        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
        const next = timers.shift();
        now = next.at;
        next.resolve();
        await drainMicrotasks();
      }
      return now;
    },
  };
};

const mapLimit = async (items, limit, worker) => {
  const results = new Array(items.length);
  let cursor = 0;
  const runner = async () => {
    while (cursor < items.length) {
      const i = cursor++;                       // claim an index, then await
      results[i] = await worker(items[i], i);
    }
  };
  const pool = Array.from({ length: Math.min(limit, items.length) }, runner);
  await Promise.all(pool);
  return results;
};

const routes = [
  { name: 'yaba', ms: 30 },
  { name: 'ikeja', ms: 10 },
  { name: 'lekki', ms: 20 },
  { name: 'ojota', ms: 5 },
  { name: 'apapa', ms: 15 },
];

const quoteAll = async (limit) => {
  const clock = makeClock();
  const finished = [];
  let inFlight = 0;
  let peak = 0;
  const quote = async (route) => {
    inFlight++;
    peak = Math.max(peak, inFlight);
    await clock.wait(route.ms);
    inFlight--;
    finished.push(route.name);
    return `${route.name}:${route.ms}`;
  };
  const pending = mapLimit(routes, limit, quote);
  const finishedAt = await clock.runAll();
  const results = await pending;
  return { results, finished, peak, finishedAt };
};

const two = await quoteAll(2);
const serial = await quoteAll(1);
const wideOpen = await quoteAll(5);
const overshoot = await quoteAll(50);
const orderIsStable = same(two.results, serial.results) && same(two.results, wideOpen.results);

console.log('limit 2 :', two.finished, '| peak:', two.peak, '| clock:', two.finishedAt);
console.log('limit 1 :', serial.finished, '| clock:', serial.finishedAt);
console.log('limit 5 :', wideOpen.finished, '| clock:', wideOpen.finishedAt);
console.log('results :', two.results);

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 makeClock = () => {
  let now = 0;
  let seq = 0;
  const timers = [];
  const drainMicrotasks = async () => {
    for (let i = 0; i < 50; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait: (ms) => new Promise((resolve) => timers.push({ at: now + ms, seq: seq++, resolve })),
    async runAll() {
      await drainMicrotasks();                  // drain BEFORE the clock moves
      while (timers.length) {
        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
        const next = timers.shift();
        now = next.at;
        next.resolve();
        await drainMicrotasks();
      }
      return now;
    },
  };
};

const retry = async (operation, options) => {
  const { attempts, base, factor = 2, maxDelay = Infinity, clock, onWait } = options;
  let lastError;
  for (let attempt = 1; attempt <= attempts; attempt++) {
    try {
      return await operation(attempt);
    } catch (error) {
      lastError = error;
      if (attempt === attempts) break;          // no wait after the try you will not repeat
      const delay = Math.min(base * factor ** (attempt - 1), maxDelay);
      if (onWait) onWait(delay);
      await clock.wait(delay);
    }
  }
  throw lastError;
};

const flaky = (failures) => {
  let calls = 0;
  return async (attempt) => {
    calls++;
    if (calls <= failures) throw new Error(`attempt ${attempt} failed`);
    return `ok on attempt ${attempt}`;
  };
};

const attempt = async (options, failures) => {
  const clock = makeClock();
  const delays = [];
  let value = 'no value';
  let failure = 'no error';
  const settled = retry(flaky(failures), { ...options, clock, onWait: (d) => delays.push(d) })
    .then((v) => { value = v; }, (e) => { failure = e.message; });
  await clock.runAll();
  await settled;
  return { value, failure, delays, at: clock.now() };
};

const doubling = await attempt({ attempts: 5, base: 100 }, 3);
const capped = await attempt({ attempts: 5, base: 100, maxDelay: 250 }, 3);
const flat = await attempt({ attempts: 4, base: 100, factor: 1 }, 3);
const hopeless = await attempt({ attempts: 3, base: 100 }, 99);
const firstTime = await attempt({ attempts: 5, base: 100 }, 0);

console.log('doubling :', doubling.delays, '->', doubling.value, '| clock:', doubling.at);
console.log('capped   :', capped.delays, '| clock:', capped.at);
console.log('flat     :', flat.delays);
console.log('hopeless :', hopeless.delays, '->', hopeless.failure);

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
86const makeClock = () => {
  let now = 0;
  let seq = 0;
  const timers = [];
  const drainMicrotasks = async () => {
    for (let i = 0; i < 50; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait: (ms) => new Promise((resolve) => timers.push({ at: now + ms, seq: seq++, resolve })),
    async runAll() {
      await drainMicrotasks();                  // microtasks first, then the clock
      while (timers.length) {
        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
        const next = timers.shift();
        now = next.at;
        next.resolve();
        await drainMicrotasks();
      }
      return now;
    },
  };
};

class SerialQueue {
  #tail = Promise.resolve();
  #depth = 0;

  add(task) {
    this.#depth++;
    const run = this.#tail.then(task);          // wait for whatever is ahead of you
    this.#tail = run.catch(() => {});           // a failure must not poison the chain
    return run.finally(() => { this.#depth--; });
  }

  get depth() { return this.#depth; }
}

const clock = makeClock();
const started = [];
const finished = [];
const job = (name, ms) => async () => {
  started.push(name);
  await clock.wait(ms);
  finished.push(name);
  return `${name} done`;
};

const queue = new SerialQueue();
const slow = queue.add(job('upload-receipt', 30));
const quick = queue.add(job('send-sms', 5));
const third = queue.add(job('update-ledger', 10));
const startedSynchronously = [...started];
const depthWhileQueued = queue.depth;

const serialAt = await clock.runAll();
const queued = await Promise.all([slow, quick, third]);
const depthAtTheEnd = queue.depth;

const parallelClock = makeClock();
const pStarted = [];
const pFinished = [];
const pJob = (name, ms) => async () => {
  pStarted.push(name);
  await parallelClock.wait(ms);
  pFinished.push(name);
  return name;
};
const together = Promise.all([pJob('upload-receipt', 30)(), pJob('send-sms', 5)(), pJob('update-ledger', 10)()]);
const parallelAt = await parallelClock.runAll();
const parallelResults = await together;

const failClock = makeClock();
const trail = [];
const failQueue = new SerialQueue();
const one = failQueue.add(async () => { trail.push('one'); await failClock.wait(5); return 'one'; });
const boom = failQueue.add(async () => { trail.push('two'); await failClock.wait(5); throw new Error('network down'); });
const three = failQueue.add(async () => { trail.push('three'); await failClock.wait(5); return 'three'; });
const rescued = boom.then(() => 'resolved after all', (e) => e.message);
await failClock.runAll();
const outcomes = [await one, await rescued, await three];

console.log('started :', started, '| synchronously:', startedSynchronously);
console.log('finished:', finished, '| clock:', serialAt);
console.log('parallel:', pFinished, '| clock:', parallelAt);
console.log('after a failure:', trail, outcomes);

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
86const makeClock = () => {
  let now = 0;
  let seq = 0;
  const timers = [];
  const drainMicrotasks = async () => {
    for (let i = 0; i < 50; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait: (ms) => new Promise((resolve) => timers.push({ at: now + ms, seq: seq++, resolve })),
    async runAll() {
      await drainMicrotasks();                  // microtasks first, then move the clock
      while (timers.length) {
        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
        const next = timers.shift();
        now = next.at;
        next.resolve();
        await drainMicrotasks();
      }
      return now;
    },
  };
};

const waitOrAbort = (clock, ms, signal) =>
  new Promise((resolve, reject) => {
    if (signal.aborted) {
      reject(signal.reason);                    // already cancelled: the event will not fire again
      return;
    }
    const onAbort = () => reject(signal.reason);
    signal.addEventListener('abort', onAbort, { once: true });
    clock.wait(ms).then(() => {
      signal.removeEventListener('abort', onAbort);
      resolve();
    });
  });

const steps = [
  { name: 'reserve stock', ms: 10 },
  { name: 'charge card', ms: 20 },
  { name: 'notify rider', ms: 5 },
];

const runTransfer = async ({ abortAt = null, abortFirst = false }) => {
  const clock = makeClock();
  const controller = new AbortController();
  const signal = controller.signal;
  const done = [];
  const transfer = async () => {
    for (const step of steps) {
      await waitOrAbort(clock, step.ms, signal);
      done.push(step.name);
    }
    return done.join(' -> ');
  };
  if (abortFirst) controller.abort(new Error('cancelled before we started'));
  else if (abortAt !== null) clock.wait(abortAt).then(() => controller.abort(new Error('rider cancelled')));
  let value = 'no value';
  let failure = 'no error';
  const settled = transfer().then((v) => { value = v; }, (e) => { failure = e.message; });
  await clock.runAll();
  await settled;
  return { value, failure, done, at: clock.now(), controller };
};

const whole = await runTransfer({});
const cancelled = await runTransfer({ abortAt: 25 });
const early = await runTransfer({ abortFirst: true });

whole.controller.abort(new Error('too late to matter'));
const afterTheFact = [whole.value, whole.controller.signal.aborted, whole.controller.signal.reason.message];

const bare = new AbortController();
bare.abort();
const defaultReason = [bare.signal.aborted, bare.signal.reason.name];

const twice = new AbortController();
twice.abort(new Error('first reason'));
twice.abort(new Error('second reason'));
const keptReason = twice.signal.reason.message;

console.log('whole    :', whole.value, '| clock:', whole.at);
console.log('cancelled:', cancelled.done, '->', cancelled.failure, '| clock:', cancelled.at);
console.log('early    :', early.done, '->', early.failure, '| clock:', early.at);
console.log('bare     :', defaultReason, '| kept:', keptReason);

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122const makeClock = () => {
  let now = 0;
  let seq = 0;
  const timers = [];
  const drainMicrotasks = async () => {
    for (let i = 0; i < 50; i++) await Promise.resolve();
  };
  return {
    now: () => now,
    wait: (ms) => new Promise((resolve) => timers.push({ at: now + ms, seq: seq++, resolve })),
    async runAll() {
      await drainMicrotasks();                  // drain, then advance
      while (timers.length) {
        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
        const next = timers.shift();
        now = next.at;
        next.resolve();
        await drainMicrotasks();
      }
      return now;
    },
  };
};

const table = [
  { id: 1, name: 'Ngozi Traders' },
  { id: 2, name: 'Bisi Foods' },
  { id: 3, name: 'Chidi Motors' },
  { id: 4, name: 'Amaka Fabrics' },
  { id: 5, name: 'Tunde Spares' },
];

const makeSource = (clock, pageSize) => {
  let calls = 0;
  return {
    get calls() { return calls; },
    async fetchPage(cursor) {
      calls++;
      await clock.wait(10);                     // one round trip
      return {
        rows: table.slice(cursor, cursor + pageSize),
        next: cursor + pageSize < table.length ? cursor + pageSize : null,
      };
    },
  };
};

const paged = (source) => ({
  async *[Symbol.asyncIterator]() {
    let cursor = 0;
    while (cursor !== null) {
      const page = await source.fetchPage(cursor);
      for (const row of page.rows) yield row;   // hand out rows, not pages
      cursor = page.next;
    }
  },
});

const clockA = makeClock();
const sourceA = makeSource(clockA, 2);
const walkAll = async () => {
  const out = [];
  for await (const row of paged(sourceA)) out.push(row.name);
  return out;
};
const pendingA = walkAll();
await clockA.runAll();
const everyName = await pendingA;
const fullWalk = [sourceA.calls, clockA.now()];

const clockB = makeClock();
const sourceB = makeSource(clockB, 2);
const walkThree = async () => {
  const out = [];
  for await (const row of paged(sourceB)) {
    out.push(row.id);
    if (out.length === 3) break;                // stop asking
  }
  return out;
};
const pendingB = walkThree();
await clockB.runAll();
const threeIds = await pendingB;
const shortWalk = [sourceB.calls, clockB.now()];

const clockC = makeClock();
const sourceC = makeSource(clockC, 5);
const iterator = paged(sourceC)[Symbol.asyncIterator]();
const firstStep = iterator.next();
const stepIsAPromise = typeof firstStep.then === 'function';
await clockC.runAll();
const first = await firstStep;
const second = await iterator.next();
const rest = [];
let step = await iterator.next();
while (!step.done) {
  rest.push(step.value.id);
  step = await iterator.next();
}

let spreadError = 'no error';
try { [...paged(sourceA)]; } catch (e) { spreadError = e.constructor.name; }

const clockE = makeClock();
const sourceE = makeSource(clockE, 5);
const feed = paged(sourceE);
const walkFeed = async () => {
  const out = [];
  for await (const row of feed) out.push(row.id);
  return out;
};
const firstPass = walkFeed();
await clockE.runAll();
const pass1 = await firstPass;
const secondPass = walkFeed();
await clockE.runAll();
const pass2 = await secondPass;

console.log('all rows :', everyName);
console.log('requests :', fullWalk, '| after break:', shortWalk);
console.log('manual   :', first.value.name, second.value.name, rest, '| done:', step.done);
console.log('twice    :', pass1, pass2, '| requests:', sourceE.calls);

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
31const machine = Object.freeze({
  placed:     { pack: 'packed', cancel: 'cancelled' },
  packed:     { dispatch: 'dispatched', cancel: 'cancelled' },
  dispatched: { deliver: 'delivered' },
  delivered:  {},
  cancelled:  {},
});

const next = (state, event) => machine[state]?.[event] ?? state;
const eventsFrom = (state) => Object.keys(machine[state] ?? {});
const isTerminal = (state) => eventsFrom(state).length === 0;

const feed = (start, events) => events.reduce((acc, event) => {
  const to = next(acc.state, event);
  return to === acc.state
    ? { ...acc, ignored: [...acc.ignored, event] }
    : { ...acc, state: to, trail: [...acc.trail, to] };
}, { state: start, trail: [start], ignored: [] });

const happy = feed('placed', ['pack', 'dispatch', 'deliver']);
const stubborn = feed('placed', ['deliver', 'pack', 'cancel', 'pack']);
const fromNowhere = next('warehouse-9', 'pack');

let topLevelWrite = 'no error';
try { machine.placed = {}; } catch (e) { topLevelWrite = e.constructor.name; }
const nestedIsFrozen = Object.isFrozen(machine.placed);

console.log('happy    :', happy.state, happy.trail);
console.log('stubborn :', stubborn.state, '| ignored:', stubborn.ignored);
console.log('terminal :', ['delivered', 'cancelled', 'placed'].map(isTerminal));
console.log('freeze   :', topLevelWrite, '| nested frozen:', nestedIsFrozen);

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 empty = Object.freeze({ items: [], note: '' });

const reduce = (state, action) => {
  switch (action.type) {
    case 'add': {
      const seen = state.items.some((i) => i.sku === action.sku);
      const items = seen
        ? state.items.map((i) => (i.sku === action.sku ? { ...i, qty: i.qty + action.qty } : i))
        : [...state.items, { sku: action.sku, name: action.name, qty: action.qty, kobo: action.kobo }];
      return { ...state, items };
    }
    case 'drop':
      return { ...state, items: state.items.filter((i) => i.sku !== action.sku) };
    case 'qty':
      return action.qty > 0
        ? { ...state, items: state.items.map((i) => (i.sku === action.sku ? { ...i, qty: action.qty } : i)) }
        : reduce(state, { type: 'drop', sku: action.sku });
    case 'note':
      return { ...state, note: action.text };
    default:
      return state;
  }
};

const feed = (state, actions) => actions.reduce(reduce, state);
const totalKobo = (state) => state.items.reduce((sum, i) => sum + i.qty * i.kobo, 0);

const stocked = feed(empty, [
  { type: 'add', sku: 'GARRI-5', name: 'Garri, 5kg', qty: 2, kobo: 450000 },
  { type: 'add', sku: 'PALM-1', name: 'Palm oil, 1L', qty: 1, kobo: 320000 },
  { type: 'add', sku: 'GARRI-5', qty: 1 },
]);

const noted = reduce(stocked, { type: 'note', text: 'Leave it at the gate' });
const zeroed = reduce(stocked, { type: 'qty', sku: 'PALM-1', qty: 0 });
const ignored = reduce(stocked, { type: 'sing' });

let frozenWrite = 'no error';
try { empty.note = 'hijacked'; } catch (e) { frozenWrite = e.constructor.name; }

console.log('cart  :', stocked.items.map((i) => `${i.name} x${i.qty}`));
console.log('total :', totalKobo(stocked), 'kobo');
console.log('shared:', noted.items === stocked.items, '| same object back:', ignored === stocked);

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 STATES = new Set(['Lagos', 'Kano', 'Rivers', 'Enugu', 'FCT']);

const rules = [
  ['name', 'name is required', (f) => typeof f.name === 'string' && f.name.trim() !== ''],
  ['phone', 'phone must be 11 digits starting with 0', (f) => /^0\d{10}$/.test(f.phone ?? '')],
  ['state', 'state is not on the list', (f) => STATES.has(f.state)],
  ['age', 'age must be a whole number, 18 or more', (f) => Number.isInteger(f.age) && f.age >= 18],
  ['email', 'email needs exactly one @', (f) => (f.email ?? '').split('@').length === 2],
];

const check = (form) => {
  const errors = rules
    .filter(([, , ok]) => !ok(form))
    .map(([field, message]) => ({ field, message }));
  return errors.length === 0 ? { ok: true, value: form } : { ok: false, errors };
};

const firstFailureOnly = (form) => {
  try {
    for (const [field, message, ok] of rules) {
      if (!ok(form)) throw new Error(`${field}: ${message}`);
    }
    return { ok: true };
  } catch (e) {
    return { ok: false, message: e.message };
  }
};

const good = { name: 'Ngozi Okafor', phone: '08031234567', state: 'Enugu', age: 31, email: 'ngozi@example.ng' };
const wrong = { name: '   ', phone: '8031234567', state: 'Lagos Island', age: 17, email: 'ngozi.example.ng' };
const nearly = { name: 'Musa Bello', phone: '07098765432', state: 'Kano', age: 16, email: 'musa@example.ng' };

const passed = check(good);
const failed = check(wrong);
const fields = failed.errors.map((e) => e.field);
const byField = failed.errors.reduce((acc, e) => ({ ...acc, [e.field]: e.message }), {});
const eager = firstFailureOnly(wrong);
const reversedFields = [...rules].reverse().filter(([, , ok]) => !ok(wrong)).map(([f]) => f);

console.log('passed :', passed);
console.log('failed :', fields);
console.log('eager  :', eager.message);
console.log('byField:', byField);

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 at = (path, message) => ({ path, message });
const prefix = (head, errors) =>
  errors.map((e) => ({ ...e, path: e.path ? `${head}.${e.path}` : head }));

const str = ({ min = 0 } = {}) => (v) =>
  typeof v !== 'string' ? [at('', 'must be a string')]
    : v.length < min ? [at('', `must be at least ${min} characters`)]
      : [];

const int = ({ min = -Infinity } = {}) => (v) =>
  !Number.isInteger(v) ? [at('', 'must be a whole number')]
    : v < min ? [at('', `must be at least ${min}`)]
      : [];

const oneOf = (allowed) => (v) =>
  allowed.includes(v) ? [] : [at('', `must be one of ${allowed.join(', ')}`)];

const optional = (rule) => (v) => (v === undefined ? [] : rule(v));

const arrayOf = (rule) => (v) =>
  !Array.isArray(v)
    ? [at('', 'must be an array')]
    : v.flatMap((item, i) => prefix(String(i), rule(item)));

const shape = (fields) => (v) =>
  v === null || typeof v !== 'object'
    ? [at('', 'must be an object')]
    : Object.entries(fields).flatMap(([key, rule]) => prefix(key, rule(v[key])));

const validator = (rule) => (v) => {
  const errors = rule(v);
  return errors.length ? { ok: false, errors } : { ok: true, value: v };
};

const checkVendor = validator(shape({
  name: str({ min: 3 }),
  lga: oneOf(['Eti-Osa', 'Ikeja', 'Surulere']),
  stall: optional(str({ min: 1 })),
  goods: arrayOf(shape({ item: str({ min: 2 }), kobo: int({ min: 1 }) })),
}));

const goodVendor = { name: 'Mama Nkechi', lga: 'Ikeja', goods: [{ item: 'Ugu', kobo: 50000 }] };
const badVendor = { name: 'Yo', lga: 'Ajah', goods: [{ item: 'Ugu', kobo: 0 }, { item: 7, kobo: 1.5 }] };

const bad = checkVendor(badVendor);
const paths = bad.errors.map((e) => e.path);

console.log('good :', checkVendor(goodVendor));
console.log('paths:', paths);
console.log('first:', bad.errors[0]);

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 parseCsv = (text) => {
  const rows = [];
  let row = [];
  let field = '';
  let quoted = false;
  let i = 0;
  while (i < text.length) {
    const ch = text[i];
    if (quoted) {
      if (ch === '"' && text[i + 1] === '"') { field += '"'; i += 2; continue; }
      if (ch === '"') { quoted = false; i += 1; continue; }
      field += ch; i += 1; continue;
    }
    if (ch === '"') { quoted = true; i += 1; continue; }
    if (ch === ',') { row.push(field); field = ''; i += 1; continue; }
    if (ch === '\n' || ch === '\r') {
      if (ch === '\r' && text[i + 1] === '\n') i += 1;
      row.push(field); rows.push(row); row = []; field = ''; i += 1; continue;
    }
    field += ch; i += 1;
  }
  if (field !== '' || row.length) { row.push(field); rows.push(row); }
  return rows;
};

const toObjects = ([header, ...body]) =>
  body.map((cells) => Object.fromEntries(header.map((key, i) => [key, cells[i] ?? ''])));

const csv = [
  'name,lga,crates,note',
  '"Adebayo, Tunde",Ikeja,2,"said ""come early"""',
  'Ngozi Okafor,Surulere,1,',
  '"Musa Bello",Kano,3,"two lines:\nthe second"',
].join('\r\n');

const rows = parseCsv(csv);
const records = toObjects(rows);
const naive = csv.split('\n')[1].split(',').length;

console.log('rows   :', rows.length, '| cells per row:', rows.map((r) => r.length));
console.log('record :', records[0]);
console.log('naive  :', naive, 'cells for a line that has 4 fields');

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
35const parseQuery = (search) =>
  search
    .replace(/^\?/, '')
    .split('&')
    .filter(Boolean)
    .reduce((acc, pair) => {
      const [rawKey, ...rest] = pair.split('=');
      const decode = (s) => decodeURIComponent(s.replace(/\+/g, ' '));
      const key = decode(rawKey);
      const value = decode(rest.join('='));
      const prior = acc[key];
      const merged = !(key in acc) ? value
        : Array.isArray(prior) ? [...prior, value]
          : [prior, value];
      return { ...acc, [key]: merged };
    }, {});

const buildQuery = (params) =>
  Object.entries(params)
    .flatMap(([key, value]) => (Array.isArray(value) ? value.map((one) => [key, one]) : [[key, value]]))
    .filter(([, value]) => value !== undefined && value !== null)
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
    .join('&');

const search = '?state=Lagos&lga=Eti-Osa&lga=Ikeja&q=jollof+rice&price=%E2%82%A65%2C000&flag';
const parsed = parseQuery(search);
const rebuilt = buildQuery(parsed);
const reparsed = parseQuery(rebuilt);

const injected = buildQuery({ q: 'rice&admin=1', page: 2, cursor: undefined, note: null });
const injectedBack = parseQuery(injected);

console.log('parsed  :', parsed);
console.log('rebuilt :', rebuilt);
console.log('injected:', injected);

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 tokenise = (text) => text.match(/\d+(?:\.\d+)?|[-+*/()]|\S/g) ?? [];

const evaluate = (text) => {
  const tokens = tokenise(text);
  let at = 0;
  const peek = () => tokens[at];
  const eat = (want) => {
    if (peek() !== want) throw new SyntaxError(`expected ${want}, found ${peek() ?? 'end of input'}`);
    at += 1;
  };
  const primary = () => {
    const token = peek();
    if (token === '(') {
      eat('(');
      const inner = expr();
      eat(')');
      return inner;
    }
    if (token === '-') { eat('-'); return -primary(); }
    if (token !== undefined && /^\d/.test(token)) { at += 1; return Number(token); }
    throw new SyntaxError(`unexpected ${token ?? 'end of input'}`);
  };
  const term = () => {
    let left = primary();
    while (peek() === '*' || peek() === '/') {
      const op = peek();
      at += 1;
      const right = primary();
      left = op === '*' ? left * right : left / right;
    }
    return left;
  };
  const expr = () => {
    let left = term();
    while (peek() === '+' || peek() === '-') {
      const op = peek();
      at += 1;
      const right = term();
      left = op === '+' ? left + right : left - right;
    }
    return left;
  };
  const value = expr();
  if (at !== tokens.length) throw new SyntaxError(`trailing ${peek()}`);
  return value;
};

const complain = (text) => {
  try { return evaluate(text); } catch (e) { return e.message; }
};

console.log('tokens :', tokenise('1500 * (12 - 2)'));
console.log('fare   :', evaluate('1500 * 12 + 500'));
console.log('errors :', ['(2 + 3', '2 +', '2 3', '4 % 2'].map(complain));

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
29const ENTITIES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
const escapeHtml = (value) => String(value).replace(/[&<>"']/g, (ch) => ENTITIES[ch]);

class Safe {
  constructor(markup) { this.markup = markup; }
  toString() { return this.markup; }
}

const render = (value) =>
  value instanceof Safe ? value.markup
    : Array.isArray(value) ? value.map(render).join('')
      : value === null || value === undefined ? ''
        : escapeHtml(value);

const html = (strings, ...values) =>
  new Safe(strings.reduce((out, chunk, i) => out + render(values[i - 1]) + chunk));

const shapes = (strings, ...values) => ({ chunks: strings.length, values: values.length, cooked: strings[1], raw: strings.raw[1] });

const vendor = { name: 'Ade & Sons', review: '<script>steal()</script>', stall: null, crates: 12 };
const card = html`<p>${vendor.name} sold ${vendor.crates} crates</p>`;
const nasty = html`<blockquote>${vendor.review}</blockquote>`;
const nested = html`<ul>${['Yaba', 'Surulere'].map((z) => html`<li>${z}</li>`)}</ul>`;
const missing = html`<span>${vendor.stall}${undefined}</span>`;
const parts = shapes`a${1}b\nc${2}d`;

console.log('card  :', String(card));
console.log('nasty :', String(nasty));
console.log('nested:', String(nested));

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 deepEqual = (a, b) => {
  if (a === b) return true;
  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;
  const ak = Object.keys(a);
  const bk = Object.keys(b);
  return ak.length === bk.length && ak.every((k) => deepEqual(a[k], b[k]));
};

const diff = (before, after) => {
  const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])];
  return keys.reduce((acc, key) => {
    const had = Object.hasOwn(before, key);
    const has = Object.hasOwn(after, key);
    if (!had) return { ...acc, added: { ...acc.added, [key]: after[key] } };
    if (!has) return { ...acc, removed: { ...acc.removed, [key]: before[key] } };
    if (deepEqual(before[key], after[key])) return acc;
    return { ...acc, changed: { ...acc.changed, [key]: [before[key], after[key]] } };
  }, { added: {}, removed: {}, changed: {} });
};

const apply = (base, d) => {
  const next = { ...base, ...d.added };
  for (const key of Object.keys(d.removed)) delete next[key];
  for (const [key, [, to]] of Object.entries(d.changed)) next[key] = to;
  return next;
};

const before = { name: 'Mama Nkechi', lga: 'Ikeja', phone: '08031234567', stall: { row: 'B', number: 12 }, tags: ['veg'] };
const after = { name: 'Mama Nkechi', lga: 'Surulere', stall: { row: 'B', number: 12 }, tags: ['veg', 'fruit'], since: 2019 };

const d = diff(before, after);
const nothing = diff(before, before);
const blanked = diff({ a: 1 }, { a: undefined });
const nanDiff = diff({ takings: NaN }, { takings: NaN });

console.log('changed:', d.changed);
console.log('added  :', d.added, '| removed:', d.removed);
console.log('applied:', apply(before, d));

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
40const isContainer = (v) => v !== null && typeof v === 'object';

const flatten = (value, head = '') => {
  if (!isContainer(value)) return { [head]: value };
  const entries = Object.entries(value);
  if (entries.length === 0) return head ? { [head]: Array.isArray(value) ? [] : {} } : {};
  return entries.reduce((acc, [key, inner]) => {
    const path = head ? `${head}.${key}` : key;
    return { ...acc, ...flatten(inner, path) };
  }, {});
};

const unflatten = (flat) =>
  Object.entries(flat).reduce((root, [path, value]) => {
    const keys = path.split('.');
    const last = keys.pop();
    const parent = keys.reduce((node, key, i) => {
      const nextSegment = keys[i + 1] ?? last;
      if (node[key] === undefined) node[key] = /^\d+$/.test(nextSegment) ? [] : {};
      return node[key];
    }, root);
    parent[last] = value;
    return root;
  }, {});

const settings = {
  shop: { name: 'Balogun Stores', address: { lga: 'Lagos Island', street: 'Broad Street' } },
  delivery: { zones: ['Yaba', 'Surulere'], freeAbove: 500000 },
  open: true,
};

const flat = flatten(settings);
const back = unflatten(flat);
const empties = flatten({ a: {}, b: [] });
const collided = flatten({ 'shop.name': 'typed with a dot', shop: { name: 'nested' } });
const deepArray = unflatten({ 'a.0.b': 1 });

console.log('flat  :', Object.keys(flat));
console.log('back  :', back);
console.log('edges :', empties, collided, deepArray);

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
29const deepFreeze = (value) => {
  if (value === null || typeof value !== 'object' || Object.isFrozen(value)) return value;
  Object.freeze(value);
  Object.values(value).forEach((inner) => deepFreeze(inner));
  return value;
};

const shallow = Object.freeze({ shop: 'Balogun Stores', tariffs: { lekki: 250000 } });
let shallowTop = 'no error';
try { shallow.shop = 'somewhere else'; } catch (e) { shallowTop = e.constructor.name; }
shallow.tariffs.lekki = 1;
const leaked = shallow.tariffs.lekki;

const deep = deepFreeze({ shop: 'Balogun Stores', tariffs: { lekki: 250000 }, zones: ['Yaba'] });
let deepNested = 'no error';
try { deep.tariffs.lekki = 1; } catch (e) { deepNested = e.constructor.name; }
let pushed = 'no error';
try { deep.zones.push('Ikeja'); } catch (e) { pushed = e.constructor.name; }

const withMap = deepFreeze({ seen: new Map([['Yaba', 1]]) });
withMap.seen.set('Ketu', 2);

const knot = { name: 'knot' };
knot.self = knot;
deepFreeze(knot);

console.log('shallow :', shallowTop, '| nested value is now', leaked);
console.log('deep    :', deepNested, pushed, '| tariff still', deep.tariffs.lekki);
console.log('map     :', [...withMap.seen], '| cycle frozen:', Object.isFrozen(knot));

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
58function* naturals(from = 1) {
  let n = from;
  while (true) {
    yield n;
    n += 1;
  }
}

function* map(source, fn) {
  for (const value of source) yield fn(value);
}

function* filter(source, ok) {
  for (const value of source) if (ok(value)) yield value;
}

function* take(source, count) {
  if (count <= 0) return;
  let taken = 0;
  for (const value of source) {
    yield value;
    taken += 1;
    if (taken >= count) return;
  }
}

const toArray = (source) => [...source];
const pipeline = (source, ...steps) => steps.reduce((acc, step) => step(acc), source);

const everyThirdInKobo = toArray(pipeline(
  naturals(),
  (s) => filter(s, (n) => n % 3 === 0),
  (s) => map(s, (n) => n * 100),
  (s) => take(s, 4),
));

let squareCalls = 0;
const threeSquares = toArray(take(map(naturals(), (n) => { squareCalls += 1; return n * n; }), 3));

const once = take(naturals(), 3);
const firstDrain = toArray(once);
const secondDrain = toArray(once);

let closed = false;
function* readings() {
  try {
    yield 1;
    yield 2;
    yield 3;
  } finally {
    closed = true;
  }
}
const twoOfThree = toArray(take(readings(), 2));

console.log('pipeline :', everyThirdInKobo);
console.log('lazy     :', threeSquares, '| the mapper ran', squareCalls, 'times');
console.log('drains   :', firstDrain, secondDrain, '| source closed:', closed);

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
61function* naturals(from = 1) {
  let n = from;
  while (true) {
    yield n;
    n += 1;
  }
}

function* map(source, fn) {
  for (const value of source) yield fn(value);
}

function* filter(source, ok) {
  for (const value of source) if (ok(value)) yield value;
}

function* take(source, count) {
  if (count <= 0) return;
  let taken = 0;
  for (const value of source) {
    yield value;
    taken += 1;
    if (taken >= count) return;
  }
}

function* zip(left, right) {
  const a = left[Symbol.iterator]();
  const b = right[Symbol.iterator]();
  while (true) {
    const x = a.next();
    const y = b.next();
    if (x.done || y.done) return;
    yield [x.value, y.value];
  }
}

const toArray = (source) => [...source];
const stops = ['Oshodi', 'Ikeja', 'Yaba', 'Surulere', 'Ojota', 'Ketu', 'Mile 12', 'Berger'];

let eagerTouches = 0;
const eager = stops
  .map((s) => { eagerTouches += 1; return s.toUpperCase(); })
  .filter((s) => s.length > 4)
  .slice(0, 2);

let lazyTouches = 0;
const lazy = toArray(take(
  filter(map(stops, (s) => { lazyTouches += 1; return s.toUpperCase(); }), (s) => s.length > 4),
  2,
));

const numbered = toArray(map(zip(naturals(), stops), ([i, name]) => `${i}. ${name}`));
const uneven = toArray(zip([1, 2, 3], ['a', 'b']));
const counter = naturals();
const shortPairs = toArray(zip(counter, ['a', 'b']));
const nextFromCounter = counter.next().value;

console.log('eager :', eager, '| touched', eagerTouches);
console.log('lazy  :', lazy, '| touched', lazyTouches);
console.log('zip   :', numbered.slice(0, 3), '| uneven:', uneven);

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
35const more = (fn, ...args) => ({ tag: 'more', fn, args });
const done = (value) => ({ tag: 'done', value });

const trampoline = (start) => {
  let step = start;
  while (step.tag === 'more') step = step.fn(...step.args);
  return step.value;
};

const sumTo = (n, acc = 0) => (n === 0 ? acc : sumTo(n - 1, acc + n));
let blewUp = 'no error';
try { sumTo(200000); } catch (e) { blewUp = e.constructor.name; }

const sumStep = (n, acc = 0) => (n === 0 ? done(acc) : more(sumStep, n - 1, acc + n));
const bounced = trampoline(sumStep(200000));

let plain = 0;
for (let i = 1; i <= 200000; i++) plain += i;

let bounces = 0;
const counted = (n, acc = 0) => {
  bounces += 1;
  return n === 0 ? done(acc) : more(counted, n - 1, acc + n);
};
const smallSum = trampoline(counted(5));

const isEven = (n) => (n === 0 ? done(true) : more(isOdd, n - 1));
const isOdd = (n) => (n === 0 ? done(false) : more(isEven, n - 1));
const parity = [trampoline(isEven(100001)), trampoline(isEven(4))];

const firstStep = sumStep(3);

console.log('direct    :', blewUp);
console.log('trampoline:', bounced, '| plain loop:', plain);
console.log('parity    :', parity, '| bounces for 5:', bounces);

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 pipeAsync = (...steps) => (input) =>
  steps.reduce((acc, step) => acc.then(step), Promise.resolve(input));
const composeAsync = (...steps) => pipeAsync(...[...steps].reverse());

const DIRECTORY = { 'mama nkechi': { lga: 'Ikeja', kobo: 50000 } };
const trail = [];
const step = (name, fn) => async (value) => {
  trail.push(name);
  return fn(value);
};

const normalise = step('normalise', (s) => s.trim().toLowerCase());
const lookup = step('lookup', (slug) => DIRECTORY[slug] ?? null);
const required = step('required', (row) => {
  if (!row) throw new Error('vendor not found');
  return row;
});
const priced = step('priced', (row) => ({ ...row, naira: row.kobo / 100 }));

const findVendor = pipeAsync(normalise, lookup, required, priced);

const found = await findVendor('  Mama Nkechi ');
const trailWhenFound = [...trail];
trail.length = 0;

let failure = 'no error';
try { await findVendor('Unknown Trader'); } catch (e) { failure = e.message; }
const trailWhenLost = [...trail];
trail.length = 0;

const backwards = composeAsync(priced, required, lookup, normalise);
const alsoFound = await backwards('MAMA NKECHI');
trail.length = 0;

const inc = async (n) => n + 1;
const dbl = async (n) => n * 2;
const bothWays = [await pipeAsync(inc, dbl)(5), await composeAsync(inc, dbl)(5)];
const mixed = await pipeAsync((n) => n + 1, async (n) => n * 3)(2);
const emptyPipe = pipeAsync()(3);

console.log('found  :', found);
console.log('trails :', trailWhenFound, trailWhenLost);
console.log('ways   :', bothWays, '| mixed sync and async:', mixed);

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
64class AppError extends Error {
  constructor(message, options) {
    super(message, options);
    this.name = new.target.name;
  }
}

class ValidationError extends AppError {
  constructor(field, message, options) {
    super(message, options);
    this.field = field;
  }
}

class PaymentError extends AppError {
  constructor(reference, message, options) {
    super(message, options);
    this.reference = reference;
  }
}

class Careless extends Error {
  constructor(message, options) {
    super(message);
    this.name = 'Careless';
  }
}

const chargeCard = () => { throw new RangeError('gateway timed out after 30s'); };

const takePayment = (reference) => {
  try {
    return chargeCard();
  } catch (cause) {
    throw new PaymentError(reference, 'could not charge the card', { cause });
  }
};

const chainOf = (error) => {
  const names = [];
  let at = error;
  while (at) {
    names.push(`${at.name}: ${at.message}`);
    at = at.cause;
  }
  return names;
};

const toPlain = (error) => ({
  name: error.name,
  message: error.message,
  ...(error.cause ? { cause: toPlain(error.cause) } : {}),
});

let caught = new Error('never thrown');
try { takePayment('TX-2019'); } catch (e) { caught = e; }
const kinds = [caught instanceof PaymentError, caught instanceof AppError, caught instanceof Error];
const sibling = new ValidationError('phone', 'phone must be 11 digits');
const careless = new Careless('lost the trail', { cause: new Error('the real problem') });
const serialised = JSON.stringify(caught);

console.log('caught :', caught.name, '|', caught.message);
console.log('chain  :', chainOf(caught));
console.log('json   :', serialised);

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
83const normal = () => {
  try {
    return 'from try';
  } finally {
    const noReturnHere = true;
  }
};

const hijacked = () => {
  try {
    return 'from try';
  } finally {
    return 'from finally';
  }
};

const swallowed = () => {
  try {
    throw new Error('boom');
  } finally {
    return 'finally ate the error';
  }
};

const rethrown = () => {
  try {
    return 'never seen';
  } finally {
    throw new Error('finally threw instead');
  }
};

let counter = 0;
const evaluatedFirst = () => {
  try {
    return counter;
  } finally {
    counter = 99;
  }
};

const box = { n: 1 };
const mutatedAfter = () => {
  try {
    return box;
  } finally {
    box.n = 2;
  }
};

const order = [];
const traced = () => {
  try {
    order.push('try');
    return order.length;
  } finally {
    order.push('finally');
  }
};

const cleanup = [];
const readRow = (bad) => {
  cleanup.push('open');
  try {
    if (bad) throw new Error('bad row');
    return 'ok';
  } finally {
    cleanup.push('close');
  }
};

const captured = evaluatedFirst();
const returnedBox = mutatedAfter();
const tracedValue = traced();
const good = readRow(false);
let escaped = 'no error';
try { readRow(true); } catch (e) { escaped = e.message; }
let secondary = 'no error';
try { rethrown(); } catch (e) { secondary = e.message; }

console.log('values :', normal(), '|', hijacked(), '|', swallowed());
console.log('timing :', captured, '->', counter, '| box:', returnedBox.n);
console.log('cleanup:', cleanup, '| escaped:', escaped);

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
37class Money {
  #kobo;
  constructor(kobo) { this.#kobo = kobo; }
  get kobo() { return this.#kobo; }
  get [Symbol.toStringTag]() { return 'Money'; }
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') return this.#kobo;
    if (hint === 'string') return `₦${(this.#kobo / 100).toFixed(2)}`;
    return `Money(${this.#kobo})`;
  }
}

class Tagged {
  get [Symbol.toStringTag]() { return 'Tagged'; }
}

class Bare {
  #hidden = 'invisible';
  constructor() { this.shown = 1; }
}

const fare = new Money(50000);
const tip = new Money(32000);

const asNumber = +fare;
const inText = `the fare is ${fare}`;
const plussed = fare + 0;
const minussed = fare - 0;
const difference = fare - tip;
const bigger = fare > tip;
const tagOf = Object.prototype.toString.call(fare);
const tagOfTagged = Object.prototype.toString.call(new Tagged());
const taggedInText = `${new Tagged()}`;

console.log('hints  :', asNumber, '|', inText, '|', plussed);
console.log('maths  :', minussed, difference, bigger);
console.log('tags   :', tagOf, tagOfTagged, taggedInText);

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
51class Vehicle {
  static #built = 0;
  #plate;
  constructor(plate, seats) {
    this.#plate = plate;
    this.seats = seats;
    Vehicle.#built += 1;
  }
  static get built() { return Vehicle.#built; }
  get plate() { return this.#plate; }
  fare(km) { return 100 * km; }
  describe() { return `${this.constructor.name} ${this.#plate}`; }
}

class Danfo extends Vehicle {
  constructor(plate, seats, conductor) {
    super(plate, seats);
    this.conductor = conductor;
  }
  fare(km) { return super.fare(km) + 50 * this.seats; }
  static fromPlate(text) {
    const [plate, seats = '14'] = text.split('/');
    return new this(plate, Number(seats), 'unknown');
  }
}

class Keke extends Danfo {
  fare(km) { return super.fare(km) / 2; }
}

class Broken extends Vehicle {
  constructor(plate) {
    this.tooEarly = true;
    super(plate, 1);
  }
}

const builtBefore = Vehicle.built;
const bus = new Danfo('LSD-234-AB', 14, 'Sunday');
const keke = new Keke('KEK-11-XY', 3, 'none');
const parsed = Danfo.fromPlate('EPE-901-CD/18');
const parsedKeke = Keke.fromPlate('IKD-77-EF/3');
const defaulted = Danfo.fromPlate('ABC-123-ZZ');
const builtHere = Vehicle.built - builtBefore;

let beforeSuper = 'no error';
try { new Broken('XX-000'); } catch (e) { beforeSuper = e.constructor.name; }

console.log('fares  :', bus.fare(10), keke.fare(10));
console.log('factory:', parsed.constructor.name, parsedKeke.constructor.name, defaulted.seats);
console.log('built  :', builtHere, '| this before super:', beforeSuper);

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 canGreet = (state) => ({
  greet: () => `Kaabo, ${state.name}`,
});

const canBill = (state) => ({
  bill: (km) => state.rate * km,
  raise: (by) => { state.rate += by; return state.rate; },
});

const canLog = (state) => ({
  log: (line) => { state.entries = [...state.entries, line]; return state.entries.length; },
  history: () => [...state.entries],
});

const makeDriver = ({ name, rate }) => {
  const state = { name, rate, entries: [] };
  return {
    ...canGreet(state),
    ...canBill(state),
    ...canLog(state),
    snapshot: () => ({ ...state }),
  };
};

const alsoGreets = () => ({ greet: () => 'a different greeting' });
const clashed = { ...canGreet({ name: 'Ada' }), ...alsoGreets() };

const Timestamped = (Base) => class extends Base {
  stamp(n) { return `${this.constructor.name}#${n}`; }
};
const Countable = (Base) => class extends Base {
  static tally(list) { return list.length; }
};
class Person {
  constructor(name) { this.name = name; }
}
class Rider extends Timestamped(Countable(Person)) {}

class ClassDriver {
  constructor(rate) { this.rate = rate; }
  bill(km) { return this.rate * km; }
}

const driver = makeDriver({ name: 'Musa Bello', rate: 15000 });
const beforeRaise = driver.bill(2);
const newRate = driver.raise(1000);
const afterRaise = driver.bill(2);
const logged = [driver.log('Yaba to Ojota'), driver.log('Ojota to Ketu')];
const { bill } = driver;
const detached = bill(3);

const loose = new ClassDriver(15000).bill;
let looseError = 'no error';
try { loose(3); } catch (e) { looseError = e.constructor.name; }

const rider = new Rider('Ngozi');

console.log('driver  :', driver.greet(), '|', driver.snapshot());
console.log('detached:', detached, '| class method detached:', looseError);
console.log('mixins  :', rider.stamp(3), Rider.tally([1, 2]), rider instanceof Person);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22const names = ['Ọladele', 'Adéwálé', 'adebayo', 'Zainab', 'Chinedu', 'Ẹmeka', 'Ibrahim'];

const byCodeUnit = [...names].sort();
const byLocale = [...names].sort((a, b) => a.localeCompare(b, 'en-NG'));

const collator = new Intl.Collator('en-NG');
const byCollator = [...names].sort(collator.compare);

const loose = new Intl.Collator('en-NG', { sensitivity: 'base' });
const accentPair = [loose.compare('Adéwálé', 'Adewale'), collator.compare('Adéwálé', 'Adewale')];
const casePair = [loose.compare('adebayo', 'Adebayo'), Math.abs(Math.sign(collator.compare('adebayo', 'Adebayo')))];

const stalls = ['Stall 10', 'Stall 2', 'Stall 1'];
const byText = [...stalls].sort((a, b) => a.localeCompare(b, 'en-NG'));
const byNumber = [...stalls].sort((a, b) => a.localeCompare(b, 'en-NG', { numeric: true }));

const signs = ['adebayo'.localeCompare('Zainab', 'en-NG'), 'Zainab'.localeCompare('adebayo', 'en-NG')].map(Math.sign);
const found = names.filter((n) => loose.compare(n, 'adewale') === 0);

console.log('code units:', byCodeUnit);
console.log('locale    :', byLocale);
console.log('stalls    :', byText, '->', byNumber);