Posted on Jul 3

Implementing Enum Types in Go

Preface

Enumeration types are a commonly used data type for representing a limited, predefined set of named constant values. In an enumeration type, each constant is an enum value, and all values are equal and unique.

Enumeration types are typically used to represent a set of related constants, such as days of the week, months, gender, etc. In other languages (such as Java and C), enumeration types are built-in. However, Go does not have a built-in enumeration type, so we need to use other approaches to implement similar enum functionality. This article will demonstrate how to implement an "enumeration type".

"Enumeration Types" in Go

The values of enumeration types are essentially constants, so we can use constants in Go to implement similar enum functionality. For example:

const ( Sunday = 1 Tuesday = 2 Wednesday = 3 Thursday = 4 Friday = 5 Saturday = 6 Monday = 7 )

In this example, we use the const keyword to define a group of constants, where each constant's name represents an enum and its value corresponds to an integer.

Although this example achieves functionality similar to an enum type, it lacks some characteristics of true enum types, such as safety and constraints. To address these two issues, we can use custom types for improvement:

type WeekDay int const ( Sunday WeekDay = 1 Tuesday WeekDay = 2 Wednesday WeekDay = 3 Thursday WeekDay = 4 Friday WeekDay = 5 Saturday WeekDay = 6 Monday WeekDay = 7 )

In the improved example, we define a custom type WeekDay to represent the days of the week. We then use the const keyword to define a group of constants, where each constant is assigned a specific value and constrained by the WeekDay type for type enforcement and checking. This allows us to use the enum value names to represent specific days of the week, and because of the custom type, the compiler can perform type checking, thereby improving type safety.

Gracefully Implementing Enums Using `iota`

From the previous example, it is easy to see that manually assigning values to each enum constant becomes quite cumbersome when multiple enum values are needed. To solve this problem, we can use the iota constant generator, which helps us generate sequential integer values.
For example, we can define a weekday enum type using iota:

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

In this example, we use the auto-incrementing constant generator iota to define an enumeration type for weekdays. Each enum value is a constant of type WeekDay. Due to the auto-increment rule of iota, each enum value will automatically increment, generating a series of consecutive integer values.

Adding Methods to Custom Enums

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

To make our implemented "enum type" more closely resemble enums in other languages such as Java, we can add methods to it.

`Name()`

Returns the name of the enum value.

// Name returns the name of the enum value func (w WeekDay) Name() string { if w < Sunday || w > Monday { return "Unknown" } return [...]string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}[w] }

`Original`

Returns the position of the enum value in the enum type.

// Original: Since enum values in this type are essentially integer constants, // we can directly use the enum value as its index. func (w WeekDay) Original() int { return int(w) }

`String()`

Implements the String method for formatted output.

// Converts the enum value to a string for easy output func (w WeekDay) String() string { return w.Name() }

`Values()`

Returns a slice containing all enum values.

// Values returns a slice containing all enum values func Values() []WeekDay { return []WeekDay{Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday} }

`ValueOf()`

Returns the corresponding enum value based on the name.

// ValueOf uses a switch statement to return the corresponding enum value based on the name func ValueOf(name string) (WeekDay, error) { switch name { case "Sunday": return Sunday, nil case "Monday": return Monday, nil case "Tuesday": return Tuesday, nil case "Wednesday": return Wednesday, nil case "Thursday": return Thursday, nil case "Friday": return Friday, nil case "Saturday": return Saturday, nil default: return 0, fmt.Errorf("invalid WeekDay name: %s", name) } }

Summary

In day-to-day development, enumeration types are very commonly used. Although Go does not have built-in enum types, it does not prevent us from implementing a similar "enum type" ourselves. When implementing it, we need to consider issues of type constraint and safety.

There are many ways to implement enum-like functionality. This article has introduced an approach using custom types. Once you understand the core idea, you can also implement similar enum functionality using structures or other techniques.