Learn how to define and invoke functions and explore their use cases in Swift. 

Functions

Swift supports a number of various parameters used with functions. In this exercise, we'll explore one of them: default parameters.

 _Default parameters_ have a real value assigned to a parameter in the function's definition. A parameter that has a default value does not require an argument passed into it when the function is called.  

Let's see a default parameter in action. Assume we're writing a program that calculates the total bill amount with a 20% (0.2) tip: 

```swift 
func totalWithTip(total: Double, tip: Double = 0.2) -> Double {
 return total + (total * tip)
}
```

`tip` is the default parameter in the function `totalWithTip(total:tip:)`. 


- A default parameter is set up in the same way as a regular parameter except it's followed by an assignment operator (`=`) and a default value. 
- The default value should be the same data type as the parameter type. 

When calling the function, we can omit the `tip` parameter entirely and the program will substitute the default value, `0.2`, with `tip` in the function body:

```swift 
print(totalWithTip(total: 50))

// Prints: 60.0
```

In the case that we want to use a different tip - say 15% instead of 20%, we can call the function and pass in the new argument for `tip`:

```swift 
print(totalWithTip(total: 50, tip: 0.15))

// Prints: 57.5
```

The new value, `0.15` for the `tip` parameter will override the default value that was declared in the function definition and `return` the value of the expression, `50 + (50 * 0.15)`. 

Default Parameters 

Excellent work! 👏 In this lesson, you’ve covered a major fundamental programming concept used in the majority of all programs to organize code into reusable blocks. 

Here's a recap:

- A function definition consists of a function name followed by optional parameters and a return type. 
- The function body holds the function's task. 
- A function will execute only when it is called.  
- A `return` keyword is used to return a value from a function. 
- A function's return type is specified in the function definition followed by an `->`. If a function does not return any values, it's return type is `Void` or the arrow and type are omitted entirely. 
- A `return` statement can be omitted if the function consists of only one expression to return. This is called an _implicit return_. 
- A parameter is a placeholder for a real value passed into a function. A parameter must be enclosed within `()` of a function definition and must have a specific type.
- An argument is a real value passed in for a parameter in the function call.    
- A function can accept multiple parameters separated by commas. As many parameters as a function accepts, as many arguments or real values must be passed into the function when it is called. 
- A function can return multiple values in the form of a tuple. 
- Swift offers support for wide variety of parameter use cases within a function: 
 - **Default Parameter**: a parameter that sets a value to the parameter that will be used if an argument is omitted.
 - **Variadic Parameter**: a parameter that accepts zero or more values of the parameter's type.  
 - **In-out Parameter**: a parameter whose value is passed into a function and modified within the body.

A diagram of a Swift function breakdown containing parameters, arguments, and a return statement. 

Review 

Each program we've written so far, whether it tested values against conditional statements or looped for iteration, executed explicitly in the order we’ve laid out and any code that needed to be reused would have to be typed out again. 

As our programs get more complex, we'll seek more efficient ways of organizing our code and aim to avoid repetition. This is where functions truly shine.  

Swift _functions_ are chunks of reusable code that achieve a certain outcome. Take a look at Sud City's `carWash()` function on the right. The function contains numerous tasks that work together to achieve a clean car. Now each time we'd need our car washed, we wouldn't build a new car wash, we'd simply reuse the one that already exists.

In this lesson, we’ll explore more scenarios in which functions are useful and learn to define and use them in our code. 

An animation with a dirty car entering a car wash named, Sud City carWash(), where the car gets soaped, scrubbed, rinsed, and dried. The car exits the car wash house clean and shiny. 

Introduction to Functions 

Until this point, our functions have only printed values to the terminal. Although useful, functions are a lot more powerful when they are able to pass values out of a function using a `return` statement. Passing a value from a function allows us to use it in other functions or save it in a variable until the need for it arises.  

If we intend for a function to return a value, we must specify that value's return type in the function definition. Take a look at the following code:

```pseudo
func funcName() -> Int {
 return 5
}
```

The function above specifies that it returns a value of type, `Int` in its definition. Within the body, the `return` statement includes `5` which matches the return type. 

