IMO a better solution would be to use the delegation pattern:

type ostrich struct {
    b bird
}

func (this *ostrich) eat() {
    this.b.eat()
}

func (this *ostrich) drink() {
    this.b.drink()
}

func (this *ostrich) sleep() {
    this.b.sleep()
}

It's not worth it to convolute the language just to save a few lines of code.

IMO a better solution would be to use the delegation pattern:

type ostrich struct {
    b bird
}

func (this *ostrich) eat() {
    this.b.eat()
}

func (this *ostrich) drink() {
    this.b.drink()
}

func (this *ostrich) sleep() {
    this.b.sleep()
}

It's not worth it to convolute the language just to save a few lines of code.

it is feasible if the number of methods is small, but when the number of methods is large, it will cause lots of work. I will encounter this situation in my actually development, which resulting a large number of duplicate code. Of course, you can design a new parent structure, but it's still a good amount of work.Because the project already largely depend on the parent structure.
Not all structures can be designed perfectly from the very beginning.

type discard interface {
    fly()
}

type ostrich struct {
    bird
    discard
}

It seems that interface is a better choice.

Better from the view of aesthetics.

In fact, the following one is more memory saving:

type discard struct {
    fly struct{}
}

What is the problem of having more methods than you are using?

#35206 (comment) shows a different way to implement this without changing the language. This proposal as is does not have strong support. For these reasons, this is a likely decline. Leaving open for four weeks for final comments.

No final comments. Closing.