switchlen(channels) { case2: select { case <-channels[0]: case <-channels[1]: } default: m := len(channels) / 2 select { case <-Or(channels[:m]...): case <-Or(channels[m:]...): } } }()
return orDone }
Approach 2: reflection
reflect.SelectCase describes one select arm (send or recv):
1 2 3 4 5
type SelectCase struct { Dir SelectDir // direction of case Chan Value // channel to use (for send or receive) Send Value // value to send (for send) }
Build a slice of receive cases and call reflect.Select:
orDone := make(chaninterface{}) gofunc() { deferclose(orDone) var cases []reflect.SelectCase for _, c := range channels { cases = append(cases, reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(c), }) }
reflect.Select(cases) }()
return orDone }
Benchmarks
Both scale to many channels; recursion vs reflection is not obvious on paper.
Helper stream:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
funcAsStream(done <-chanstruct{}, values ...interface{}) <-chaninterface{} { s := make(chaninterface{}) gofunc() { deferclose(s) for _, v := range values { select { case <-done: return case s <- v: } } }() return s }
var funcs = []struct { name string f func(...<-chaninterface{}) <-chaninterface{} }{ {"reflection", OrInReflect}, {"recursion", OrRecur}, } funcBenchmarkOr(b *testing.B) { for _, f := range funcs { for n := 8; n <= 1024; n *= 2 { b.Run(fmt.Sprintf("%s/%d", f.name, n), func(b *testing.B) { for i := 0; i < b.N; i++ { b.StopTimer() done := make(chanstruct{}) deferclose(done) streams := make([]<-chaninterface{}, n) for i := range streams { streams[i] = AsStream(done, []interface{}{1}) } b.StartTimer() <-f.f(streams...) } }) } } }