Workshop: write the code yourself

Check object shape, ID type and normalized content. Handle null separately; for strings validate the full decimal syntax before Number. Then check finiteness and sign. Test zero, whitespace, .5 versus 0.5, exponent syntax and unsafe coercion shortcuts. The reference functions are in examples/workshop.ts.

export function parsePriceRecord(raw: unknown): { id: string; price: number } {
  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
    throw new Error("Expected an object");
  }
  if (!("id" in raw) || typeof raw.id !== "string" || raw.id.trim() === "") {
    throw new Error("Invalid id");
  }
  if (!("price" in raw)) throw new Error("Missing price");
  let price: number;
  if (typeof raw.price === "number") {
    price = raw.price;
  } else if (typeof raw.price === "string" && /^\d+(\.\d+)?$/.test(raw.price.trim())) {
    price = Number(raw.price.trim());
  } else {
    throw new Error("Invalid price format");
  }
  if (!Number.isFinite(price) || price < 0) throw new Error("Invalid price");
  return { id: raw.id.trim(), price };
}

Choose nullable fields with an explicit undefined check, not ??, because null is meaningful. Clone the selected tags array. Object spread alone leaves nested references shared. Test mutation of the result and of a supplied patch array after the call.

export type Current = { id: string; price: number | null; tags: readonly string[] };
export type Patch = { price?: number | null; tags?: readonly string[] };

export function applyPatch(current: Current, patch: Patch): Current {
  return {
    id: current.id,
    price: patch.price === undefined ? current.price : patch.price,
    tags: [...(patch.tags ?? current.tags)],
  };
}

A plausible wrong solution: nullish fallback and shallow copying

const current = { id: "A", price: 10, tags: ["old"] };
const patch: { price?: number | null } = { price: null };
const wrong = { ...current, price: patch.price ?? current.price };
wrong.tags.push("new");
// wrong.price is 10, not null; current.tags is now ["old", "new"].

The contract says null clears price, so ?? incorrectly turns an explicit clear into no change. Check undefined for the price field.

The outer spread creates a new object but shares tags: copy the selected array independently, even for an empty patch.

A meaningful test asserts null and then mutates the returned tags to verify that current.tags remains unchanged.

Zero, absent fields and empty replacement arrays exercise different branches.

Cache the in-flight promise before other callers can start another load. Promise.resolve().then invokes the loader after the cache entry is set and captures synchronous throws. On rejection, evict that entry. Distinguish absence of an entry from a successfully cached undefined. Failed promises must not remain permanently cached.

export function memoizeAsync<K, V>(
  load: (key: K) => Promise<V>,
): (key: K) => Promise<V> {
  const cache = new Map<K, Promise<V>>();
  return key => {
    const existing = cache.get(key);
    if (existing !== undefined) return existing;

    const pending = Promise.resolve()
      .then(() => load(key))
      .catch(error => {
        cache.delete(key);
        throw error;
      });
    cache.set(key, pending);
    return pending;
  };
}

Catch inside the mapLimit callback, return a discriminated failure with a normalized message, and let successful results remain values. Error or String(error) handles ordinary thrown values without assuming every exception is Error. Type the callback result union explicitly when inference widens the discriminator.

import { mapLimit } from "./core.ts";

export type Outcome<T> =
  | { status: "loaded"; id: string; value: T }
  | { status: "failed"; id: string; message: string };

export function loadAll<T>(
  ids: readonly string[],
  limit: number,
  load: (id: string) => Promise<T>,
): Promise<Outcome<T>[]> {
  return mapLimit(ids, limit, async (id): Promise<Outcome<T>> => {
    try {
      return { status: "loaded", id, value: await load(id) };
    } catch (error) {
      return {
        status: "failed", id,
        message: error instanceof Error ? error.message : String(error),
      };
    }
  });
}