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

好的，所以它似乎与lack的slice covariance in go有关。我的解决方案是键入转换＆＃34;非定向＆＃34;通道进入一片只读通道。完整示例如下：

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

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

2 个答案: