struct embedding (composition) ਕਿਵੇਂ ਕਾਲਾ ਰਿਹਾ ਹੈ?

Question

Accepted Answer

Go ਦੇ ਕੋਲ **inheritance ਨਹੀਂ ਹੈ** — ਇਸ ਦੀ ਬਜਾਏ ਇਹ struct embedding ਦੁਆਰਾ **composition** ਵਰਤਦਾ ਹੈ। ਇੱਕ struct (ਜਾਂ interface) ਨੂੰ ਦੂਜੇ ਦੇ ਅੰਦਰ embed ਕਰ ਕੇ، outer type ਨੂੰ inner type ਦੇ fields ਅਤੇ methods ਸਿੱਧੇ ਹਾਸਲ ਹੁੰਦੇ ਹਨ۔ ਇਹ Go ਦੀ "has-a" composition کو "is-a" inheritance پر ترجیح دیتے ہوئے code reuse کے لیے جواب ہے۔

## Struct کو embed ਕਰਨਾ

```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 name نہیں) embedded type کے fields اور methods کو outer struct میں **promote** کرتا ہے — تو `d.Name` اور `d.Eat()` ایسے کام کرتے ہیں جیسے وہ `Dog` سے تعلق رکھتے ہوں۔ یہ inheritance جیسا لگتا ہے لیکن composition ہے: `Dog` *has an* `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
```

Outer type ایک جیسے نام کا method define کر سکتا ہے تاکہ promoted کو "override" (shadow) کریں؛ آپ ابھی بھی embedded version کو explicitly reach کر سکتے ہیں۔

## Interfaces کو embed کرنا (بہت عام)

```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 over 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** کے لیے distinctive mechanism ہے، جو زیادہ تر OOP languages میں پائی جانے والی inheritance کو بدل دیتا ہے۔

اس کو سمجھنا ضروری ہے کیونکہ یہ وہ ہے جس سے Go reuse حاصل کرتا ہے (promoted fields/methods کو تاکہ outer type composition کے ذریعے behavior کو "inherit" کرے) جبکہ جان بوجھ کر inheritance کے معروف مسائل سے بچا (fragile base classes، deep rigid hierarchies، tight coupling)۔

یہ broadly قابلِ توثیق اصول **"composition over inheritance"** کو مجسم کرتا ہے۔ Embedding ہر جگہ ظاہر ہوتا ہے — structs کو reuse کے لیے embed کرنا، interfaces کو بڑے contracts بنانے کے لیے embed کرنا (جیسے `io.ReadWriter`)، اور mixin-style behavior کے لیے embed کرنا۔

یہ سمجھنا کہ Go کے پاس inheritance نہیں ہے اور embedding اس کا compositional متبادل ہے — نیز method-promotion اور shadowing rules — idiomatic Go کو پڑھنے اور design کرنے کے لیے بنیادی ہے، اور class-based languages سے اختلاف کی وجہ سے ایک عام interview topic ہے۔