How to handle flow-style interface of embedded type

Assume I have a third-party type that implements a flow-style interface, i.e. calling a function on a pointer function update the state and returns the pointer back:

type ThirdPartyType struct {}

func NewThirdPartyType() *ThirdPartyType {
    return &ThirdPartyType{}
}

func (tpt *ThirdPartyType) Foo(foo string) *ThirdPartyType {
    // ...
    return tpt
}

Using such a type is succinct:

tpt := NewThirdPartyType().Foo("foo")

I want to wrap this ThirdPartyType and add a few new methods. For this I embed it into MyType like

type MyType struct {
    *ThirdPartyType
}

func NewMyType() *MyType {
    return &MyType{}
}

func (mt *MyType) Bar(bar string) *MyType {
    // ...
    return mt
}

While for my custom methods I can retain the flow style, I cannot for the ones “inherited” by ThirdPartyType as they return *ThirdPartyType and thus cannot be used in the chain:

var mt *MyType = NewMyType().Bar("bar")
mt.Foo("foo")

This is rather unfortunate as it defeats the succinctness I had before. The only solution I found so far is to re-implement the methods of ThirdPartyType on MyType like:

func (mt *MyType) Foo(foo string) *MyType {
    mt.Foo(foo)
    return mt
}

Now I can in fact do

mt := NewMyType().Bar("bar").Foo("foo")

However, this is quite a bit of boilerplate. Plus, the number of methods I’d need to re-implement is around 50, so I’d rather not maintain this by hand.

The best solution I came up with is to use code generation coupled with reflect to handle this automatically. I just want to check if I’m missing a simpler solution before I go down this route.

Hello there. Sadly, as far as I know there is no solution for this question. Digging deeper I guess it’s also more about design of the implementation. In particular, I don’t like methods chaining and try to avoid it in go as much as possible and favor the functional options pattern. If you wanna stick with the chaining, I’d advise to checkout gorm source code. I’ve never seen anything better with chaining, than this package