我如何将通道切片传递给函数作为可变的

Question

如果我有一个函数接受许多只读通道(例如通道聚合)，为什么我不能用通道切片调用这个函数，如

package main
func f(in ...<-chan int) {
    // do something
}
func main() {
    chList := []chan int{make(chan int), make(chan int)}
    f(make(chan int), make(chan int)) // works
    f(chList...) // cannot use chList (type []chan int) as type []<-chan int in argument to f
}

我似乎错过了一些基本的东西，但我不知道是什么。如果函数不能接受单向通道，为什么在第一种情况下不能接受呢?

Answer 1

好的，这似乎与围棋中缺乏切片协方差有关。我的解决方案是将"非定向"通道片转换为只读通道片。完整示例如下:

package main
import (
    "fmt"
    "time"
)
func f(in ...<-chan int) chan int {
    fmt.Println("number of channels:", len(in))
    out := make(chan int)
    for _, ch := range in {
        go func(ch <-chan int) {
            for i := range ch {
                out <- i
            }
        }(ch)
    }
    return out
}
func chConv(channels ...chan int) []<-chan int {
    ret := make([]<-chan int, len(channels))
    for n, ch := range channels {
        ret[n] = ch
    }
    return ret
}
func main() {
    chList := []chan int{make(chan int), make(chan int)}
    roChans := chConv(chList...)
    agg := f(roChans...)
    go func() {
        for i := range agg {
            fmt.Println("got:", i)
        }
    }()
    for i := 0; i < 10; i++ {
        for _, ch := range chList {
            ch <- i
        }
    }
    time.Sleep(1 * time.Second)
}

Answer 2

你错过了方向，

package main
func f(in ...<-chan int) {
    // do something
}
func main() {
    chList := []<-chan int{make(<-chan int), make(<-chan int)}
    f(make(<-chan int), make(<-chan int)) 
    f(chList...) 
}