Resolved: Idiomatic goroutine concurrency and error handling

package main</p>
<p>    import (<br />
        "fmt"<br />
        "sync"<br />
    )</p>
<p>    func processBatch(num int, errChan chan<- error, resultChan chan<- int, wg *sync.WaitGroup) {
        defer wg.Done()
    
        if num == 3 {
            resultChan <- 0
            errChan <- fmt.Errorf("goroutine %d's error returned", num)
        } else {
            square := num * num
    
            resultChan <- square
    
            errChan <- nil
        }
    
    }
    
    func main() {
        var wg sync.WaitGroup
    
        batches := [5]int{1, 2, 3, 4, 5}
    
        resultChan := make(chan int)
        errChan := make(chan error)
    
        for i := range batches {
            wg.Add(1)
            go processBatch(batches[i], errChan, resultChan, &wg)
        }
    
        var results [5]int
        var err [5]error
        for i := range batches {
            results[i] = <-resultChan
            err[i] = <-errChan
        }
        wg.Wait()
        close(resultChan)
        close(errChan)
        fmt.Println(results)
        fmt.Println(err)
    }
[/code]

</p>



Playground: <a href="https://go.dev/play/p/zA-Py9gDjce" rel="nofollow noreferrer">https://go.dev/play/p/zA-Py9gDjce</a>
This code works and I get the result that I want i.e:<br> 


<p>[code][25 1 4 0 16]<br />
[<nil> <nil> <nil> goroutine 3's error returned <nil>]

package main</p>
<p>import (<br />
    "fmt"<br />
)</p>
<p>func processBatch(num int, errChan chan<- error, resultChan chan<- int) {
    if num == 3 {
        // no need to send result when it is meanenless
        // resultChan <- 0
        errChan <- fmt.Errorf("goroutine %d's error returned", num)
    } else {
        square := num * num

        resultChan <- square

        // no need to send errror when it is nil
        // errChan <- nil
    }

}

func main() {
    batches := [5]int{1, 2, 3, 4, 5}

    resultChan := make(chan int)
    errChan := make(chan error)

    for i := range batches {
        go processBatch(batches[i], errChan, resultChan)
    }

    // use slices instead of arrays because legth varry now
    var results []int
    var errs []error

    // every time function executes it sends singe piece of data to one of two channels
    for range batches {
        select {
        case res := <-resultChan:
            results = append(results, res)
        case err := <-errChan:
            errs = append(errs, err)
        }
    }

    close(resultChan)
    close(errChan)

    fmt.Println(results)
    fmt.Println(errs)
}
[/code]

</p>



<a href="https://go.dev/play/p/SYmfl8iGxgD" rel="nofollow noreferrer">https://go.dev/play/p/SYmfl8iGxgD</a><br> 


<p>[code][25 1 16 4]<br />
[goroutine 3's error returned]