**Note:** Not specifying a return type or omitting a `return` statement in a function that expects a return will result in an error. 

Let's see a `return` statement in action. The following program determines a user's age given their birth year and the current year: 

```swift 
let birthYear = 1994
var currentYear = 2021

func findAge() -> Int {
  return currentYear - birthYear
}

```

- The `findAge()` function returns a value of the type, `Int`. 
- Within the body of `findAge()`, a `return` statement is used to return the difference between the `currentYear` and `birthYear` from the function.   
- The `return` statement ends the execution of a function. 

To see the output of this function, we can:

**1.** Wrap the function call directly in a `print()` statement: 

```swift 
print(findAge()) // Prints: 27
```

**2.** Save the function call in a variable and then use a `print()` statement to output the value of the variable: 

```swift 
var age = findAge()

print(age) // Prints: 27
```

We'll practice with both strategies going forward.

Returning a Value 

A function consists of many moving parts, so let's first get familiar with its core - a definition. 

A function _definition_ consists of a function's name, optional input values, and the type of value the function returns. Following the definition is a code block or body that contains the function's task. 

Here's the set up: 

```pseudo 
func functionName() -> returnType {
 // function's task goes here
} 
```

- The `func` keyword indicates the beginning of a function. It is followed by a name in camelCase format that describes the task the function performs. It's best practice to give your functions a descriptive yet concise name. 

- Following the `functionName` is a pair of `(` `)` that can hold optional input values known as _parameters_. (More on parameters later in the lesson!)

- Following the parentheses is a _return arrow_ (`->`) with the type of data the function gives back, or _returns_. If a function does not return a value, one of the following two syntaxes can be used: <br>
  **1**: `func functionName() {` where the `->` and type are omitted entirely.  
  **2**: `func functionName() -> Void {` where `Void` is listed as the type.  

- Lastly, the `returnType` is followed by a code block that holds the code for the function's task. 


