The following code fails, because after using B.Assign(A), the information on the specific type of B is lost (at least that's what I think goes wrong here):
package main
import "fmt"
type Methods interface {
Method()
Assign(Methods)
Set(Methods)
}
type Parent struct {
Methods
assigned Methods
}
type ChildA struct {
Parent
}
type ChildB struct {
Parent
msg string
}
func (this *Parent) Assign(other Methods) {
//Some other logic here
other.Set(this)
}
func (this *Parent) Set(other Methods) {
this.assigned = other
}
func (c *ChildA) Method() {
fmt.Println("I'm child A")
}
func (c *ChildB) Method() {
fmt.Println("I'm child B, and I approve this message:", c.msg)
}
func main() {
A := new(ChildA)
B := new(ChildB)
B.msg = "my message"
B.Assign(A)
A.assigned.Method()
}
Now, in order to avoid this, I would have to make another method, that has exactly the same definition as Parent.Assign(), but different receiver:
func (this *Parent) Assign(other Methods) {
//Some other logic here
other.Set(this)
}
func (this *ChildB) Assign(other Methods) {
//Same as above
other.Set(this)
}
This is rather ugly. Is there a way to preserve the information about B's type when calling the method from it's embedded struct Parent, without duplicating the code?
