Struct embedding (composition) कसे काम करते?

Question

Accepted Answer

Go-चे **कोणतेही inheritance नाही** — त्याऐवजी हे **struct embedding द्वारे composition** वापरते. एक struct (किंवा interface) दुसरे struct-मध्ये embed करून, बाहेरील 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-चे नाव नाही) embedded type-चे fields आणि methods बाहेरील struct-ला **promote** करते — म्हणून `d.Name` आणि `d.Eat()` असे काम करतात जणू ते `Dog`-ला व्यक्तिगत आहेत. हे inheritance सारखे दिसते पण 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 समान नावाचा method परिभाषित करू शकते promoted method-ला "shadow" करण्यासाठी; तरीही आप 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-ला मोठ्या interfaces-मध्ये compose करते — पूर्ण standard library-मध्ये वापरले जाते.

## Composition over inheritance — Go-चा philosophy

```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 हा **code reuse आणि composition** साठी Go-चा अनोखा mechanism आहे, जो बहुतेक OOP languages-मध्ये पाहिल्या जाणाऱ्या inheritance-ची जागा घेते.

हे समजणे महत्वाचे आहे कारण Go कसे code reuse साधते (embedded fields/methods-ला promote करून जेणेकरून बाहेरील type composition-द्वारे behavior "inherit" करते) तेव्हा जाणूनबुजून inheritance-चे ज्ञात समस्या (fragile base classes, deep rigid hierarchies, tight coupling) टाळते.

हे व्यापकपणे मान्यताप्राप्त तत्त्व **"composition over inheritance."** अवतारत करते. Embedding सतत दिसते — reuse-साठी struct embedding, मोठ्या contracts build करण्यासाठी interface embedding (जसे `io.ReadWriter`), आणि mixin-style behavior-साठी embedding.

हे जाणून घेणे की Go-चे कोणतेही inheritance नाही आणि embedding हा त्याचा compositional पर्याय आहे — plus method-promotion आणि shadowing rules — idiomatic Go read आणि design करण्यासाठी महत्वाचे आहे, आणि class-based languages-पेक्षा हे वेगळे आहे हे research केल्यास एक सामान्य interview topic आहे.