¿Cómo funciona struct embedding (composition)?

Question

Accepted Answer

Go no tiene **herencia** — en cambio, usa **composición** a través de struct embedding. Al incrustar una struct (o interfaz) dentro de otra, el tipo externo obtiene los campos y métodos del tipo interno directamente. Esta es la respuesta de Go a la reutilización de código, favoreciendo la composición "tiene-un" sobre la herencia "es-un".

## Inserción de una 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
```

La incrustación (escribir solo el nombre de tipo, sin nombre de campo) **promueve** los campos y métodos del tipo incrustado a la struct externa — por lo que `d.Name` y `d.Eat()` funcionan como si pertenecieran a `Dog`. Esto parece herencia pero es composición: `Dog` *tiene un* `Animal`.

## Anulación de métodos promovidos

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

El tipo externo puede definir un método con el mismo nombre para "anular" (sombrear) el promovido; aún puede acceder explícitamente a la versión incrustada.

## Incrustación de interfaces (muy común)

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

La incrustación de interfaz compone interfaces pequeñas en interfaces más grandes — se utiliza en toda la biblioteca estándar.

## Composición sobre herencia — filosofía de 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
```

## Por qué es importante

Struct embedding es el mecanismo distintivo de Go para **reutilización de código y composición**, reemplazando la herencia que se encuentra en la mayoría de los lenguajes OOP.

Comprender esto es esencial porque es cómo Go logra la reutilización (promoviendo campos/métodos incrustados para que el tipo externo "herede" comportamiento a través de composición) mientras evita deliberadamente los problemas bien conocidos de la herencia (clases base frágiles, jerarquías rígidas profundas, acoplamiento estrecho).

Encarna el principio ampliamente respaldado **"composición sobre herencia."** La incrustación aparece constantemente — incrustación de structs para reutilización, incrustación de interfaces para construir contratos más grandes (como `io.ReadWriter`), e incrustación para comportamiento de estilo mixin.

Reconocer que Go no tiene herencia y que la incrustación es su alternativa composicional — más las reglas de promoción de métodos y sombreado — es fundamental para leer y diseñar Go idiomático, y un tema común de entrevista dado cómo difiere de los lenguajes basados en clases.