Golang Tutorial: Enums and Custom Types (Chapter 22)

Enums (Enumerated Types) are widely used across programming languages to represent a fixed group of related constant values. While Go does not have a dedicated enum keyword like TypeScript, Java, or C#, it provides robust mechanisms to implement them cleanly using custom types, constant blocks, and the iota identifier.

1. Why Do We Need Enums? (The Problem Statement)

Imagine building an e-commerce backend where order statuses change dynamically across the lifecycle of an order (e.g., received, confirmed, prepared, delivered).

A naive approach relies entirely on passing raw strings into functions:

package main

import "fmt"

func changeOrderStatus(status string) {
    fmt.Printf("Changing order status to: %s\n", status)
}

func main() {
    // Naive string usage
    changeOrderStatus("received")
    changeOrderStatus("confrmd") // Typo! But the compiler accepts it without error.
}

Real-World Pitfalls of Raw Strings

• Typo Vulnerability: Passing raw strings means a simple typo (like "confrmd" instead of "confirmed") compiles successfully and only breaks business logic at runtime.
• Refactoring Nightmare: If you need to rename a status string (e.g., changing "confirmed" to "order_confirmed"), you must hunt down and manually update every occurrence across multiple files in your project.
• Discoverability & Autocompletion: Developers consuming the function have to memorize or guess valid status strings without IDE assistance.

2. Core Mental Model: Grouping Related Constants

In a professional application, related options (such as User Roles, Categories, or Order States) belong together as a closed set.

Instead of letting callers pass arbitrary strings or numbers, we group valid options into a strict, unified domain vocabulary using custom types and constants.

3. Creating Custom Types in Go

Before implementing Enums, it helps to understand that Go allows developers to create custom types based on built-in primitives (similar to Type Aliases in TypeScript).

package main

// Defining a custom type based on a string
type MyType string

func main() {
    var val MyType = "Hello World"
    println(val)
}

This capability serves as the foundation for creating type-safe Enums in Go.

4. Implementing Enums via Integer Constants and iota

To optimize performance and memory, developers often represent Enums as integers. Go provides a special pre-declared identifier called iota to simplify sequential integer constant generation.

Step-by-Step Code Evolution: Integer-Based Enum

package main

import "fmt"

// 1. Define a custom integer-based type for domain safety
type OrderStatus int

// 2. Group related constants using a const block and iota
const (
	Received  OrderStatus = iota // Assigned 0 automatically
	Confirmed                    // Assigned 1 automatically
	Prepared                     // Assigned 2 automatically
	Delivered                    // Assigned 3 automatically
)

func changeOrderStatus(status OrderStatus) {
	fmt.Printf("Changing order status to: %v\n", status)
}

func main() {
	// 3. Pass strongly typed constants instead of raw strings
	changeOrderStatus(Received)  // Prints: Changing order status to: 0
	changeOrderStatus(Prepared)  // Prints: Changing order status to: 2
}

Note on iota: iota is a zero-indexed auto-incrementing counter managed by the Go compiler inside a const block. Every time a new constant is declared in the block, iota increments by 1.

5. Implementing String-Based Enums

If your database or API requires explicit string values rather than underlying integers (for logging or JSON serialization), you can assign string literals to your custom type instead of using iota.

String-Based Enum Implementation

package main

import "fmt"

// 1. Define a custom string-based type
type OrderStatus string

// 2. Group string constants mapped to our custom type
const (
	Received  OrderStatus = "received"
	Confirmed OrderStatus = "confirmed"
	Prepared  OrderStatus = "prepared"
	Delivered OrderStatus = "delivered"
)

func changeOrderStatus(status OrderStatus) {
	fmt.Printf("Changing order status to: %s\n", status)
}

func main() {
	// 3. Pass clean, readable string-backed enum constants
	changeOrderStatus(Prepared) // Prints: Changing order status to: prepared
}

6. Comparison: Integer-Based vs. String-Based Enums

7. IDE Benefits and Developer Experience

Implementing Enums with custom types and constants transforms the developer experience in modern IDEs like VS Code:

• Type Enforcement: The Go compiler throws a compile-time error if a raw string or unrelated integer is passed into changeOrderStatus(status OrderStatus).
• IntelliSense Autocompletion: Modern editors read the custom type signature and immediately suggest valid enum values when Ctrl + Space is triggered.
• Centralized Refactoring: Renaming a constant in the const block safely updates its definition across all imported packages and files.

8. Summary and Key Takeaways

• No Native Keyword: Go does not have a dedicated enum keyword, but achieves identical behavior through idiomatic combination of type and const.
• Custom Types: Always wrap primitive types (int or string) into domain-specific custom types (e.g., type OrderStatus string) to prevent invalid argument passing.
• The iota Keyword: Use iota for concise, zero-indexed, auto-incrementing integer constant generation.
• String Backing: Assign explicit string values to custom types when human-readable log output or direct API/Database compatibility is required.
• Compile-Time Safety: Replacing raw strings with typed constants catches typos during compilation rather than crashing in production.
• Enhanced Autocompletion: Properly typed constants enable rich IDE autocompletion and drastically improve code discoverability.
• Real-World Domain Modeling: Enums are best utilized for bounded states, such as order lifecycles, user access roles, and payment categories.