Go: naming convention for slice variables/params?

Is the convention for naming slices in Go? Specifically, do you use plurals?
I've noticed that Go App Engine doesn't (eg. it uses key not keys):

func GetMulti(c appengine.Context, key []*Key, dst interface{}) error

I haven't seen anything equivalent in the standard packages or docs I've read. Is singular or plural normal?

That should be a typo, I guess.

Names of slices and arrays are plural. It's not hard to find some samples in the standard library: function SetCookies in CookieJar, Readdirnames, or Args variable in the variables of os package.

But for any variable use a name that better explains its purpose.

A clear exception to this all-plural approach is argv which had its name for decades.

@Mostafa is right. Names of slices and arrays in Go should be a plural. fns is the plural of fn in this example from @Ainar-G. See https://stackoverflow.com/a/35648660/12817546..

package main

import "fmt"

func main() {
	var fns []func()
	fns = append(fns, beeper)
	fns = append(fns, pinger)
	for _, fn := range fns {
		fn() //beep-beep ping-ping
	}

}
func beeper() { fmt.Println("beep-beep") }
func pinger() { fmt.Println("ping-ping") }

@Mostafa is also right that names should explain their purpose. To add to this, self-evident names make code more readable. Self-evident names comment on and document their code.

Self-evident names are consistent. That is they are easy to guess.beeper matches "beep-beep". Self-evident names are accurate. That is they are easy to understand.fns matches fn which denotes a func.

Self-evident names are short. That is they are easy to type. Short names require a short distance between their declaration and their use. Arguments such as fn can be one or two characters-long. For everything else a short one word noun can be used. But sometimes if the distance is great more explanation is needed. A multi-word name mixedCaps can be used. But don't use an under_score_name.

The names used may not be as self-evident as they could be. As a result code may have too many // line comments. Comments can make code less readable. Rename your identifiers so they become more self-evident. And then the number of // can be reduced without loss of explanation.

There are other limits to the use of names. Go keywords cannot be used. Canonical Read, Write, Close, Flush, String etc words should not be used. The first character of a name must be a Unicode letter or a _. Remember capitalized names such as MixedCaps can be exported and type identifiers are typically uppercase.

To find out more have a look at https://talks.golang.org/2014/names.slide, https://blog.golang.org/package-names, https://talks.golang.org/2013/bestpractices.slide, https://golang.org/ref/spec#Identifiers and https://golang.org/doc/effective_go.html#names.