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

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

好的，所以它似乎与slice covariance in go 中的lack 有关。我的解决方案是将“非定向”通道切片转换为只读通道切片。完整示例如下：

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...) 
}