Go recursion for struct fields - function vs. pointer method

Given an exemplary

type container struct {
  arr int[]
}

I want to recursively manipulate its arr array field values.

I have two options, functionally:

• a (pointer receiver) method on container, directly accessing its arr array
• a function, receiving the arr slice as parameter

In any case, alternating start and end indices have to be passed as parameters to each recursive call.

Question:<br>
Are there any known, theoretically beneficial or detrimental impacts, mainly with regards to performance¹ and memory footprint, by using one implementation over the other and considering that arr will hold between 10^6 and 10^9 elements?

¹ running (unprofessionally bench-marked) test implementations, performance does not seem to be significantly different

I think that you can use both options, but I recommend to use pointer to array because it will protect you from accidental append to the slice which can lead to copying of the entire slice memory.

Also keep in mind that you cannot use array in such way:

func foo(sl []int) {
	sl[1] = 15
}
func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	foo(arr)
}

Output:

cannot use arr (variable of type [5]int) as []int value in argument to foo

But you can convert array into slice without copying it:

package main
import (
	"fmt"
)
func foo(sl []int) {
	sl[1] = 55
}
func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	sl := arr[:]
	fmt.Printf("arr=%v, sl=%v\n", arr, sl)
	arr[1] = 5
	fmt.Printf("arr=%v, sl=%v\n", arr, sl)
	sl[1] = 15
	fmt.Printf("arr=%v, sl=%v\n", arr, sl)
	foo(sl)
	fmt.Printf("arr=%v, sl=%v\n", arr, sl)
}

Output:

arr=[1 2 3 4 5], sl=[1 2 3 4 5]
arr=[1 5 3 4 5], sl=[1 5 3 4 5]
arr=[1 15 3 4 5], sl=[1 15 3 4 5]
arr=[1 55 3 4 5], sl=[1 55 3 4 5]