Can you declare multiple variable types for function arguments if you have multiple types to declare? (Golang)

Ok so lets say i have this code (as an easy to understand abstraction of the real thing):

package fiction     

import "fmt"

func doSomething(height int, width int, printMe string) int {
  fmt.Println(printMe)
  return height * width
}

how would I turn the height int, width int, part in the function declaration into something like height, width int,?

So what I'm trying to do is something like:

package fiction     

import "fmt"

func doSomething(height, width int, printMe string) int {
  fmt.Println(printMe)
  return height * width
}

or is this just not possible? And trust me, I get it, its just 3 letters, and between the time I've spent looking for the answer and typing this out its really a moot point but at this point I just want to know...

Also I would like to stay away from variadic parameters, BUT if there is a solution that involves variadic parameters, AND its the only solution, it would be nice to know (although it won't really work for my current use case).

tld;dr summary: Yes.

We need to figure out two things:

• Is the syntax valid?
• Do the semantics do what you want?

Both of these are important: it doesn't help you if the syntax allows you to write code that way, but it does something different from what you want. (For example, leaving out the type could mean that the type is any or that the type is inferred from the call-site. It is not obvious that leaving out the type means "take the next type you find".)

Aside

When browsing questions here on SO, I find that a lot of programmers are almost obsessed with syntax: they constantly ask "is this syntax valid", "what is the correct syntax for this", "what would be the syntax for this", etc. When what is, arguably, more important is: does this actually do what you want, i.e. does it have the required semantics?

But I digress.

Syntax

The question whether the syntax is valid is actually easy to answer. We just need to follow the breadcrumbs.

According to the section Function declarations of the Go Programming Language Specification, the syntax for a function declaration is:

> lang-none
> FunctionDecl = "func" FunctionName [ TypeParameters ] Signature [ FunctionBody ] .
> FunctionName = identifier .
> FunctionBody = Block .
>

What we are interested in, is the syntax for the Signature. Thankfully, the Go Programming Language Specification is hyperlinked, so all we need to do is click on the Signature non-terminal in the grammar which brings us to the section Function types, where the syntax is defined like this:

> lang-none
> FunctionType = "func" Signature .
> Signature = Parameters [ Result ] .
> Result = Parameters | Type .
> Parameters = "(" [ ParameterList [ "," ] ] ")" .
> ParameterList = ParameterDecl { "," ParameterDecl } .
> ParameterDecl = [ IdentifierList ] [ "..." ] Type .
>

So, a Signature is Parameters followed by an optional Result. Parameters is an opening round parenthesis followed by an optional ParameterList (itself followed by an optional comma) followed by a closing round parenthesis. A ParameterList is a ParameterDecl followed by zero or more groups of a comma followed by a ParameterDecl. A ParameterDecl is an optional IdentifierList followed by an optional ellipsis followed by a Type.

Which means we now need to know what an IdentifierList is. The name sort-of already implies that it is a list of identifiers, which would mean that, indeed, we can put multiple identifiers in front of a single type, but let's make sure.

Same game, the non-terminal IdentifierList is hyperlinked and takes us to the section Constant declarations, where we see that an IdentifierList is an identifier followed by zero or more groups of a comma followed by an identifier:

> lang-none
> IdentifierList = identifier { "," identifier } .
>

In other words, an IdentifierList is what it sounds like: a list of identifiers, separated by commas.

If we substitute all our definitions back into the grammar for the parameters in a function signature we started out with, we get the following:

Parameters = "(" [ ParameterList [ "," ] ] ")" .

Substitute the definition of ParameterList:

Parameters = "(" [ ParameterDecl { "," ParameterDecl } [ "," ] ] ")" .

Substitute the definition of ParameterDecl:

Parameters = "(" [ [ IdentifierList ] [ "..." ] Type { "," [ IdentifierList ] [ "..." ] Type } [ "," ] ] ")" .

Substitute the definition of IdentifierList:

Parameters = "(" [ [ identifier { "," identifier } ] [ "..." ] Type { "," [ identifier { "," identifier } ] [ "..." ] Type } [ "," ] ] ")" .

And we can see that your parameter list is indeed a syntactically valid parameter list.

Semantics

So, the question now becomes: what does this syntax mean, i.e. what are its semantics and are those the semantics you expect?

For the semantic definition of the signature, the section on Function declarations links again to the section on Function types, which has this to say [bold italic emphasis mine]:

> Within a list of parameters or results, the names (IdentifierList) must either all be present or all be absent. If present, each name stands for one item (parameter or result) of the specified type […]

So, what this is saying is that, indeed, when you write an IdentifierList followed by a Type, that means all parameters in that IdentifierList have the type specified by Type.

In your case, that means that both height and width have the type int.