Kif taħdem struct embedding (composition)?

Question

Accepted Answer

Go **m'għandux inheritance** — minflok uso **composition** permezz ta' struct embedding. Billi tuddaħħal struct wieħed (jew interface) ġewwa struct ieħor, it-tip ta' barra jinkiseb il-fields u l-metodi tat-tip ta' ġewwa direttament. Din hija t-tweġiba ta' Go għar-riużu tal-kodiċi, u titfavor il-komposizzjoni "has-a" fuq l-inheritance "is-a".

## Embedding 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 (iktib biss l-isem tat-tip, mingħajr isem tal-field) **ipromwovi** il-fields u l-metodi tat-tip mudaħħal lit-struct ta' barra — allura `d.Name` u `d.Eat()` jaħdmu bħallikieku jappartjenu lil `Dog`. Dan jidher bħal inheritance imma huwa composition: `Dog` *għandu* `Animal`.

## Override tal-metodi mpromwovuti

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

It-tip ta' barra jista' jiddefinixxi metodu bl-istess isem biex "shadow" dak li mpromwovut; xorta tista' taċċessa l-verżjoni mudaħħla b'mod esplicitu.

## Embedding interfaces (komuni ħafna)

```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 tal-interface jikkomponi interfaces żgħar f'dawk akbar — użat madwar il-librerija standard.

## Composition over inheritance — il-filosofija ta' 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
```

## Għaliex hija importanti

Struct embedding huwa l-mekkaniżmu distintivu ta' Go għall-**riużu tal-kodiċi u l-composition**, li jinbidel l-inheritance misjuħ fil-ħafna mill-lingwi OOP.

L-għarfien tiegħu huwa essenzjali għaliex huwa l-mod kif Go nċarriż ir-riużu (billi jpromwovi fields/metodi mudaħħla għalmod li t-tip ta' barra "jirċievi" il-immuş permezz tal-composition) filwaqt li deliberatament jevita l-problemi magħrufin tal-inheritance (klassijiet bażi fraġli, ġerarkiji riġidi u fond, konnessjoni strettu).

Hija tajba l-prinċipju wieħed mifhum ħafna **"composition over inheritance."** L-embedding jidher kostantement — embedding struct għar-riużu, embedding interfaces biex ibnied kuntratti akbar (bħal `io.ReadWriter`), u embedding għal immuş stil mixin.

Ir-rikonoxximent li Go m'għandux inheritance u li l-embedding huwa l-alternattiva komposizzjonali tiegħu — flimkien mar-regoli tal-promozzjoni tal-metodi u t-shadowing — huwa fundamentali biex aqra u tiddisinja Go idiomatiku, u suġġett komuni fl-intervisti li jingħata l-fatt kif jidiferi mill-lingwi bbażati fuq klassijiet.