How to collect values from a channel into a slice in Go?

Suppose I have a helper function helper(n int) which returns a slice of integers of variable length. I would like to run helper(n) in parallel for various values of n and collect the output in one big slice. My first attempt at this is the following:

package main

import (
	"fmt"

	"golang.org/x/sync/errgroup"
)

func main() {
	out := make([]int, 0)
	ch := make(chan int)

	go func() {
		for i := range ch {
			out = append(out, i)
		}
	}()

	g := new(errgroup.Group)
	for n := 2; n <= 3; n++ {
		n := n
		g.Go(func() error {
			for _, i := range helper(n) {
				ch <- i
			}
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		panic(err)
	}
	close(ch)

	// time.Sleep(time.Second)
	fmt.Println(out) // should have the same elements as [0 1 0 1 2]
}

func helper(n int) []int {
	out := make([]int, 0)
	for i := 0; i < n; i++ {
		out = append(out, i)
	}
	return out
}

However, if I run this example I do not get all 5 expected values, instead I get

[0 1 0 1]

(If I uncomment the time.Sleep I do get all five values, [0 1 2 0 1], but this is not an acceptable solution).

It seems that the problem with this is that out is being updated in a goroutine, but the main function returns before it is done updating.

One thing that would work is using a buffered channel of size 5:

func main() {
	ch := make(chan int, 5)

	g := new(errgroup.Group)
	for n := 2; n <= 3; n++ {
		n := n
		g.Go(func() error {
			for _, i := range helper(n) {
				ch <- i
			}
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		panic(err)
	}
	close(ch)

	out := make([]int, 0)
	for i := range ch {
		out = append(out, i)
	}

	fmt.Println(out) // should have the same elements as [0 1 0 1 2]
}

However, although in this simplified example I know what the size of the output should be, in my actual application this is not known a priori. Essentially what I would like is an 'infinite' buffer such that sending to the channel never blocks, or a more idiomatic way to achieve the same thing; I've read https://blog.golang.org/pipelines but wasn't able to find a close match to my use case. Any ideas?

In this version of the code, the execution is blocked until ch is closed.

ch is always closed at the end of a routine that is responsible to push into ch. Because the program pushes to ch in a routine, it is not needed to use a buffered channel.

package main

import (
	"fmt"

	"golang.org/x/sync/errgroup"
)

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

	go func() {
		g := new(errgroup.Group)
		for n := 2; n <= 3; n++ {
			n := n
			g.Go(func() error {
				for _, i := range helper(n) {
					ch <- i
				}
				return nil
			})
		}
		if err := g.Wait(); err != nil {
			panic(err)
		}
		close(ch)
	}()

	out := make([]int, 0)
	for i := range ch {
		out = append(out, i)
	}

	fmt.Println(out) // should have the same elements as [0 1 0 1 2]
}

func helper(n int) []int {
	out := make([]int, 0)
	for i := 0; i < n; i++ {
		out = append(out, i)
	}
	return out
}

Here is the fixed version of the first code, it is convoluted but demonstrates the usage of sync.WaitGroup.

package main

import (
	"fmt"
	"sync"

	"golang.org/x/sync/errgroup"
)

func main() {
	out := make([]int, 0)
	ch := make(chan int)

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		for i := range ch {
			out = append(out, i)
		}
	}()

	g := new(errgroup.Group)
	for n := 2; n <= 3; n++ {
		n := n
		g.Go(func() error {
			for _, i := range helper(n) {
				ch <- i
			}
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		panic(err)
	}
	close(ch)

	wg.Wait()
	// time.Sleep(time.Second)
	fmt.Println(out) // should have the same elements as [0 1 0 1 2]
}

func helper(n int) []int {
	out := make([]int, 0)
	for i := 0; i < n; i++ {
		out = append(out, i)
	}
	return out
}