A library I use has a type with multiple methods:
type Foo struct {
}
func (f *Foo) method1() int { ... }
func (f *Foo) method2() int { ... }
func (f *Foo) method3() int { ... }
// ... and so on
I'd really like to apply some specific behavior anytime I call method1
on this type:
func (f *Foo) method1Wrapper() int {
incrementCounter()
return f.method1()
}
But this adds a new method I'd have to call instead of just directly calling method1()
itself.
Alternatively, I imagine I could create my own type:
type Foo2 struct {
Foo
}
func (f *Foo2) method1() int {
incrementCounter()
return f.Foo.method1()
}
But then I'd have to create a bunch of boilerplate code to proxy all the calls to method2
, method3
, etc down to the Foo
implementation, and I'd have to change all my usages of Foo
to Foo2
.