Loop Forms and range

## One keyword instead of four Most C-family languages ship `for`, `while`, and `do ... while` as separate statements. Go ships one: `for`. Every loop in every Go program is a `for` statement, and the different shapes come from which clauses you leave out. This is a deliberate simplification - there is exactly one place to look when you read a loop, and exactly one keyword to learn. ### The three-clause form ```go for i := 0; i < len(rows); i++ { // body } ``` The three clauses are the **init statement**, the **condition**, and the **post statement**, separated by semicolons. The init statement runs once before the first iteration; the condition is evaluated before every iteration and the loop stops when it is false; the post statement runs after each iteration, before the condition is re-tested. A variable declared in the init clause with `:=` is scoped to the loop - it does not exist after the closing brace. The condition must be a boolean expression. Go has no truthiness: `for n { }` where `n` is an int does not compile. That is a deliberate barrier against a whole family of C bugs. ### The condition-only form: Go's while Omit the init and post clauses (and their semicolons) and you get: ```go for scannerHasMore { // body } ``` This is a `while` loop in every meaningful sense: the condition is tested before the first iteration, so the body may run zero times. Because this form exists, Go's designers saw no reason to add a `while` keyword. Reaching for `while` in Go source is a compile error, not a style problem - `while` is not a keyword at all, so the compiler reads it as an identifier and the statement fails to parse. This is the form you use when the number of iterations is not known in advance: reading until an input is exhausted, retrying until a condition flips, draining a work list until it is empty. ### The infinite form Omit everything: ```go for { // runs until break, return, or a panic } ``` `for { }` is a legal and idiomatic Go statement, not a syntax error. It is the standard shape for a service main loop, a retry loop, or a state machine that decides internally when to stop. You leave it with `break`, with `return` from the enclosing function, or by panicking. The compiler also knows a `for { }` with no `break` never completes, which is why code after such a loop can be unreachable without a missing-return complaint. ### There is no do-while Go has no statement that tests the condition after the body. The idiom is: ```go for { body() if !keepGoing { break } } ``` The body runs at least once and the exit test sits where you can see it. Some people write the test at the top with a first-iteration flag; that is worse, because the flag is state a reader has to track. ### break and continue `break` ends the innermost enclosing `for` immediately. `continue` skips the rest of the body and moves on: in the three-clause form it runs the post statement and then re-tests the condition; in the condition-only form it goes straight back to the condition. Both are unlabeled by default and act on the loop they sit in. ### The failure this form invites The condition-only form has one classic way to go wrong: nothing in the body changes what the condition reads. In a batch job that walks a directory of CSV files, `for len(pending) > 0 { ... }` spins forever if a parse failure takes the branch that never removes the file from `pending`, and a retry loop written as `for attempts < maxRetries { doWork() }` never terminates because nobody increments `attempts`. The loop is not hung on anything - it is running flat out, one core pinned at 100%. When you review a condition-only loop, the question to ask is: which statement in this body is guaranteed to move the condition towards false, and does every path through the body reach it? The three-clause form is more resistant to this because the post statement makes the progress step syntactically part of the loop header, where it is hard to omit and hard to skip - `continue` still runs it. ### Style notes Braces are always required, even for a one-statement body, and the opening brace is on the same line - gofmt enforces both. Parentheses around the clauses are not written. The empty body `for cond { }` is legal but usually a smell; if you truly want to just advance, say so with a comment.