How to use embedding for code organization and modularity in Go?

In Go, embedding is a mechanism that allows one struct type to embed another struct type. This technique can be used for code organization and modularity, enabling code reuse and creating hierarchical structures. Here's how you can use embedding for code organization in Go:

Define a base struct: Start by creating a struct that represents the common functionality or attributes that you want to reuse across different structs. This will serve as the base struct or parent struct.

type Animal struct {
    name string
    age  int
}

Embed the base struct: In another struct where you want to reuse the functionality of the base struct, use embedding to include the base struct field within the child struct. This is done by simply specifying the type of the base struct as an anonymous field in the child struct.

type Dog struct {
    Animal // Embed the Animal struct
    breed  string
}

Access embedded fields and methods: By embedding the Animal struct in the Dog struct, the fields and methods of the Animal struct are automatically available in the Dog struct. You can access these embedded fields and methods directly, as if they belong to the Dog struct.

func main() {
    myDog := Dog{
        Animal: Animal{
            name: "Buddy",
            age:  3,
        },
        breed: "Labrador",
    }
    fmt.Println(myDog.name) // Access the embedded field
    myDog.eat()             // Call an embedded method
}

Override embedded methods: If the child struct wants to override a method defined in the embedded struct, it can simply define a method with the same name in the child struct. This will shadow the embedded method.

type Cat struct {
    Animal // Embed the Animal struct
}

func (c Cat) eat() {
    fmt.Println("The cat is eating")
}

func main() {
    myCat := Cat{
        Animal: Animal{
            name: "Whiskers",
            age:  5,
        },
    }
    myCat.eat() // Calls the overridden eat method in Cat
}

By utilizing embedding, you can create a hierarchy of structs, reuse common functionality, and organize code in a modular way, leading to cleaner and more maintainable Go code.