struct embedding (composition) எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Go-வுக்கு **பரம்பரை (inheritance) இல்லை** — அதற்குப் பதிலாக **composition** ஐ struct embedding மூலம் பயன்படுத்துகிறது. ஒரு struct (அல்லது interface) ஐ மற்றொன்றுக்குள் embedding செய்வதன் மூலம், வெளிப்புற type-க்கு உள்ளீட்டு type-ன் fields மற்றும் methods நேரடியாக கிடைக்கும். இது Go-வின் code reuse-க்கான பதில் ஆகும், இது "is-a" inheritance-ஐ விட "has-a" composition-ஐ விரும்புகிறது.

## Struct embedding

```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 (வெறும் type பெயரை எழுதுதல், field பெயர் இல்லை) உட்பொதிக்கப்பட்ட type-ன் fields மற்றும் methods-ஐ வெளிப்புற struct-க்கு **promote** செய்கிறது — எனவே `d.Name` மற்றும் `d.Eat()` அவை `Dog`-க்கு சொந்தமாக இருப்பதைப் போல செயல்படுகின்றன. இது பரம்பரை போல் தோன்றினாலும் composition ஆகும்: `Dog` *ஒரு* `Animal` *கொண்டுள்ளது*.

## Promoted methods-ஐ override செய்தல்

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

வெளிப்புற type-க்கு promoted method-ஐ "override" (shadow) செய்ய அதே பெயரில் method வரையறுக்க முடியும்; நீங்கள் இன்னும் embedded version-ஐ explicitly அணுக முடியும்.

## Interfaces embedding (மிகவும் பொதுவானது)

```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 சிறிய interfaces-ஐ பெரியவற்றுக்குள் compose செய்கிறது — standard library முழுவதிலும் பயன்படுத்தப்படுகிறது.

## Composition vs inheritance — 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
```

## இது ஏன் முக்கியமாகும்

Struct embedding என்பது Go-வின் வேறுபட்ட **code reuse மற்றும் composition** பொறிமுறை ஆகும், இது பெரும்பாலான OOP languages-ல் உள்ள பரம்பரையை மாற்றுகிறது.

இதை புரிந்துகொள்வது அত்यন்த முக்கியமாகும் ஏனெனில் இது Go-வின் reuse அடைய நடவடிக்கை (embedded fields/methods-ஐ promote செய்வதற்கால் வெளிப்புற type composition மூலம் behavior "inherit" செய்கிறது) பரம்பரையின் நன்கறிந்த சிக்கல்கள் (fragile base classes, deep rigid hierarchies, tight coupling) ஐ வேண்டுமென்றே தவிர்க்கும் செயல்பாட்டைக் கொண்டிருக்கிறது.

இது பரவலாக ஒப்புக்கொள்ளப்பட்ட **"composition over inheritance"** கோட்பாட்டை செயல்படுத்துகிறது. Embedding நிரந்தரமாக தோன்றுகிறது — reuse-க்காக structs embedding, பெரிய contracts-ஐ உருவாக்கிய interfaces embedding (`io.ReadWriter`போல), மற்றும் mixin-style behavior-க்கான embedding.

Go-வுக்கு பரம்பரை இல்லை என்பதையும், embedding என்பது அதன் compositional alternative என்பதையும் — plus method-promotion மற்றும் shadowing rules — விளங்கிக்கொள்வது idiomatic Go-ஐ வாசிப்பதற்கும் வடிவமைப்பதற்கும் அடிப்படையாகும், மேலும் class-based languages-ல் இருந்து பொதுவான பேட்டி கேள்வியாகும்.