Come funziona l'embedding di struct (composition)?

Question

Accepted Answer

Go **non ha ereditarietà** — utilizza invece **composition** tramite embedding di struct. Incorporando uno struct (o un'interfaccia) dentro un altro, il tipo esterno acquisisce i campi e i metodi del tipo interno direttamente. Questa è la risposta di Go al riuso del codice, favorendo la composizione "has-a" rispetto all'ereditarietà "is-a".

## Embedding di uno 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
```

L'embedding (scrivere solo il nome del tipo, senza nome di campo) **promuove** i campi e i metodi del tipo incorporato allo struct esterno — quindi `d.Name` e `d.Eat()` funzionano come se appartenessero a `Dog`. Questo assomiglia all'ereditarietà ma è composition: `Dog` *ha un* `Animal`.

## Shadowing di metodi promossi

```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
```

Il tipo esterno può definire un metodo con lo stesso nome per "shadowing" del metodo promosso; è comunque possibile raggiungere la versione incorporata esplicitamente.

## Embedding di interfacce (molto comune)

```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)
```

L'embedding di interfacce compone interfacce piccole in interfacce più grandi — utilizzato in tutto la libreria standard.

## Composition over inheritance — la filosofia Go

```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
```

## Perché è importante

L'embedding di struct è il meccanismo distintivo di Go per **riuso del codice e composition**, sostituendo l'ereditarietà presente nella maggior parte dei linguaggi OOP.

Comprenderlo è essenziale perché è il modo in cui Go ottiene il riuso (promuovendo campi/metodi incorporati in modo che il tipo esterno "erediti" il comportamento attraverso la composition) evitando deliberatamente i problemi noti dell'ereditarietà (classi base fragili, gerarchie rigide profonde, tight coupling).

Incarna il principio ampiamente riconosciuto **"composition over inheritance."** L'embedding appare costantemente — embedding di struct per il riuso, embedding di interfacce per costruire contratti più grandi (come `io.ReadWriter`), e embedding per comportamenti in stile mixin.

Riconoscere che Go non ha ereditarietà e che l'embedding è la sua alternativa composizionale — più le regole di promozione e shadowing dei metodi — è fondamentale per leggere e progettare Go idiomatico, ed è un argomento comune negli interview considerando come differisce dai linguaggi basati su classi.