slice, channel of empty interface as function argument - go

Question

I would like to implement a parallelization function, which in the absence of generics, looks like so:
func Parallelize(s []interface{}, c chan interface{}, f func(interface{}, chan interface{})) {
var wg sync.WaitGroup
defer wg.Done()
for _, si := range s {
wg.Add(1)
go f(si, c)
}
wg.Wait()
close(c)
}
I'd like to enable passing objects of any type, but to ensure that the first argument is a slice of objects, second is a channel and third is a function that accepts an object and channel.
Apparently, the go compiler doesn't like the arguments. It is not allowing me to call this function like so:
a := make([]*A)
c := make(chan *A)
f := func(_a *A, _c chan A) {
...
}
Parallelize(a, c, f)
What is the right way of going about this?

Answer 1

There are several ways you can do this, though the best in my opinion is not to do it. This is one of those common patterns that is best left explicit because it is much easier to read and maintain. However, if you insist:
One way to do it is realizing that you don't really need to pass the slice elements:
func Parallelize(n int, c chan interface{}, f func(int, chan interface{})) {
var wg sync.WaitGroup
defer wg.Done()
for i:=0;i<n;i++ {
wg.Add(1)
go f(i, c)
}
wg.Wait()
close(c)
}
And call it using:
Parallelize(len(slice), ch, func(i int,ch chan interface{}) {
// use slice[i]
})
You also don't need to pass the channel:
func Parallelize(n int, f func(int)) {
var wg sync.WaitGroup
defer wg.Done()
for i:=0;i<n;i++ {
wg.Add(1)
go f(i)
}
wg.Wait()
}
And call it:
Parallelize(len(slice), func(i int) {
// use slice[i] and chan ch
})`
close(ch)
Another way of doing this is using reflection. It'll be uglier, and you'll have to deal with runtime errors instead of compile time errors.