I'm writing a function where I'm trying to increment a channel. In a much larger program, this is not working and it actually hangs on a line that looks like:

```
current = <-channel

```

The `go func`s are running, but the program seems to halt on this line.

I tried to write a smaller SSCCE, but now I'm having a different problem. Here it is:

```
package main                                                                    

import (                                                                        
    "fmt"                                                                       
)                                                                               

func main() {                                                                   
    count := make(chan int)                                                     

    go func(count chan int) {                                                   
        current := 0                                                            
        for {                                                                   
            current = <-count                                                   
            current++                                                           
            count <- current                                                    
            fmt.Println(count)                                                  
        }                                                                       
    }(count)                                                                    
}

```

However, in the above the `go func` does not actually seem to be called at all. If I put a `fmt.Println` statement before `for {`, it *does not* print out. If I put `fmt.Println` statements before or after they `go func` block, they will both print out.

1. Why does the self-calling block in the above example not seem to run at all?
2. If it were running, why would it block on `current = <-count`? How could I properly increment the channel?