Does closed channel send value zero? - go

Question

In the below code:
package main
import (
"fmt"
"time"
)
func asChan(vs ...int) <-chan int {
c := make(chan int)
go func() {
for _, v := range vs {
c <- v
time.Sleep(2 * time.Second)
}
close(c)
}()
return c
}
func merge(a, b <-chan int) <-chan int {
c := make(chan int)
go func() {
for {
select {
case v := <-a:
c <- v
case v := <-b:
c <- v
}
}
}()
return c
}
func main() {
a := asChan(1, 3, 5, 7)
b := asChan(2, 4, 6, 8)
c := merge(a, b)
for value := range c {
fmt.Println(value)
}
}
below is the value zero for v received after closing channel a.
but my understanding is, this line of code(case v := <-a:) in merge() function should block for input, because the channel(a) is closed
Edit:
After code changes, main() does not exit:
func merge(a, b <-chan int) chan int {
c := make(chan int)
go func() {
defer close(c)
for a != nil || b != nil { // while atleast one channel is open
select {
case v, ok := <-a:
sendOnChannel(a, c, v, ok)
case v, ok := <-b:
sendOnChannel(b, c, v, ok)
}
}
}()
return c
}
func sendOnChannel(sourceChan <-chan int, targetChan chan int, v int, channelOpen bool) {
if !channelOpen {
// The channel is closed. Set channel variable
// to nil to disable this select / case.
sourceChan = nil
} else {
targetChan <- v
}
}
Output:
$ bin/cs61a
1
2
3
4
5
6
7
8
How a generates zero in this line of code(case v := <-a)?

Answer 1

The specification says:
A receive operation on a closed channel can always proceed immediately, yielding the element type's zero value after any previously sent values have been received.
I don't know why the language designers chose this design, but it's useful in practice.
Use the two-value receive statement to detect when the channel yields a zero value because the channel is closed.
v, ok := <-a
if !ok {
// channel closed
}
Use the following code to implement merge:
func merge(a, b <-chan int) <-chan int {
c := make(chan int)
go func() {
defer close(c)
// While we have at least one channel ...
for a != nil || b != nil {
select {
case v, ok := <-a:
if ok {
c <- v
} else {
// The channel is closed. Set channel variable
// to nil to disable this select / case.
a = nil
}
case v, ok := <-b:
if ok {
c <- v
} else {
b = nil
}
}
}
}()
return c
}
Run it on the playground.