Stricter Go enums with go-genums

Go has an idiomatic way to declare enums, that is by many (me included) praised for its simplicity:

type Day int
const (
   Monday Day = 1 + iota
   Tuesday
   Wednesday
   Thursday
   Friday
   Saturday
   Sunday
)

Other languages have usually more features for enum types, for example in Java:

public enum Day {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday 
}

And then you can use features like:

for (Day day: Day.values()) {
    if (day == Day.Monday) {
       System.out.printf("Monday is day number %d\n", day.ordinal());
    }
    System.out.printf("Day of the week: %s\n", day);
}

In C# you can benefit from similar type-safety checks, and a slightly different syntax for the base type:

enum Days : byte {Monday=1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

Let’s give now another look at the same enum in Go, with focus on what we could make use of:

type Day int // a String() method for each value, so that we can printf it during development/logging?
const (
   Monday Day = 1 + iota // more complex types maybe?
   Tuesday
   Wednesday
   Thursday
   Friday
   Saturday
   Sunday
   // boundary check so that I cannot inadvertently create an 8th day of the week?
)
// array/slice of allowed values?

In a discussion with other Go coders I came up with the idea of using a slightly stricter syntax for Go enums, (ab)using type switches and the marvels of templating (with go:generate), the result of which is the go-genums project.

The generated code for this weekdays example with go-genums is (some parts redacted for simplicity):

package main

// *** generated with go-genums ***

// DayEnum is the the enum interface that can be used
type DayEnum interface {
	String() string
	Value() dayEnum
	uniqueDayMethod()
}

// dayEnumBase is the internal, non-exported type
type dayEnumBase struct{ value dayEnum }

// Value() returns the enum value
func (eb dayEnumBase) Value() dayEnum { return eb.value }

// String() returns the enum name as you use it in Go code,
// needs to be overriden by inheriting types
func (eb dayEnumBase) String() string { return "" }

// ... [redacted declaration of a type+methods for each allowed enum value]

var internalDayEnumValues = []DayEnum{
	Sunday{}.New(),
	Monday{}.New(),
	Tuesday{}.New(),
	Wednesday{}.New(),
	Thursday{}.New(),
	Friday{}.New(),
	Saturday{}.New(),
}

// DayEnumValues will return a slice of all allowed enum value types
func DayEnumValues() []DayEnum { return internalDayEnumValues[:] }

// NewDayFromValue will generate a valid enum from a value, or return nil in case of invalid value
func NewDayFromValue(v dayEnum) (result DayEnum) {
	switch v {
	case daySunday:
		result = Sunday{}.New()
	case dayMonday:
		result = Monday{}.New()
	case dayTuesday:
		result = Tuesday{}.New()
	case dayWednesday:
		result = Wednesday{}.New()
	case dayThursday:
		result = Thursday{}.New()
	case dayFriday:
		result = Friday{}.New()
	case daySaturday:
		result = Saturday{}.New()
	}
	return
}

// ... [redacted]

The resulting generated enum code is nonetheless longer and more complex, but you do not have to type it as it’s auto-generated; among the features added by this code generation step, the one I personally like most is the possibility to use type switches for enum evaluation:

day := Monday{}.New()
switch day.(type) {
    case Monday:
        fmt.Println("It's", day)
    default:
        panic("It's not Monday!")
}

Note here that a type switch over an interface value is still pretty efficient, as it will not de-reference the actual value (be it an int or a large struct) but rather use Go’s internal type id.

Last but not least, with go-genums you can use structs for your enum declaration and auto-generated validating factory methods, and you do not loose the capability of directly comparing enum variables; you can read more and play around with it at the github project page.