We know that functions can return information, but we can also provide functions with information using parameters. Function parameters are variables that are used within the function to use in some sort of computation or calculation. When calling a function, we give arguments, which are the values that we want those parameter variables to take. We give our function parameters types when defining the function:

func multiplier(x int32, y int32) int32 {
  return x * y
}

In the function above, we added information inside our parentheses, that is where parameters belong. Our first parameter is x and it has a type of int32. Our second parameter, y also has a type of int32. After the parentheses is something we’ve seen before: the type of our return value. Since both parameters have the same type, we could write it as:

func multiplier(x, y int32) int32 {
  return x * y
}

See how we wrote int32 once at the end of our list of parameters instead of writing int32 after each parameter?

Let’s now call our function with literal values as arguments:

func main() {
  var product int32
  product = multiplier(25, 4)
  fmt.Println(product) // Prints: 100
}

We can also call our function with variables as arguments:

func main() {
  var mainX, mainY, newProduct int32
  mainX = 6
  mainY = 7
  newProduct = multiplier(mainX, mainY)
  fmt.Println(newProduct) // Prints: 42
}

Notice in both cases, our functions worked as expected with the provided arguments! But, it’s important that we provide enough arguments. Our multiplier() function has two parameters, so it expects two arguments. If we don’t, the Go compiler throws an error that reads not enough arguments in call to (functionName) or in our case: not enough arguments in call to multiplier.