Constants, Untyped Constants and iota

### What `iota` actually is `iota` is a *predeclared identifier* in Go, not a keyword and not a runtime variable. You never assign to it. It is meaningful only inside a constant declaration, where the compiler substitutes an integer: the index of the ConstSpec — informally, the line — currently being evaluated inside a parenthesized `const` block. The first line sees `0`, the second `1`, the third `2`. ```go type Status int const ( StatusOpen Status = iota StatusPending StatusClosed ) ``` Here `StatusOpen` is 0, `StatusPending` is 1 and `StatusClosed` is 2. ### The counter belongs to the block `iota` resets to 0 at every `const` keyword. Two const blocks in the same file do not continue one another's numbering, and neither do const blocks in different files of the same package. If you split an enum across two `const (...)` groups, the second group restarts at 0 and you get silent duplicate values — one of the few ways this idiom bites you without any warning from the compiler. ### It counts lines, not names The increment happens once per ConstSpec, not once per declared identifier. So `const ( a, b = iota, iota )` gives `a == 0` and `b == 0`; the *next* line would see `iota == 1`. Comments and blank lines are not ConstSpecs and do not advance the counter. ### It is a compile-time construct Everything `iota` participates in is a constant expression. It is evaluated by the compiler, with exact arithmetic, before the program runs. You cannot write `iota` in a `var` declaration, in a function body, or in a struct literal; the compiler rejects it. That is also why `iota` can only ever produce numbers: constants in Go are limited to booleans, runes, integers, floats, complex values and strings, so there is no such thing as an `iota`-numbered slice or map of constants. ### Why Go uses it: the enum idiom Go deliberately has no `enum` construct. The community idiom is three parts: 1. a defined type — `type Status int` — so a `Status` is not interchangeable with a bare `int`; 2. a `const` block numbered by `iota`; 3. a `String() string` method so the values print as names rather than as digits, usually produced by `//go:generate stringer -type=Status` rather than written by hand. The defined type is the part people skip, and it is the part that buys you anything: without it, every helper that takes a `Status` will happily accept any integer expression in the program. ### What the idiom does *not* give you - **No exhaustiveness.** A `switch` over a `Status` that forgets a case compiles fine. Add a `default` branch that fails loudly rather than falling through silently. - **No range checking.** `Status(99)` is a legal conversion, and a value arriving from JSON, a database column or an RPC payload is just an integer, so it can hold a number no constant names. Validate at the boundary where the value enters your process. - **A meaningful zero value.** Whatever constant gets 0 is the zero value of the type, which means a struct field or a map miss silently reads as that status. Many teams therefore make the first constant an explicit `StatusUnknown` (or `StatusInvalid`) so that an unset field is obviously unset rather than plausibly "open". ### Offsets and variations you will see `iota` is just a number in a constant expression, so it can be shifted and offset: `StatusOpen Status = iota + 1` starts the run at 1, and arithmetic such as `1 << iota` builds bit flags. Those are all ordinary constant expressions; nothing special happens beyond the substitution of the line index. ### Common mistakes to avoid Saying "iota increments every time it appears" (it does not — it is fixed for the whole line), believing the counter survives into the next `const` block, or claiming Go's constants give you a compiler-enforced enum. In an interview, write the three-line block, state the starting value and the reset rule, then mention the defined type — that combination is what the question is really probing.