Implement Ruby style Cartesian product in Go

I want to get the Cartesian product of a, b, c, d:

a = ['a1']
b = ['b1', 'b2']
c = ['c1', 'c2', 'c3']
d = ['d1']

Here is code in Ruby:

e = [b, c, d]
print a.product(*e)

Output is:

[
  ["a1", "b1", "c1", "d1"],
  ["a1", "b1", "c2", "d1"],
  ["a1", "b1", "c3", "d1"],
  ["a1", "b2", "c1", "d1"],
  ["a1", "b2", "c2", "d1"],
  ["a1", "b2", "c3", "d1"]
]

Is there a similar package or function that could do product in Golang?
This is just simplified version, in fact, the input data is like [['a1'], ['b1','b2'], ['c1','c2','c3],['d1'],['e1',...],...].

If you need an unknown-at-compile-time set of nested index loops, you can use code like this.

package main

import "fmt"

// NextIndex sets ix to the lexicographically next value,
// such that for each i>0, 0 <= ix[i] < lens(i).
func NextIndex(ix []int, lens func(i int) int) {
	for j := len(ix) - 1; j >= 0; j-- {
		ix[j]++
		if j == 0 || ix[j] < lens(j) {
			return
		}
		ix[j] = 0
	}
}

func main() {
	e := [][]string{
		{"a1"},
		{"b1", "b2"},
		{"c1", "c2", "c3"},
		{"d1"},
	}
	lens := func(i int) int { return len(e[i]) }

	for ix := make([]int, len(e)); ix[0] < lens(0); NextIndex(ix, lens) {
		var r []string
		for j, k := range ix {
			r = append(r, e[j][k])
		}
		fmt.Println(r)
	}
}

The output is:

[a1 b1 c1 d1]
[a1 b1 c2 d1]
[a1 b1 c3 d1]
[a1 b2 c1 d1]
[a1 b2 c2 d1]
[a1 b2 c3 d1]

Based on @paul-hankin answer, here a solution which is embedded in a function and uses generics. Needs go 1.18 minimum

// cartesianProduct returns the cartesian product
// of a given matrix
func cartesianProduct[T any](matrix [][]T) [][]T {
	// nextIndex sets ix to the lexicographically next value,
	// such that for each i>0, 0 <= ix[i] < lens(i).
	nextIndex := func(ix []int, lens func(i int) int) {
		for j := len(ix) - 1; j >= 0; j-- {
			ix[j]++

			if j == 0 || ix[j] < lens(j) {
				return
			}

			ix[j] = 0
		}
	}

	lens := func(i int) int { return len(matrix[i]) }

	results := make([][]T, 0, len(matrix))
	for indexes := make([]int, len(matrix)); indexes[0] < lens(0); nextIndex(indexes, lens) {
		var temp []T

		for j, k := range indexes {
			temp = append(temp, matrix[j][k])
		}

		results = append(results, temp)
	}

	return results
}