An access-log summary loop is rewritten as transformation stages - what does the chain no longer give you?

Rewriting the access-log summary into stages is usually presented as a pure win, so the follow-up an interviewer reaches for is the honest half: what did the loop do that the chain now cannot, and what does getting each one back cost? ## What a stage is actually handed A per-element stage is a function invoked with one element. It is given no index, no neighbour, no running count of how many elements have gone past, and no way to say "stop, we are done". Everything the loop could do that depended on any of those is what you are giving up. ## Loss one: the position The index was not only a traversal device; it was data the body could use. Things the loop expressed with it: - Compare a line with the one before or after it. - Take every nth line, or the first n, or a window of lines around a match. - Report *where* something was - the position of the first malformed record, not just that one exists. - Treat the first or last element specially. The standard way back is to stop pretending position is hidden and make it data: pair each line with its position before the stages begin, after which every downstream stage is a plain per-element function again over pairs. The cost is real but small and explicit - an extra pass or a primitive that does the pairing, plus every later stage now destructures a pair instead of taking a line. ## Loss two: the mid-traversal exit A loop can leave immediately and the remaining lines are never touched. In a chain, whether that is possible depends on the evaluation model, and both models exist: - A **demand-driven** pipeline pulls elements one at a time through the stages and stops as soon as the consumer stops asking, so a stop-at-first-match consumer never touches the tail. - A pipeline whose stages each run to completion over the whole collection before the next begins has already done the work by the time anyone looks at the first result. What is gone in *every* model is the loop's most flexible form: an exit on a condition computed halfway through the body that also returns whatever was accumulated so far. That has to be restated as a stage that carries the partial result along with a decision about whether to continue, which is a different and usually longer piece of code. ## Loss three: the breakpoint The loop body is a numbered line in your own function. You break on it, you step, you watch the accumulator change, you add a condition so it stops on the four-thousandth line. In a chain, each stage is a separate function: you can still break inside a stage, but you lose the surrounding loop context and the single place where everything about one element happened. Stack traces taken from inside a stage often read through the traversal machinery rather than through your code, which is the practical annoyance people actually complain about. | The loop could | The chain's equivalent | What it costs | |---|---|---| | read the index | pair each element with its position first | an extra stage, and pairs downstream | | break out mid-body | demand-driven evaluation or a stop-at-first-match stage | depends on the machinery; not always available | | break out *with* the partial result | a stage that carries the partial result and a stop decision | more code than the loop had | | stop on one body line per element | break inside a stage, or inspect between stages | the per-element view of one place | ## Judging the trade The useful observation is that two of the three losses were also two of the ways the loop let you make a mistake. The index gave you position *and* off-by-one errors; the mid-body exit gave you early return *and* the bug where one path forgets to update the accumulator before leaving. Giving them up is a trade, not a sacrifice - which is why the answer an interviewer wants is a trade, not a verdict. Name the three, say how each is recovered, and say plainly that when the position or the exit is the whole point of the code, restating it as stages is usually longer and harder to read than what it replaced.