Two Debounces, One Tape: Combine and async/await Wait for the Same Quiet

How many searches does typing "Parcel Wire" launch?

If you wire the text field straight to the network, the answer is one per key — 11 in this script. If you wait for a beat of quiet first, the answer collapses to 2: once after Parcel, once after Parcel Wire.

This bench runs that experiment three ways at once and prints every event on one tape.

One script, three listeners

private static let script: [(TimeInterval, String)] = [
  (0.00, "P"), (0.08, "Pa"), (0.16, "Par"), (0.24, "Parc"),
  (0.32, "Parce"), (0.40, "Parcel"),
  (1.20, "Parcel "), (1.28, "Parcel W"), (1.36, "Parcel Wi"),
  (1.44, "Parcel Wir"), (1.52, "Parcel Wire"),
]

Eleven commits. A 400 ms quiet window after each burst. The rose column is the control: it has no window.

The tape is the argument

From the settled still, after the first pause:

And after the second:

Combine and async agree on what. They are about 33 ms apart on when — same 400 ms debounce, different scheduling. That gap is real and small enough that a search UI should not care; the RAW column is the one that hurts.

Mid-type: the control still looks "more up to date"

Caught mid-burst: RAW already shows Parcel Wi (9 emits). Combine and async still display Parcel (1 emit each) because the 400 ms quiet has not arrived. The control looks faster. It is also wrong about what the user meant — they were not done.

Combine: debounce(for:scheduler:)

subject
  .debounce(for: .seconds(0.4), scheduler: DispatchQueue.main)
  .sink { value in
    combineResult = value
    appendTape(tag: "CMB", text: value)
  }

The Time Manipulation Operators chapter in the Combine book uses the same idea with a one-second window and a Hello World typing script. This bench keeps the operator, swaps the domain to a shipment search, and puts the competing async implementation in the next column instead of a playground console.

Async: sleep, then check the generation

asyncGeneration += 1
let generation = asyncGeneration
Task { @MainActor in
  try? await Task.sleep(nanoseconds: 400_000_000)
  guard generation == asyncGeneration else { return } // a newer key won
  asyncResult = text
  appendTape(tag: "ASY", text: text)
}

Each key cancels the previous wait by bumping the generation — the unstructured twin of debounce. Chapter 10's lesson applies: this Task is only safe because we ignore stale generations on purpose. Prefer .task / structured cancellation when the wait is tied to a view lifetime.

Mini-exercise

Change debounceSeconds to 0.05 and re-run. Watch Combine and async emit counts climb toward RAW. Then set it to 1.0 and watch the mid-type still sit on — even longer. The number is a product decision, not a constant of nature.

Challenges

1. Replace the generation token with a stored Task you cancel() on each key — photograph whether ASY timestamps move closer to CMB.
2. Add Combine throttle(for:scheduler:latest:) as a fourth card and show how it differs from debounce on this same script.
3. Bridge the PassthroughSubject into an AsyncStream and drive one debounce only from async — delete the duplicate scheduler path.
4. Fire a fake network counter on each emit and show RAW billing 11 credits vs 2 for the debounced lanes.
5. Type a third burst into the script (Parcel Wire Pro) and confirm both debouncers emit 3 times while RAW emits N keys.

Key Points

• Debounce waits for quiet; this bench uses 400 ms.
• RAW control: 11 emits for Parcel Wire. Combine and async: 2 each.
• First emission: CMB 804 ms / ASY 837 ms (Parcel); second: CMB 1925 / ASY 1958 (Parcel Wire).
• ~33 ms separates the two debouncers — same answer, different schedulers.
• Mid-type, RAW looks ahead (Parcel Wi) while debounce still shows the last committed search.
• Combine's debounce(for:scheduler:) is the publisher spelling; sleep+generation is the async spelling.
• The tape makes the flood visible in a still — many KEY lines, two CMB/ASY pairs.
• Pick the runtime that matches the surrounding code; the product rule is identical: do not search on every key.

Next up: persistence — the same edit written three ways (UserDefaults, JSON file, SwiftData) with a kill-and-relaunch that shows which survive.