You may recall from yesterday that you can omit the constant expression for all but the first ConstantSpec in a parenthesized constant declaration, but that it wasn’t very useful by itself.

Enter iota…

Iota

Within a constant declaration, the predeclared identifier iota represents successive untyped integer constants. Its value is the index of the respective ConstSpec in that constant declaration, starting at zero. It can be used to construct a set of related constants:

const (
	c0 = iota  // c0 == 0
	c1 = iota  // c1 == 1
	c2 = iota  // c2 == 2
)

const (
	a = 1 << iota  // a == 1  (iota == 0)
	b = 1 << iota  // b == 2  (iota == 1)
	c = 3          // c == 3  (iota == 2, unused)
	d = 1 << iota  // d == 8  (iota == 3)
)

const (
	u         = iota * 42  // u == 0     (untyped integer constant)
	v float64 = iota * 42  // v == 42.0  (float64 constant)
	w         = iota * 42  // w == 84    (untyped integer constant)
)

const x = iota  // x == 0
const y = iota  // y == 0

With the automatic iota constant, we can expand yesterday’s example to do something interesting:

	const (
		one = iota+1
		two
		three
	)
	fmt.Println(one, two, three)

Now it prints: 1 2 3

And what’s more, as you can see in the quoted examples above, you can perform various operations on the iota result, to manipulate it to a form you care about:

	const (
		a = string(byte(iota + 65))
		b
		c
	)
	fmt.Println(a, b, c)

Prints: A B C

But you don’t have to combine iota with the omitted expression. You can explicitly use iota on all, or only some, of the ConstantSpecs:

		a = string(byte(iota + 65))
		b
		c = iota
		d
		e = iota * 10
		f
	)
	fmt.Println(a, b, c, d, e, f)

Prints: A B 2 3 40 50

Quotes from The Go Programming Language Specification Version of December 15, 2022