go routine for range over channels

This situation caused of output channel of sq function is not buffered. So sq is waiting until next function will read from output, but if sq is not async, it will not happen (Playground link):

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func main() {
    numsCh := gen(3, 4)
    sqCh := sq(numsCh) // if there is no sq in body - we are locked here until input channel will be closed
    result := sq(sqCh) // but if output channel is not buffered, so `sq` is locked, until next function will read from output channel

    for n := range result {
        fmt.Println(n)
    }
    fmt.Println("Process completed")
}

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int, 100)
    for n := range in {
        out <- n * n
    }
    close(out)
    return out
}

Your function creates a channel, writes to it, then returns it. The writing will block until somebody can read the corresponding value, but that's impossible because nobody outside this function has the channel yet.

func sq(in <-chan int) <-chan int {
    // Nobody else has this channel yet...
    out := make(chan int)
    for n := range in {
        // ...but this line will block until somebody reads the value...
        out <- n * n
    }
    close(out)
    // ...and nobody else can possibly read it until after this return.
    return out
}

If you wrap the loop in a goroutine then both the loop and the sq function are allowed to continue; even if the loop blocks, the return out statement can still go and eventually you'll be able to connect up a reader to the channel.

(There's nothing intrinsically bad about looping over channels outside of goroutines; your main function does it harmlessly and correctly.)

The reason of the deadlock is because the main is waiting for the sq return and finish, but the sq is waiting for someone read the chan then it can continue.

I simplified your code by removing layer of sq call, and split one sentence into 2 :

func main() {
    result := sq(gen(3, 4)) // <-- block here, because sq doesn't return
    for n := range result { 
        fmt.Println(n)
    }
    fmt.Println("Process completed")
}

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    for n := range in {
        out <- n * n   // <-- block here, because no one is reading from the chan
    }
    close(out)
    return out
}

In sq method, if you put code in goroutine, then the sq will returned, and main func will not block, and consume the result queue, and the goroutine will continue, then there is no block any more.

func main() {
    result := sq(gen(3, 4)) // will not blcok here, because the sq just start a goroutine and return
    for n := range result {
        fmt.Println(n)
    }
    fmt.Println("Process completed")
}

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n // will not block here, because main will continue and read the out chan
        }
        close(out)
    }()
    return out
}

The code is a bit complicated, Let's simplify

First eq below, not has deadLock

func main() {
    send := make(chan int)
    receive := make(chan int)
    go func() {
        send<-3
        send<-4
        close(send)
    }()
    go func() {
        receive<- <-send
        receive<- <-send
        close(receive)
    }()
    for v := range receive{
        fmt.Println(v)

    }
}

Second eq below,remove "go" has deadLock

func main() {
    send := make(chan int)
    receive := make(chan int)
    go func() {
        send<-3
        send<-4
        close(send)
    }()
    receive<- <-send
    receive<- <-send
    close(receive)
    for v := range receive{
        fmt.Println(v)

    }
}

Let's simplify second code again

func main() {
    ch := make(chan int)
    ch <- 3
    ch <- 4
    close(ch)
    for v := range ch{
        fmt.Println(v)

    }
}

The reason of the deadlock is no buffer channel waiting in main goroutine.

Two Solutions

// add more cap then "channel<-" time
func main() {
    ch := make(chan int,2)
    ch <- 3
    ch <- 4
    close(ch)
    for v := range ch{
        fmt.Println(v)

    }
}

//async "<-channel"
func main() {
    ch := make(chan int)
    go func() {
        for v := range ch {
            fmt.Println(v)
        }
    }()
    ch <- 3
    ch <- 4
    close(ch)
}

My understanding is when the main thread is blocked for waiting for the chan to be writen or read, Go will detect if any other Go routine is running. If there is no any other Go routine running, it will have "fatal error: all goroutines are asleep - deadlock!" I tested if by using the below simple case

func main() {
    c := make(chan int)
    go func() {
        time.Sleep(10 * time.Second)
    }()
    c <- 1
}

The deadlock error is reported after 10 seconds.