Understanding embedding in Go

Question

I am trying understanding Google Go's embedding mechanism (as an alternative to subclassing). Below is a simple program that summarizes my problem with the approach:

package main

import "fmt"

type Person struct {
    Name string
}

func (p *Person) Talk() {
    fmt.Println("Hi, my name is Person")
}

func (p *Person) TalkVia() {
    fmt.Println("TalkVia ->")
    p.Talk()
}

type Android struct {
    Person
}

func (p *Android) Talk() {
    fmt.Println("Hi, my name is Android")
}

func main() {
    fmt.Println("Person")
    p := new(Person)
    p.Talk()
    p.TalkVia()

    fmt.Println("Android")
    a := new(Android)
    a.Talk()
    a.TalkVia()
}

The output is:

Person
Hi, my name is Person
TalkVia ->
Hi, my name is Person
Android
Hi, my name is Android
TalkVia ->
Hi, my name is Person

but if I was subclassing (in another language), the output will be:

Person
Hi, my name is Person
TalkVia ->
Hi, my name is Person
Android
Hi, my name is Android
TalkVia ->
Hi, my name is Android

Is there a way to achieve this last output with google go embedding (not interfaces)?

Embedding is not an alternative to subclassing. Just forget about subclassing when programming Go: Your designs will be much nicer. — Volker
– Volker, Commented Apr 14, 2014 at 8:01
@Volker: I agree. But a I am trying to understand how can I reuse code from an upstream project. I need to change one (out of many) methods and there are no interfaces (related to this piece of code) declared/used upstream. — Hernan
– Hernan, Commented Apr 14, 2014 at 11:08

Linear · Accepted Answer · 2014-04-14 01:24:36Z

6

No. Embedding is a one way thing. Embedding is slightly too unique to merely call it "syntactic sugar" -- it can be used to satisfy interfaces. Android should satisfy the interface

type TalkViaer interface {
    TalkVia()
}

because it embeds a person. However, at its heart you have to remember that embedding is just a really clever way of giving access to a struct's member. Nothing more or less. When p is passed into TalkVia it gets a Person, and since that person has no conception of its owner, it won't be able to reference its owner.

You can work around this by holding some owner variable in Person, but embedding is not inheritance. There's simply no conception of a "super" or an "extender" or anything like that. It's just a very convenient way to give a struct a certain method set.

Edit: Perhaps a little more explanation is in order. But just a little.

type Android struct {
    P person
}

We both agree that if I did a := Android{} and then a.P.TalkVia() it wouldn't call any of Android's methods, right? Even if that was Java or C++, that wouldn't make sense, since it's a member.

Embedding is still just a member. It's just a piece of data owned by the Android, no more, no less. At a syntactic level, it confers all of its methods to Android, but it's still just a member and you can't change that.

edited Apr 14, 2014 at 1:24

answered Apr 14, 2014 at 1:16

Linear

22.5k7 gold badges64 silver badges73 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Hernan Over a year ago

This last Edit was very helpful. But is there a difference between type Android struct {Person} and type Android struct {*Person}?

Vitor De Mario Over a year ago

The only difference is the embedded type is a pointer. In terms of embedding the behavior is exactly the same.

miltonb · Accepted Answer · 2014-04-14 10:04:00Z

1

I think that an interface would be closer to what you want to acheive rather than Embedding, which I know is not what your question is posed as. By providing an interface the two Person and Android stucturs can have reiver methods implemented that meet the interface. The TalkVia would be the next method to add to the interface which would then give the desired output.

 type Talker interface {
       Talk()
 }
 ...
 func (p *Android) Talk() {
       fmt.Println("Hi, my name is ", p.Name )
 }
 ...
 func main() {
       p := Person { "Person" }
       p.Talk()
       p.TalkVia()
 }

Full example based on your code with interface here at the Go Playground Example

Based on your comment about not being able to modify the implementation of Person. I have modified example with a constructor and an embedded struct to produce the following:

Person
Hi, my name is Person
TalkVia ->
Hi, my name is Person
Android
Hi, my name is Android
Hi, my name is Android
TalkVia ->
Hi, my name is Android

The full example is in this second play ground example but in short form does the following:

type Android struct {
    Person
    Name string
}
...
func NewAndroid(name string) Android {
    return Android { Person { name }, name }
}

Now we can create an Android and use it as a Android and a Person. In fact because it is now embedding Person which implements the Talker interface it can also just directly call the TalkVia method

func main() {
     ...

     a := NewAndroid("Android")
     a.Talk()
     a.TalkVia()
     ap := a.Person
     ap.Talk()
     ap.TalkVia()
}

edited Apr 14, 2014 at 10:04

answered Apr 14, 2014 at 1:46

miltonb

7,4638 gold badges50 silver badges58 bronze badges

2 Comments

Hernan Over a year ago

What can you do when you cannot modify upstream code but you want to reuse some functions. In this case, you use a package that defines Person (with Talk and TalkVia); and you want to define Android reusing TalkVia but reimplementing Talk.

miltonb Over a year ago

I see what you are getting at. I have modified with a second example which is able to produce the output you are looking for.

Collectives™ on Stack Overflow

Understanding embedding in Go

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related