How to combine 2 arrays to a new array

Imagine two functions foo() [2]func() and bar() [3]func().

The goal is to enable the compiler to unroll these arrays later on.
Thus as much compile time information as possible should be maintained.
One idea is to construct a new array [5]func() out of the return of foo and bar calls.

Is there any way of combining these 2 returned arrays to a new array, that I do not know of?

Especially since I would like to have an operation which works even when the length of the returned arrays change.

Here are some options assuming the following:

f := foo()
b := bar()

There's a lot going in some of these options, but most of that happens at compile time. The constant expressions len(f), len(b), and len(f) + len(b) are evaluated at compile time.

Use a composite literal:

c := [...]func(){f[0], f[1], b[0], b[1], b[2]}

Use conversions to get pointers to the destination array and assign.

var c [len(f) + len(b)]func()
*((*[len(f)]func())(c[:len(f)])) = f
*((*[len(b)]func())(c[len(f):len(f) + len(b)])) = b

Use the built-in copy function:

var c [len(f) + len(b)]func()
copy(c[0:], f[:])
copy(c[len(f):], b[:])

It is common to use slices in Go:

func foo() []func() { ... }
func bar() []func() { .... }

c := append(foo(), bar()...)

Here's one thing you could do that will work "even when the length of the returned arrays change":

package main

import "fmt"

func main() {
	sliceOfFuncs := []func(){}

	for _, f := range foo() {
		sliceOfFuncs = append(sliceOfFuncs, f)
	}
	fmt.Println(sliceOfFuncs)      // [0x480240 0x480260]
	fmt.Println(len(sliceOfFuncs)) // 2
	fmt.Println(cap(sliceOfFuncs)) // 2

	for _, f := range bar() {
		sliceOfFuncs = append(sliceOfFuncs, f)
	}
	fmt.Println(sliceOfFuncs)      // [0x4804a0 0x4804c0 0x4804e0 0x480500 0x480520]
	fmt.Println(len(sliceOfFuncs)) // 5
	fmt.Println(cap(sliceOfFuncs)) // 8 
	// Why 8? The capacity doubled once (2x2=4) when inserting the 3rd function
	// then doubled once again (4x2=8) when inserting the 5th function
	// that's how slices work.
}

func foo() [2]func() {
	return [2]func(){func() {}, func() {}}
}

func bar() [3]func() {
	return [3]func(){func() {}, func() {}, func() {}}
}

You could create a function for those for loops. Here an example.