Implement One Operation

1. 1
   addItem only, with the two types it needs

   because It has both checks, the find, the branch and the append — every shape the other five operations use, in one screen.

2. 2
   Transcribe line for line, keeping the rule comments

   because A line with no pseudocode behind it is a decision made in the language's vocabulary, and the comment on the find is the rule's name kept in the code.

3. 3
   Run add-first, add-again, invalid-zero

   because Three examples against one function: any failure has one suspect, and add-again is the rule "one entry per product" meeting the language.

4. 4
   Write down what the language did

   because find → undefined, in-place mutation, throw for reject — three facts the next five functions inherit without re-deciding.

5. 5
   Then removeItem, changeQuantity, total, getItems, clear

   because Each is written against the notes and its own three examples, and each takes minutes because the shapes are already known.

1type ProductId = string
2interface CartItem { productId: ProductId; quantity: number }
3interface Cart { items: CartItem[] }
4 
5const catalog = new Set<ProductId>(['laptop', 'mouse', 'keyboard'])
6 
7export function createCart(): Cart {
8  return { items: [] }
9}
10 
11export function addItem(cart: Cart, productId: ProductId, quantity = 1): Cart {
12  if (!catalog.has(productId)) throw new Error('unknown product')          // 1
13  if (quantity <= 0) throw new Error('quantity must be positive')          // 2
14  const existing = cart.items.find((i) => i.productId === productId)      // 3: one entry per product
15  if (existing) existing.quantity += quantity                              // 4
16  else cart.items.push({ productId, quantity })                            // 5
17  return cart                                                              // 6
18}

Three things the language decided that the pseudocode did not: find returns undefined when nothing matches, so "exists" is truthiness; += and push mutate the cart in place; throw is how this language rejects. The find is an O(n) scan over the items — invisible for a cart, and the line a map would replace.

1. inputThe inner call returned { items: [{ productId: 'laptop', quantity: 1 }] }; the outer call receives it with productId 'laptop' and quantity 1.
2. lookupcart.items.find((i) => i.productId === productId) scans one entry and returns it — existing is the object, not undefined.
3. branchif (existing) is truthy; the else with the push does not run.
4. mutationexisting.quantity += quantity changes 1 to 2 on the object inside the array — in place, which is why cart.items shows it.
5. outputThe same cart object, now [{ laptop, 2 }]; deepEqual passes.

1// from example add-again
2const cart = addItem(addItem(createCart(), 'laptop'), 'laptop')
3assert.deepEqual(cart.items, [{ productId: 'laptop', quantity: 2 }])
4 
5// from example invalid-zero
6const empty = createCart()
7assert.throws(() => addItem(empty, 'laptop', 0), /positive/)
8assert.deepEqual(empty.items, [])

Two examples, four assertions, one function. If the first fails there is one place to look; if the second fails, the state check is the one that matters — a rejection that left a partial entry behind is a worse bug than a wrong message.