
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


Generics (introduced in Go 1.18) allow you to write functions and data structures that work with any type satisfying a constraint, without resorting to `interface{}` and type assertions. They eliminate the need to write the same algorithm three times for different element types.

<ExamplePair>
<ExampleProse>

A generic function uses a type parameter list in square brackets. The `any` constraint means the parameter accepts any type. The compiler infers the type argument from the call site - you rarely need to write it explicitly.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

func Filter[T any](s []T, keep func(T) bool) []T {
    var result []T
    for _, v := range s {
        if keep(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    doubled := Map(nums, func(n int) int { return n * 2 })
    fmt.Println(doubled) // [2 4 6 8 10]

    evens := Filter(nums, func(n int) bool { return n%2 == 0 })
    fmt.Println(evens)   // [2 4]
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Constraints restrict which types a type parameter accepts. The `comparable` built-in constraint means the type supports `==` and `!=`. Union constraints (`~int | ~string`) allow a specific set of underlying types.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

// comparable constraint enables == comparisons
func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v {
            return true
        }
    }
    return false
}

// Union constraint: accepts any type with an underlying integer type
type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

func Sum[T Integer](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(Contains([]string{"a", "b", "c"}, "b")) // true
    fmt.Println(Sum([]int{1, 2, 3, 4}))                  // 10
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Generic types let you parameterize a data structure. A typed stack or linked list avoids the `interface{}` cast at every call site while remaining reusable across element types.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "errors"
    "fmt"
)

type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

func (s *Stack[T]) Pop() (T, error) {
    var zero T
    if len(s.items) == 0 {
        return zero, errors.New("stack is empty")
    }
    top := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return top, nil
}

func main() {
    var s Stack[int]
    s.Push(1)
    s.Push(2)
    v, _ := s.Pop()
    fmt.Println(v) // 2
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Generics solve the "write it three times or use `interface{}`" problem for container types - slices, maps, trees, queues. The constraint syntax is verbose but intentional: being explicit about what operations a type parameter must support prevents accidental misuse. Avoid generics for business logic - they add a layer of indirection that makes the code harder to read during an incident without delivering a proportional benefit. The rule of thumb: use generics for utility functions and data structures that would otherwise require reflection or code generation; use concrete types for everything in your application layer.
</InProduction>


Go 1.18 added generics - type parameters let you write functions and types that work across multiple types without losing type safety.

Generics


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.