Safely getting a subsection of a slice in Go

I know that you can get a subsection of a slice in Go via

test := []int{0, 1, 2, 3, 4}
subsection := test[:2]

But if you try something like

subsectionError := test[:10]

You'll get an out of bounds error. Currently I'm doing something like

length := 10
if len(test) < length {
	length = len(test)
}
safeSubsection := test[:length]

To avoid the error, but is there a nicer way of doing this? It feels pretty hacky to me, but then again Go generally seems to be a pretty explicit language.

In Go, the answer is often to hide ugliness in a function or method. For example, a min function,

package main
import "fmt"
func min(x, y int) int {
	if y < x {
		return y
	}
	return x
}
func main() {
	test := []int{0, 1, 2, 3, 4}
	fmt.Println(test)
	sub := test[:min(10, len(test))]
	fmt.Println(sub)
}

Output:

[0 1 2 3 4]
[0 1 2 3 4]

If you find yourself doing this often, and the ugliness annoys you, you can make a slice type instead and put some convenience methods on this. This is useful if you have a lot of convenience methods that operate on a list (say min, max, head, contains etc). I use this to add contains to string or int slices.

package main
import (
	"fmt"
)
type Ints []int
func (i Ints) Head(count int) Ints {
	if count > len(i) {
		count = len(i)
	}
	return i[:count]
}
func main() {
	test := Ints{0, 1, 2, 3, 4}
	fmt.Printf("First 2 %v\n", test.Head(2))
	fmt.Printf("First 10 %v\n", test.Head(10))
}

https://play.golang.org/p/OkCjHdlj0u

If you're only doing it once, it's probably not worth the effort, if you have a few loops operating on the same list, it might be. And of course this is one area where it'd be nice to have more sophisticated generic containers in Go.