
Go does not have a first-class enum construct. The idiomatic approach is a typed integer constant group using `iota`, which increments automatically within a `const` block. This gives you type safety and a compact declaration, while keeping the language simple.

<ExamplePair>
<ExampleProse>

Declare a named integer type and a block of constants using `iota`. The first constant in the block gets `iota = 0`, and each subsequent constant increments it by one.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Direction int

const (
    North Direction = iota
    East
    South
    West
)

func main() {
    d := North
    fmt.Println(d)        // 0
    fmt.Println(d == North) // true
    fmt.Println(East)     // 1
    fmt.Println(West)     // 3
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Implement the `fmt.Stringer` interface so your enum prints a readable name instead of an integer. This also makes log output and test failures much easier to read.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Weekday int

const (
    Monday Weekday = iota + 1
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
)

func (w Weekday) String() string {
    names := [...]string{"Monday", "Tuesday", "Wednesday",
        "Thursday", "Friday", "Saturday", "Sunday"}
    if w < Monday || w > Sunday {
        return fmt.Sprintf("Weekday(%d)", int(w))
    }
    return names[w-1]
}

func main() {
    fmt.Println(Wednesday) // Wednesday
    fmt.Println(Weekday(9)) // Weekday(9)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Use bitwise expressions with `iota` for flag-style enums where values can be combined with the `|` operator. Each constant is a power of two, so flags can be OR'd and AND'd together.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Permission int

const (
    Read    Permission = 1 << iota // 1
    Write                          // 2
    Execute                        // 4
)

func (p Permission) String() string {
    result := ""
    if p&Read != 0 {
        result += "r"
    }
    if p&Write != 0 {
        result += "w"
    }
    if p&Execute != 0 {
        result += "x"
    }
    return result
}

func main() {
    p := Read | Write
    fmt.Println(p)           // rw
    fmt.Println(p&Execute != 0) // false - execute not set
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Go has no built-in exhaustiveness check for enum values - a switch statement that handles only some constants compiles without warning. Add a `default` case that panics or logs an error so you discover unhandled values when a new constant is added, rather than in a production incident. The `stringer` tool (`go generate` with `//go:generate stringer -type=MyType`) automates the `String()` method and keeps it in sync with the constants automatically - far safer than a hand-written string array that silently goes stale when constants are added or reordered.
</InProduction>


Go has no built-in enum type - idiomatic enums use typed integer constants with iota to generate sequential values.

Enums


Go has no inheritance. Instead, you embed one struct type inside another - the embedded type's fields and methods are promoted to the outer struct. This is composition, not inheritance: the embedded type retains its own identity and the outer struct does not become a subtype.

<ExamplePair>
<ExampleProse>

Embed a struct by including it as an unnamed field. The outer struct gains access to all of the embedded type's exported fields and methods as if they were defined directly on it.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Animal struct {
    Name string
}

func (a Animal) Speak() string {
    return a.Name + " makes a sound"
}

type Dog struct {
    Animal        // embedded - no field name
    Breed string
}

func main() {
    d := Dog{
        Animal: Animal{Name: "Rex"},
        Breed:  "Labrador",
    }
    fmt.Println(d.Name)    // promoted from Animal
    fmt.Println(d.Speak()) // promoted from Animal
    fmt.Println(d.Breed)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The outer struct can define its own method with the same name to override the promoted one. The embedded type's version is still accessible via the full field path.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Base struct{}

func (b Base) Describe() string { return "I am Base" }

type Extended struct {
    Base
    label string
}

func (e Extended) Describe() string {
    return "I am Extended (" + e.label + ")"
}

func main() {
    e := Extended{label: "custom"}
    fmt.Println(e.Describe())      // I am Extended (custom)
    fmt.Println(e.Base.Describe()) // I am Base - still accessible
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Embedding interfaces inside structs is a common pattern for building partial implementations or mock types. The embedded interface provides default method stubs; the outer struct overrides only the methods it needs.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Logger interface {
    Log(msg string)
    Prefix() string
}

// DiscardLogger satisfies Logger but does nothing
type DiscardLogger struct{}

func (d DiscardLogger) Log(msg string) {}
func (d DiscardLogger) Prefix() string { return "" }

type ServiceLogger struct {
    DiscardLogger          // inherit the no-op Log
    prefix        string
}

// Override only Prefix
func (s ServiceLogger) Prefix() string { return s.prefix }

func emit(l Logger, msg string) {
    fmt.Printf("[%s] %s\n", l.Prefix(), msg)
}

func main() {
    emit(ServiceLogger{prefix: "svc"}, "started")
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Struct embedding promotes the embedded type's method set to the outer struct, which can accidentally satisfy interfaces you did not intend to implement. In public packages, add compile-time interface checks (`var _ InterfaceName = MyType{}`) to make the intent explicit and catch surprises early. Engineers who come from class-based languages sometimes try to use embedding as inheritance and are surprised when they cannot call a "parent" method from within an "overriding" method - Go has no `super`. Design your type hierarchies with composition explicitly in mind: embed for reuse, not for subtyping.
</InProduction>


Go uses struct embedding instead of inheritance - embedding promotes another type's fields and methods to the outer struct.

Struct Embedding


Go interfaces define a set of method signatures. Any type that implements those methods satisfies the interface automatically - there is no `implements` keyword. This implicit satisfaction is one of Go's most powerful design decisions.

<ExamplePair>
<ExampleProse>

Define an interface with one or more method signatures. Any type with those methods satisfies it - even types defined in other packages that were never written with your interface in mind.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "math"
)

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64      { return math.Pi * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.Radius }

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64      { return r.Width * r.Height }
func (r Rectangle) Perimeter() float64 { return 2 * (r.Width + r.Height) }

func printShape(s Shape) {
    fmt.Printf("area=%.2f perimeter=%.2f\n", s.Area(), s.Perimeter())
}

func main() {
    printShape(Circle{Radius: 5})
    printShape(Rectangle{Width: 3, Height: 4})
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The empty interface `any` (equivalent to `interface{}`) is satisfied by every type. Use it when a function must accept values of unknown type, but prefer concrete types or constrained generics when possible.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func describe(v any) {
    fmt.Printf("value=%v type=%T\n", v, v)
}

func main() {
    describe(42)
    describe("hello")
    describe(true)
    describe([]int{1, 2, 3})
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

A type assertion extracts the concrete value from an interface variable. Use the two-value form `v, ok := i.(T)` to avoid a panic when the assertion may fail.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Stringer interface {
    String() string
}

type Point struct{ X, Y int }

func (p Point) String() string { return fmt.Sprintf("(%d, %d)", p.X, p.Y) }

func tryString(v any) {
    if s, ok := v.(Stringer); ok {
        fmt.Println("Stringer:", s.String())
    } else {
        fmt.Printf("not a Stringer: %T\n", v)
    }
}

func main() {
    tryString(Point{1, 2})
    tryString(42)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Compose interfaces from smaller ones. `io.ReadWriter` in the standard library is exactly this pattern - it combines `io.Reader` and `io.Writer` into a single interface.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

type Reader interface {
    Read() string
}

type Writer interface {
    Write(s string)
}

type ReadWriter interface {
    Reader
    Writer
}

type Buffer struct{ data string }

func (b *Buffer) Read() string      { return b.data }
func (b *Buffer) Write(s string)    { b.data = s }

func process(rw ReadWriter) {
    rw.Write("hello")
    fmt.Println(rw.Read())
}

func main() {
    process(&Buffer{})
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Keep interfaces small - ideally one or two methods - and define them at the point of use, not in the package that implements them. A large interface in a shared package becomes a coupling magnet: every implementer must satisfy every method even when it only needs one. The `io.Reader` and `io.Writer` pattern is the north star: one method, infinite composability. When you need a compile-time check that a type satisfies an interface, add `var _ MyInterface = (*MyType)(nil)` near the type definition - it costs nothing at runtime and catches method signature drift immediately.
</InProduction>


Go interfaces are satisfied implicitly - any type that implements the required methods satisfies the interface, no declaration needed.