Enums in Go

1. Define a named type   →  type Status int
2. Declare constants     →  const ( Active Status = iota ... )
3. Add String() method   →  func (s Status) String() string { ... }

const (
    A = iota  // 0  ← iota starts here
    B         // 1  ← iota auto-increments
    C         // 2
)

// Step 1 — named type (prevents mixing with plain int)
type Direction int
 
// Step 2 — constants using iota
const (
    North Direction = iota // 0
    East                   // 1
    South                  // 2
    West                   // 3
)
 
// Step 3 — String() so fmt.Println shows "North", not "0"
func (d Direction) String() string {
    switch d {
    case North: return "North"
    case East:  return "East"
    case South: return "South"
    case West:  return "West"
    default:    return fmt.Sprintf("Direction(%d)", d)
    }
}
 
fmt.Println(North) // "North"  ← readable!
fmt.Println(East)  // "East"

type Status int
 
const (
    _        Status = iota // skip 0
    Active                 // 1
    Inactive               // 2
    Banned                 // 3
)

var s Status        // = 0
fmt.Println(s == Active) // ❌ true! That's wrong — s was never set

type Permission int
 
const (
    Read    Permission = 1 << iota // 1  → 001
    Write                          // 2  → 010
    Execute                        // 4  → 100
)
 
perm := Read | Write       // combine: 3 → 011
fmt.Println(perm & Write != 0) // true — has write
fmt.Println(perm & Execute != 0) // false — no execute

type Environment string
 
const (
    Production  Environment = "production"
    Staging     Environment = "staging"
    Development Environment = "development"
)
 
fmt.Println(Production) // "production" — no String() needed