How does struct embedding (composition) work?

Question

Accepted Answer

Go has **no inheritance** — instead it uses **composition** via struct embedding. By embedding one struct (or interface) inside another, the outer type gains the inner type's fields and methods directly. This is Go's answer to code reuse, favoring "has-a" composition over "is-a" inheritance.

## Embedding a struct

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

Embedding (writing just the type name, no field name) **promotes** the embedded type's fields and methods to the outer struct — so `d.Name` and `d.Eat()` work as if they belonged to `Dog`. This looks like inheritance but is composition: `Dog` *has an* `Animal`.

## Overriding promoted methods

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

The outer type can define a method with the same name to "override" (shadow) the promoted one; you can still reach the embedded version explicitly.

## Embedding interfaces (very common)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

Interface embedding composes small interfaces into larger ones — used throughout the standard library.

## Composition over inheritance — the Go philosophy

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

## Why it matters

Struct embedding is Go's distinctive mechanism for **code reuse and composition**, replacing the inheritance found in most OOP languages.

Understanding it is essential because it's how Go achieves reuse (promoting embedded fields/methods so the outer type "inherits" behavior through composition) while deliberately avoiding inheritance's well-known problems (fragile base classes, deep rigid hierarchies, tight coupling).

It embodies the widely-endorsed principle **"composition over inheritance."** Embedding appears constantly — embedding structs for reuse, embedding interfaces to build larger contracts (like `io.ReadWriter`), and embedding for mixin-style behavior.

Recognizing that Go has no inheritance and that embedding is its compositional alternative — plus the method-promotion and shadowing rules — is fundamental for reading and designing idiomatic Go, and a common interview topic given how it differs from class-based languages.