mixing "exploded" slices and regular parameters in variadic functions
The ugly way to get this to work is make it into a new variadic.
foo(append([]string{"bar"}, stuff...)...)
And if the order doesn't matter:
foo(append(stuff, "bar")...)
https://play.golang.org/p/mY6y0vScfPB
The value for a variadic argument can be specified either by enumerating the elements, or using an existing slice, specified by its name followed by ...
.
You want to mix the 2 possible ways which is not permitted by the Go Language Specification (Passing arguments to ...
parameters).
If the first form is used (enumerating the elements):
The value passed [as the variadic parameter] is a new slice of type
[]T
with a new underlying array whose successive elements are the actual arguments.
If the latter is used (passing an existing slice followed by ...
) no new slice is created, the one you pass is used as is. And the passed slice can only be used to specify the value of one – the final – variadic parameter. Attempting to pass both a single element and a slice will not match the signature (the parameter list in this case) of your function and you'll get an error:
too many arguments in call to foo
There is no actual "exploding" involved in Go, the term is just used in other languages to help visualize that the passed array or slice will not be an element of the variadic parameter but will be the value of variadic parameter itself.
Mixing the 2 would require to allocate a new slice because obviously the existing slice cannot be used.
The specification on this is at the "Passing arguments to ...
parameters":
If
f
is variadic with a final parameterp
of type...T
, then withinf
the type ofp
is equivalent to type[]T
.
Iff
is invoked with no actual arguments forp
, the value passed top
isnil
.
Otherwise, the value passed is a new slice of type[]T
with a new underlying array whose successive elements are the actual arguments, which all must be assignable toT
.
In your case, where stuff... works:
If the final argument is assignable to a slice type
[]T
, it may be passed unchanged as the value for a...T
parameter if the argument is followed by...
. In this case no new slice is created.
But "bar", stuff...
doesn't match either case specified above.
T, []T
doesn't match f([]T)
.