Right, so you’ve got a set of related constants. You could declare them one by one, manually assigning values. It’s tedious, error-prone, and frankly, a bit barbaric. Enter iota. This little keyword is Go’s way of saying, “I got this,” and it’s how we elegantly define enumerated constants.

The core concept is simple: iota is a predeclared identifier that represents successive untyped integer constants. It starts at zero and increments by one for each item in a constant declaration (const) block. Its real power, though, is in how it resets and how you can use it to build more complex expressions.

The Basic Spice Rack

Let’s start with the simplest possible use case. You’re defining the states for a traffic light or the severity levels for a log.

const (
    Red    = iota // 0
    Amber         // 1 (iota increments)
    Green         // 2
)

const (
    LogDebug = iota // 0 (iota resets to 0 in a new const block)
    LogInfo         // 1
    LogWarn         // 2
    LogError        // 3
)

Notice how after the first line, you don’t have to repeat the = iota? This is because within a const block, the expression (including the iota) is implicitly repeated. It’s a fantastic bit of syntactic sugar that keeps your code clean. The moment you start a new const block, iota resets blissfully back to zero.

Skipping the Zero Value (And Other Tricks)

Sometimes, you want your first value to be something other than 0. Maybe 0 is a meaningful default (a “zero value”) you want to avoid, or you’re mapping to some external system that starts at 1. Easy. You just throw iota into an expression.

const (
    // Start at 1 by adding 1 to the first iota (which is 0)
    FirstThing = iota + 1 // 1
    SecondThing           // 2 (iota is now 1, so 1 + 1 = 2? Wait, no...)
)

Hold on. Let’s clear up a common point of confusion. The implicit repetition rule copies the entire expression. So the above block is actually evaluated like this:

    FirstThing = iota + 1 // iota=0, so 0 + 1 = 1
    SecondThing = iota + 1 // iota=1, so 1 + 1 = 2

It’s not (value of previous constant) + 1; it’s (current iota) + 1. This is a crucial distinction. You can use any expression you like:

const (
    Active = iota * 2  // 0 * 2 = 0 (maybe not what you wanted!)
    Inactive           // 1 * 2 = 2
    Pending            // 2 * 2 = 4
)

// A more practical example: bit masks or permissions
const (
    ReadPermission = 1 << iota // 1 << 0 = 1 (0001)
    WritePermission            // 1 << 1 = 2 (0010)
    ExecutePermission          // 1 << 2 = 4 (0100)
)

The bit shifting example is where iota truly shines, creating distinct bit flags that can be combined with a bitwise OR (|), like ReadPermission | WritePermission.

The Underscore is Your Bouncer

What if you need to skip a value entirely? Maybe it’s reserved or deprecated. You use a blank identifier (_) to tell iota to increment but not assign the value to a usable constant.

const (
    ThingA = iota // 0
    ThingB        // 1
    _             // 2 (skipped, iota still increments)
    _             // 3 (skipped, iota still increments)
    ThingC        // 4
)

This is far cleaner than manually assigning a value to ThingC and hoping you remember why there’s a gap.

When iota Gets a Little… Odd

Here’s a quirk that feels a bit like a design choice made after a long night. iota increments on each line, including empty lines and comment lines. Yes, really. The spec says it increments after each “ConstSpec”. This can lead to some surprising results if you try to format your code for readability.

const (
    A = iota // 0
    B        // 1
    
    C        // 2? Nope. Wait for it...
    // This is just a comment, but iota increments here too!
    D        // 3
)

See that? The empty line and the comment line each caused iota to increment. It’s the kind of thing that can cause a subtle bug if you’re not aware of it. The best practice? Avoid putting blank lines inside your const blocks. Group your constants logically and use comments, but keep the declarations tight.

The Final Word on iota

iota is one of those features that seems trivial until you use it, at which point it becomes indispensable. It enforces consistency, reduces errors, and makes your intent crystal clear. Remember:

  1. It resets to 0 in every const block.
  2. The expression, including the iota, is implicitly repeated for every subsequent line.
  3. It increments on every line within the block, so mind your formatting.
  4. Use it with expressions (+, <<, *) to create powerful sequences.
  5. Use the blank identifier _ to skip values gracefully.

It’s not magic, it’s just good, thoughtful design. Now go use it. Your future self, who isn’t debugging why one constant has the same value as another, will thank you.