Why are slices of directional channels failing to compile?

https://play.golang.org/p/-cHBgiNl0tK

package main

import (
	"fmt"
	"time"
)

func read(ch ...<-chan int) {
	for i := 0; i < len(ch); i++ {
		i := i
		go func() { fmt.Println(<-ch[i]) }()
	}
}

func write(ch ...chan<- int) {
	for i := 0; i < len(ch); i++ {
		i := i
		go func() { ch[i] <- i }()
	}
}

func main() {
	var maxLen = 10
	var ch []chan int
	for i := 0; i < maxLen; i++ {
		ch = append(ch, make(chan int))
	}
	read(ch...)
	write(ch...)
	time.Sleep(10 * time.Second)
}

The above snippet is failing with below error

./prog.go:28:6: cannot use ch (type []chan int) as type []<-chan int in argument to read
./prog.go:29:7: cannot use ch (type []chan int) as type []chan<- int in argument to write

How can I make it work with channel directions in read and write functions?

You're trying to pass a []chan int as a []<-chan int. Seems like a simple conversion, but it's actually a deep conversion as you're changing the element type of the container. These conversions aren't allowed in Go, though there is an existing (closed) proposal to make this kind of channel slice conversion allowed: https://github.com/golang/go/issues/41695

Here's a solution I've used in a similar situation in the past:

func readOnlyChannels(slice []chan int) []<-chan int {
	return *(*[]<-chan int)(unsafe.Pointer(&slice))
}

func writeOnlyChannels(slice []chan int) []chan<- int {
	return *(*[]chan<- int)(unsafe.Pointer(&slice))
}

And then usage:

	read(readOnlyChannels(ch)...)
	write(writeOnlyChannels(ch)...)

Since the read-only or write-only quality of a channel is only carried in the type information at compile time, and not in the actual data representation of the type [citation needed], you can use unsafe to just force a conversion.

Note: I'm not aware of any explicit or implicit guarantee that the unsafe conversion is valid, so you should create tests to verify that this works on your target platforms. However, in practice, it seems to work. It relies on differently-directioned channel values having identical (or at least compatible) data representations. Practically speaking, there's no reason why the design of channel directionality would require or even benefit from maintaining the channel direction at run-time.

If you want to avoid unsafe completely, then you'll have to do the "long" conversion like this:

func readOnlyChannels(slice []chan int) []<-chan int {
	out := make([]<-chan int, len(slice))
	for i := range slice {
		out[i] = slice[i]
	}
	return out
}

func writeOnlyChannels(slice []chan int) []chan<- int {
	out := make([]chan<- int, len(slice))
	for i := range slice {
		out[i] = slice[i]
	}
	return out
}

The only real downside here is that it's going to cause more allocations by copying everything into a new slice when you do the conversion. Use whichever approach poses the least issue in your application.

Although an expression of type chan int is assignable to a variable of type either chan<- int (send-only channel) or <-chan int (receive-only channel), the same doesn't apply to slices of such types:

var (
	ch chan int
	_  <-chan int   = ch // ok
	_  chan<- int   = ch // ok
	_  []<-chan int = []chan int(nil) // compilation error
	_  []chan<- int = []chan int(nil) // compilation error
)

(Playground)

./prog.go:7:2: cannot use ([]chan int)(nil) (type []chan int) as type []<-chan int in assignment
./prog.go:8:2: cannot use ([]chan int)(nil) (type []chan int) as type []chan<- int in assignment

As pointed out by Hymns for Disco in his/her answer, there is unfortunately no easy way out. I wouldn't recommend resorting to the unsafe package myself, because the risks associated with unsafe kind of offset the benefits of using channel directions. I would simply drop the channel directions in the parameters to functions write and read. YMMV.

Alternative approach with channel of channels with support for directional channels.

package main

import (
	"fmt"
	"time"
)

func read(inputs chan (<-chan int)) {
	for input := range inputs {
		go func(input <-chan int) { fmt.Println(<-input) }(input)
	}
}

func write(outputs chan chan<- int) {
	i := 0
	for output := range outputs {
		go func(output chan<- int, i int) { output <- i }(output, i)
		i += 1
	}
}

func main() {
	var maxLen = 10
	readers := make(chan (<-chan int), 10)
	writers := make(chan chan<- int, 10)
	for i := 0; i < maxLen; i++ {
		ch := make(chan int)
		readers <- ch
		writers <- ch
	}
	close(readers)
	close(writers)
	read(readers)
	write(writers)
	time.Sleep(10 * time.Second)
}