Calling all gophers!

It’s time to talk about… Calls!

## Calls

Given an expression

`f`

with a core type`F`

of function type,`f(a1, a2, … an)`

calls

`f`

with arguments`a1, a2, … an`

.

This basic syntax is common to many languages, so should not feel at all strange if you have any programming experience at all.

So let’s dive right into the nitty-gritty details…

… Except for one special case, arguments must be single-valued expressions assignable to the parameter types of

`F`

and are evaluated before the function is called.

So we’ll talk about the special case later. For today, we’ll address the two other points made in this sentence.

- Arguments must be single-valued expressions. Let’s consider some examples and counter-examples. Assuming a function
`f`

of type`func(int, int, int)`

:

```
f(1, 2, 3) // valid: Three single-valued expressions, 1, 2, and 3
f(1+2, 10-9, 3*4) // valid: Each expression evaluates to a single value
func one() int {
return 1
}
f(one(), one(), one()) // valid: one() evaluates to a single expression
func two() (int, int) {
return 2, 3
}
f(two(), one()) // invalid: two() evaluates to two expressions
// However, the likely intent of the above can be rewritten as:
a, b := two()
f(a, b, one())
```

- Arguments must be assignable to the parameter types of F. This one should be pretty obvious, especially if you’re familiar with strictly-typed languages.

```
f("one", float64(1.23), struct{ Name string}{Name: "Bob"}) // Invalid: f expects three ints
```

Quotes from *The Go Programming Language Specification* Version of August 2, 2023