is there a way to iterate over constant used as enum

I am trying to use enum in golang as below. I am struggling to find a easy way to iterate over the list of constant values. What are common practice in golang to iterate over constant values used as enum. Thanks!

type DayOfWeek int
const(
       Monday DayOfWeek = iota
       Tuesday
       Wednesday
       Thursday
       Friday
       Saturday
       Sunday
      )

In Java, we can iterate as below.

public enum DayOfWeek {
    MONDAY, 
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

for (DayOfWeek day: DayOfWeek.values()) {
   // code logic
}

There is no direct way to enumerate the values/instances of named type at runtime, whether variables or constants, unless you specifically define a slice that lists them. This is left up to the definer or the user of the enumeration type.

package main

import (
    "fmt"
    "time"
)

var Weekdays = []time.Weekday{
    time.Sunday,
    time.Monday,
    time.Tuesday,
    time.Wednesday,
    time.Thursday,
    time.Friday,
    time.Saturday,
}

func main() {
    for _, day := range Weekdays {
            fmt.Println(day)
    }
}

In order be able to generate this list dynamically at runtime, e.g. via reflection, the linker would have to retain all the symbols defined in all packages, like Java does. The golang-nuts group discussed this, regarding names and functions exported from a package, a superset of package constant definitions. https://groups.google.com/forum/#!topic/golang-nuts/M0ORoEU115o

It would be possible for the language to include syntactic sugar for generating this list at compile time if and only if it were referenced by the program. What should the iteration order be, though? If your week starts on Monday the list I defined is not very helpful; you will have to define your own slice to range through the days from Monday to Sunday.

You can do that without reflection.

First execute the Go tools Stringer at compile time using go generate. This creates a file [filename]_string.go which contains a map _[structname]_map of enum values referencing enum variable names as strings. This map is private, so simply assign it to a public map upon package initialization.

var EnumMap map[Enum]string

func init() {
	EnumMap = _Enum_map
}

type Enum uint

//go:generate go run golang.org/x/tools/cmd/stringer -type=Enum

const (
	One Enum = iota
    Two
)

Then you can simply loop over the keys of the map.

The comment from @davec was great. This works perfect when you have a count that increments by one.

You could either do a simple loop such as for d := Monday; d <= Sunday; d++ {}

I had constant that jumped in bits (1,2,4,8,16 etc):

const (
	Approved = 1 << iota
	AlreadyApproved
	NotApproved
	OldTicket
	Unknown
)

I avoided range and did a left shift one to move through my constant:

var score Bits
score = Set(score, AlreadyApproved)

for i := Approved; i < Unknown; i = i << 1 {
	fmt.Println(i)
}

Output:

1
2
4
8
16

Using stringer is preferable it can help you keep your codebase up to date using code generators. Unfortunately stringer does not always generate the map.

For anyone interested in keep using go generators for this purpose I wrote a small code generator called enumall. It produces a file for each provided type with variable holding all values for given type.

Use it by adding code generator comment to your code like this:

//go:generate go run github.com/tomaspavlic/enumall@latest -type=Season

type Season uint8

const (
    Spring Season = 1 << iota
    Summer
    Autumn
    Winter
)

You can find more information here: https://github.com/tomaspavlic/enumall

for i := 0; i <= int(Sunday); i++ {
    fmt.Println(DayOfWeek(i))
}