Passing in a function that calls another func - go

Question

Hello I have 2 funcs that look similar and I would like to create one generic func. My problem is: I am unsure how to pass in another func:
func (b *Business) StreamHandler1(sm streams.Stream, p []*types.People) {
guard := make(chan struct{}, b.maxManifestGoRoutines)
for _, person := range p {
guard <- struct{}{} // would block if guard channel is already filled
go func(n *types.People) {
b.PeopleHandler(sm, n)
<-guard
}(person)
}
}
func (b *Business) StreamHandler2(sm streams.Stream, pi []*types.PeopleInfo) {
guard := make(chan struct{}, b.maxManifestGoRoutines)
for _, personInfo := range pi {
guard <- struct{}{} // would block if guard channel is already filled
go func(n *types.PeopleInfo) {
b.PeopleInfoHandler(sm, n)
<-guard
}(personInfo)
}
}
You can see they both look very, very similar so I would like to make one generic func that I can pass in PeopleInfoHandler and PeopleHandler . Any idea how I can do this correctly? It looks like the syntax from Go I should be able to do something like this:
func (b *Business) StreamHandler1(f func(streams.Stream, interface{}), sm streams.Stream, p []*interface{}) {
But that doesn't seem to be working. Any ideas on how I can make this generic?

Answer 1

You can create abstractions for the type you passed with specific interface types defined.
I use the Peopler interface to either get the People or the PeopleInfo, based on the handler that I defined and that I pass to the new StreamHandler. You can pass the *Business as well in the handler if you need any of its field/method.
But as would Sergio say, if the method is only 5 lines long, even if it is mostly the same, it might not be worth it.
For your pattern with the guard struct, you could use a sync.WaitGroup that would fit better.
package main
import (
"fmt"
"time"
)
func (b *Business) StreamHandler(sm streamsStream, p []Peopler, handler func(streamsStream, Peopler)) {
guard := make(chan struct{}, b.maxManifestGoRoutines)
for _, person := range p {
guard <- struct{}{} // would block if guard channel is already filled
go func(p Peopler) {
handler(sm, p)
<-guard
}(person)
}
}
func peopleInfoHandler(s streamsStream, p Peopler) {
fmt.Println("info:", p.PeopleInfo())
}
func peopleHandler(s streamsStream, p Peopler) {
fmt.Println("people:", p.People())
}
func main() {
b := &Business{maxManifestGoRoutines: 2}
s := streamsStream{}
p := []Peopler{
&People{
Info: PeopleInfo{Name: "you"},
},
}
b.StreamHandler(s, p, peopleInfoHandler)
b.StreamHandler(s, p, peopleHandler)
time.Sleep(time.Second)
}
type streamsStream struct {
}
type People struct {
Info PeopleInfo
}
func (tp *People) People() People {
return *tp
}
type PeopleInfo struct {
Name string
}
func (tp *People) PeopleInfo() PeopleInfo {
return tp.Info
}
type Peopler interface {
People() People
PeopleInfo() PeopleInfo
}
type Business struct {
maxManifestGoRoutines int
}
play link

Answer 2

If possible, you can use dependency inversion to utilize interfaces instead. An association between a type and a function is pretty much the definition of a method. So use an interface to specify the method definition, and pass Business into that method.
The interface will be necessary to prevent an import cycle along with making the code more permissive.
Normally with dependency inversion, the handlers would be explicitly implementing an interface in the same package as Business, but that is all implicit in Go.
For example:
type Handler interface {
Handle(*Business, streams.Stream)
}
func (b *Business) StreamHandler1(sm streams.Stream, hs []Handler) {
guard := make(chan struct{}, b.maxManifestGoRoutines)
for _, h := range hs {
guard <- struct{}{} // would block if guard channel is already filled
go func(n Handler) {
n.Handle(b, sm)
<-guard
}(h)
}
}
Alternatively, if you need a specific functionality from the type, you can have the Business method accept the interface for that behavior. This would be a bit more elegant, but it takes more planning ahead of time across multiple types or a large refactor. For example:
type TypeDoThinger interface {
Type() Schema
DoThing() ImportantValue
}
func (b *Business) HandleTypeDoThinger(sm streams.Stream, t TypeDoThinger) {
sch := t.Type()
// use schema for something
v := t.DoThing()
// save the important data
}
func (b *Business) StreamHandler(sm streams.Stream, ts []TypeDoThinger) {
guard := make(chan struct{}, b.maxManifestGoRoutines)
for _, t := range ts {
guard <- struct{}{} // would block if guard channel is already filled
go func(t TypeDoThinger) {
b.HandleTypeDoThinger(sm, t)
<-guard
}(t)
}
}