Using the [pseudocode](https://en.wikipedia.org/wiki/Pseudocode) above as a reference, we're going to create a simple function without a return statement or parameters. As we continue through this lesson, we'll learn more about these different parts and concepts. 

Here's a function that greets a user: 

```swift
func greeting() -> Void {
  print("Hey there!")
  print("How are you doing today?")
} 
```

The function above can be referenced by its name and a pair of parentheses: `greeting()`. It does not return any values, denoted by the keyword `Void`, and only contains two print statements in its body. Now every time we'd like to greet a user, we can use the `greeting()` function. 


**Note**: Pasting this code into the editor and clicking "Run" will result in an empty output terminal. The `print()` statements within the function will not execute since our function hasn't been used. We will explore this further in the next exercise; for now, let's practice defining a function. 


Defining a Function

A Swift function is intended to return a single value, but what about instances in which we need to return multiple values? We can wrap them in a collection such as an array or a [tuple](https://www.codecademy.com/articles/swift-what-are-tuples). Although collections usually include numerous items, the collection as a whole is considered a _single value_, thus allowing for it to be returned from a function with no errors.

Imagine we're creating a function that returns our favorite book's name, author, and the year that it was published. We'd like to format and return its characteristics in tuple form. Here's how we can set it up:  

```swift
func favoriteBook() -> (name: String, author: String, yearPublished: Int) {
  return ("Harry Potter and the Philosopher's Stone", "J.K. Rowling", 1997)
}
```

The `favoriteBook()` function does not accept any parameters but returns multiple values: `name`, `author` and `yearPublished` as a tuple. Within the `return` statement, parentheses are used to format the tuple and separate each item with a comma. 

```swift
let book = favoriteBook()
print(book) 

// Prints: (name: "Harry Potter and the Philosopher\'s Stone", author: "J.K. Rowling", yearPublished: 1997)
```

Calling the function above and printing the constant in which it is stored, we get a tuple output. We can then further interact with the tuple using _dot syntax_ to access  each value using its named parts:

```swift 
print(book.name) // Prints: Harry Potter and the Philosopher's Stone

print(book.author) // Prints: J.K. Rowling
```

Returning Multiple Values

The ability to write readable, succinct, and expressive code is a valuable skill to possess as a developer. 

Consider this function that sets the temperature of an oven: 

```swift
func setOvenTemperature(temperature: Int) {
 
    print("The oven is now set to \(temperature) degrees.")
    
}
```

We declare the `setOvenTemperature` function that takes a single string parameter `temperature` and prints the current oven setting to the console. 

To call this function we use the following syntax:

```swift
setOvenTemperature(temperature: 400)
 
// Prints: Oven is now set to 400 degrees
```
This works but is a tad repetitive.  We have the word temperature twice in a row.

Luckily, Swift gives us argument labels, a feature that can help make our functions read in a sentence-like manner when we call them, while still allowing us to use parameter names in the function body. 

The following syntax lets us refer to the parameter name in the body of the function, while using the argument label to refer to the same parameter when calling the function:

```swift
func functionName(argumentLabel parameterName: type) {
    print(parameterName) // Notice that we use the parameter name in the body of the function
}

// We call the function like so:

functionName(argumentLabel: value)
``` 

Let’s rewrite the method that sets the oven temperature using argument labels and make it easier to read: 

```swift
func setOvenTemperature(to temperature: Int) {
 
    print("Oven is now set to \(temperature) degrees")
    
}
 
setOvenTemperature(to: 400)
 
// Prints: Oven is now set to 400 degrees
```

We added an argument label called `to` which we will use when calling the function, but within the body of the function we still use the parameter name `temperature`.

While the output of this `setOvenTemperature` is the same, its syntax `setOvenTemperature(to: 400)` reads much more like a sentence and clearly conveys our intent. In the function body, we refer to the parameter name `temperature`, which also makes more sense in context. 

In practice, you will find that it often makes sense to refer to a parameter by a different name in the body of the function than when calling the function. Swift argument labels enable us to do this! 


Argument Labels

In our previous functions, we've sometimes used the values of variables as arguments. While we could return an entirely new value, we couldn't directly affect the variable used as the argument. An _in-out parameter_ allows a function to reassign the value of a variable passed in as an argument.

Since a function with an `inout` parameter is expected to change the value of its argument, only variables can be passed in when the function is called - not constants or literals since they can not be altered.

An `inout` parameter is declared in the function definition after the parameter name and before its specified type:  

```pseudo 
func funcName(parameterName: inout parameterType) -> returnType {
```

Say we have a program that changes the color of a phone battery depending on the charge percentage of the phone. We can set up the following function that utilizes an `inout` parameter: 

```swift 
var currentColor = "green"  

func batteryInterface(percentage: Int, batteryColor: inout String) {
  if percentage < 5 {
    batteryColor = "red"
  } else if percentage < 15 {
    batteryColor = "yellow"
  } else {
    batteryColor = "green"
  }  
}
```

Currently, the phone's battery color is `"green"`. "The function holds two parameters, `percentage` and an `inout` parameter, `batteryColor`. Within the body of the function, we use a conditional to assign a color to `batteryColor`. Notice how we don't return any values from the function. 

To spring this function into action, we must call it in the following form: 

```swift 
batteryInterface(percentage: 12, batteryColor: &currentColor)
```

When a function that utilizes an `inout` parameter is called, an ampersand, `&`, must be used directly before the variable name that will act as its argument. This symbol instructs the program that the variable can be modified. 

The real value for `percentage` is set to `12`, and the `if` statement within the function executes. `batteryColor` becomes `"yellow"` and the variable, `currentColor` takes on that new value. 

```swift 
print(currentColor) // Prints: yellow
```

In-Out Parameters

We've referenced the term, parameters, previously as optional input values that exist between the `()` in a function definition. In the previous exercise, the `findAge()` function operated on the values of a global variable and constant. Each time we'd need to calculate a different outcome, we'd have to edit their values. 

Parameters can lessen this burden by allowing a function to directly accept the input it needs to execute a task. 

Parameters are defined in a function as follows: 

```pseudo
func someFunction(paramName: paramType) -> returnType {
   // function body where paramName can be used
}
```

In the example above, we define a parameter with its name and type, separated by a `:`. This syntax should look familiar since it's how we can define a variable or constant using  type annotation.

Assume we have a garden in the shape of a square whose area we need to calculate. We can set up the following function: 

```swift
func findGardenArea(side: Int) -> Int {
  return side * side
} 
```

The function above, `findGardenArea(side:)`,  accepts a single parameter, `side`, of the type, `Int`, and returns a value of the `Int` type. Within the function, the result of multiplying `side` by `side` is returned. 

When calling this function, we will need to pass in an argument for `side`. An _argument_ is the real value for a parameter when the function is called.

```swift
var area = findGardenArea(side: 5) 
print(area) // Prints: 25
```

On the first line above, we pass in the argument, `5` for the `side` parameter in the function call. With this, the compiler knows to replace `side` with `5` in the function body and return the result of `5 * 5`. This product is then stored in the variable `area` and printed to the terminal. 

Some rules to keep in mind about parameters and arguments:

- If a parameter exists, an argument must be passed in when the function is called. Otherwise, the compiler will throw an error.
- The argument must be the same type of value that the parameter is declared to have.
- When referencing a function, include the parameter name(s) in its title followed by a colon such as `findGardenArea(side:)`. 

Parameters and Arguments

Another parameter supported by Swift is the variadic parameter. A _variadic parameter_ is a parameter that accepts zero or more values of a certain type. A variadic parameter is useful for cases in which we may need to pass in more than one value for a single parameter. 

A variadic parameter is denoted by a name, type, and three consecutive dots `...` in the function declaration. It's important to note that a Swift function cannot have more than one variadic parameter. 

```pseudo 
func functionName(paramName: paramType...) -> returnType {
  // function's task goes here
}
```

The values passed for a variadic parameter are interpreted as an array of a specific type within the function's body. Let's see an example of a variadic parameter in action.  

The code below utilizes a variadic parameter in a function to calculate the average [exchange rate](https://en.wikipedia.org/wiki/Exchange_rate) between a U.S. Dollar and English Pound: 

```swift
func avgExchangeRate(numbers: Double...) -> Double {
 
  var total: Double = 0
  let numValues = Double(numbers.count)
     
  for number in numbers {
    total += number
  }

  return total / numValues
}
```

In the code above:
- `numbers` is a variadic parameter that accepts zero or more values of the type, `Double`. It is interpreted as an Array within the function. 
- A `for`-`in` loop is used to iterate over each `number` in `numbers` and add the value of `number` to the `total` each time. 
- After the `for`-`in` loop completes iterating, the average is calculated by dividing the `total` by the number of items, `numValues`, in `numbers`. 

We can invoke the function with the following exchange rates recorded for 6 days in February 2020: 

```swift 
print(avgExchangeRate(numbers: 0.81380, 0.77268, 0.77453, 0.75466, 0.75729, 0.78241))

// Prints: 0.7758949999999999
```

Each decimal gets passed into the function body and iterated over in the `for`-`in` loop. Here's a breakdown of the values: 



Variable    | Value
-------- | -----
`total` | 4.65537
`numValues` | 6.0
`total / numValues` | 0.7758949999999999

Variadic Parameters

When studying Swift loops, we've seen underscores used in place of a variable name [in a `for`-`in` loop](https://www.codecademy.com/courses/learn-swift/lessons/swift-loops/exercises/using-underscore). In functions, a similar concept applies - an underscore, (`_`), can be used in front of a parameter name in the function definition to allow for that parameter name to be omitted in the function call. 

When an `_` is specified ahead of a parameter name in the definition, only the argument value needs to be specified in the function call: 

```pseudo 
func funcName(_ paramName: paramType) -> returnType {
 // function body 
}

funcName(argument)  // function call 
```

**Note**: The `_` has a strict placement in the function definition; it must be placed at least one space ahead of the parameter name otherwise, the compiler will throw an error.   

Take a look at the following program that determines the winner of a game using each team's final points:

```swift 
let 1stTeamScore = 5
let 2ndTeamScore = 7

func findWinner(_ firstPoints: Int, secondPoints: Int) -> String {
  if firstPoints > secondPoints {
   return "Team 1 is the winner"
  } else {
   return "Team 2 is the winner" 
 }
}

print(findWinner(1stTeamScore, secondPoints: 2ndTeamScore))

// Prints: Team 2 is the winner
```

In the program above:

- The team scores are stored in constants at the top.
- The function compares points using an `if`/`else` statement and determines the final winner.
- The first parameter is omitted in the function call because of the `_`, meanwhile the second parameter name must be present. 

Notice how omitting the first argument label in the function call results in cleaner code and less repetition. 

So far in this lesson, we've used parameter names in function calls thus using an `_` and omitting a parameter name is entirely optional. Many developers prefer this syntax because it: 

1. Improves readability
2. Avoids repetition in the function call
3. Relates to how functions are called in various other programming languages 


Omitting Argument Labels

Now that we’ve practiced defining a function, let’s learn about calling a function to execute the code within its body.

The process of executing the code inside the body of a function is known as _calling_ it. To call a function in Swift, type out its name followed by parentheses `()`.

Take the following `makeSushiRoll()` function which holds step by step instructions on how to make a sushi roll: 

```swift 
func makeSushiRoll() {
 print("First, spread rice on Nori")
 print("Next, add fillings")
 print("Carefully roll the sushi")
 print("Cut the sushi")
 print("Serve 🍣") 
} 
```

To call our function, we must type out the function's name followed by a pair of parenthesis: 

```swift
makeSushiRoll()
```

Calling the function will execute the `print()` statements within the body and result in the following output:

```bash
First, spread rice on Nori
Next, add fillings
Carefully roll the sushi
Cut the sushi
Serve 🍣
```

Now it's your turn to call a function! 

Calling a Function

[Swift version 5.1](https://www.swift.org/blog/swift-5.1-released/), released in February 2020, includes a newly supported feature for functions known as an implicit return. It exists in various other programming languages and aids in shortening the code within a function. 

So far, we've used the `return` keyword in each one of our functions that expects a value returned. When there's only a single expression or value in the body, we can use Swift's _implicit return_ feature, omitting the `return` keyword, and still return our value. 

Take a look at the following function:

```swift
func findProduct(a: Int, b: Int) -> Int {
 return a * b
}
```

`findProduct(a:b:)` accepts two `Int` parameters and returns their product in `Int` form. Since the function contains a single expression, we can practice implicitly returning the expression by removing the `return` keyword:

```swift
func findProduct(a: Int, b: Int) -> Int {
 a * b
}
```

Both strategies will yield the same result when invoked:

```swift 
print(findProduct(a: 4, b: 7)) // Prints: 28
```

Implicit returns are optional and solely used for shortening the code within a function body. They are not mandatory and are up to the developer's stylistic preference. 

**Note**:  Both explicit and implicit returns are valid but keep in mind that implicit returns are only supported in Swift version 5.1 or later. Using an implicit return in earlier versions will elicit the following error:

```error 
error: missing return in a function expected to return 'Int'
```

Implicit Return 

Programs can manage more than one type of data and so can a function. We've previously only worked with one parameter per function, but Swift functions can accept multiple input values at a time separated by commas.  

Take a function, for example, that determines if a race car driver can proceed to the next round of qualifications given their current performance. Since this depends on two different types of data, the driver's speed and state of the car, we can set up multiple parameters in a function: 

```swift
func didQualify(slowestDriver: Bool, retired: Bool) -> String {

  if slowestDriver || retired {
    return "Eliminated"
  } else {
    return "Qualified"
  }
}
```

Let's peak under the hood:

- `slowestDriver` and `retired` are parameters of type `Bool` within the function, `didQualify(slowestDriver:retired:)` that returns a `String` value.
- The parameters are used in an `if`/`else` statement to determine whether or not the driver continues on to the next round. 
 
Calling the function below, we pass in `true` for `slowestDriver`, and `false` for `retired`: 

```swift 
print(didQualify(slowestDriver: true, retired: false)) 
```

The `if` statement executes within the function with the Boolean values, and the functions returns `"Eliminated"`. 