Immutability

1// the bug: sort mutates in place, and the caller still holds the array
2function applyDiscounts(order: Order): Order {
3  order.items.sort(byPrice)             // <- the confirmation page's array
4  order.items[0].price = discounted(order.items[0].price)
5  return order
6}
7 
8// immutable interface, mutable internals: fast and safe
9function applyDiscounts(order: Order): Order {
10  const items = [...order.items].sort(byPrice)   // one copy, locally owned
11  items[0] = { ...items[0], price: discounted(items[0].price) }
12  return { ...order, items }                     // shares every other field
13}
14 
15// what the type system can say about it
16type Order = { readonly id: OrderId; readonly items: readonly LineItem[] }
17// TS: erased at runtime, a cast defeats it. Java's final: stops
18// reassignment, not mutation. Rust: actually enforced.

The middle version allocates exactly two things — one array and one line item — and shares everything else by reference. That is structural sharing done by hand, and for objects of this size it is the whole technique.

• For a handful of fields, spreading is free and the argument is over (Premature Optimization, Reclaimed).
• For a large collection updated in a loop, full copying is quadratic and is a real defect, not a style question.
• Structural sharing buys back most of it and costs a library or a hand-rolled tree (What a Framework Charges).
• Mutation costs nothing and buys nothing back — the third block is the price the first two are paying to avoid (Local Reasoning).

caveat The performance column is the most misleading thing here. Mutation is not uniformly faster: reference-identity change detection can beat the deep comparison that mutation forces on a UI or a cache, and sharing an immutable value avoids the defensive copies a mutable one requires at every boundary. The scores also ignore the language entirely — row three costs almost nothing in Clojure or Rust and a great deal in Java — and they cannot express the thing that actually decides most real cases, which is whether the value is passed across module lines at all.