Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Learn how to how closures to define and call higher-order functions.

Closures

So far we have defined closures without arguments or return values. Just like with functions, it’s very useful for our closures to be able to accept inputs, perform tasks with the inputs, and return a value. Let’s see how we can do that with closures.

Word of our closure aptitude is getting out... We have been tasked by the science division to create a closure that converts meters into feet for use in their super-secret project.

First off, we need the formula for converting meters into feet:
```
LengthInFeet = LengthInMeters * 3.281
```
Let’s see how we can represent this as a closure and then break it down.  This time we will declare the types within the open brace, but they could also be defined after the variable name using type annotation as in the previous exercise.

```swift
let metersToFeet = { (meters: Double) -> Double in
  return meters * 3.281
}
```

We define a closure that takes a `Double` as an argument. We name the argument `meters`, and the closure returns a value of type  `Double`. The closure execution, following the `in` keyword, uses the formula above to convert the input argument `meters` into feet.
The closure is assigned to a constant named `metersToFeet`.

And here is what declaring the types after the variable name with type annotation looks like:

```swift
let metersToFeet: (Double) -> Double = { meters in
  return meters * 3.281
}
```

We can even use type inference define the closure:
  
```swift
let metersToFeet = { meters in
  return meters * 3.281
}
```

Swift knows that the type of `metersToFeet` must be `(Double) -> Double` because the only type that can be multiplied by `3.281` is a `Double`.


Let’s test it out by calling a few landmarks:

```swift
print(metersToFeet(1)) // prints "3.281"

// the height of the eiffel tower:
print(metersToFeet(324)) // prints "1063.044"

// the height of the empire state building:
print(metersToFeet(443.2)) // prints "1454.2"
```
Looks pretty good! The science division is going to be very happy with our work!


Inputs and Outputs

Up until this point we have been fairly explicit about defining the type of the closure, assigning it to a variable, and passing the variable to a function. With Swift being a strongly typed language, we can use type inference to our advantage and cut down on our coding footprint. This means we can define closures as we call functions without having to assign it to a variable.

On top of that, Swift has a feature named “Trailing Closures.” If a closure is the last argument in a function, we can write the trailing closure after the function's closing parenthesis, inline with the function. Let’s take a look at a common task that accepts a closure:

```swift
func networkRequest(endAction: () -> Void) {
  // Get data from online
   completion()
}
```

Above we have a function named `networkRequest` which accepts a closure as an argument named `completion`. The closure has no inputs or outputs. Rather than defining a closure and assigning it to a variable, we can define the closure inline when we call the function:

```swift
networkRequest(endAction: {
   print("Data loaded!")
})
```

Pretty neat huh? This is referred to as an inline closure and is used extensively in Swift. Also, because the closure is the last argument in the function declaration, we can omit the parameter name when calling it:

```swift
networkRequest {
    print("Data loaded!")
}
```

In Swift, you can have multiple trailing closures: 

```swift
func networkRequest(startAction: () -> Void, endAction: () -> Void) {
   startAction()
  // function execution
   endAction()
}
```
Can be called:

```swift
networkRequest {
  print("Starting to load!")
} endAction: {
  print("Data loaded!")
  // closure 2 statements
}
```

We expand the `networkRequest` to accept two closures as arguments. Because these are the last two arguments of the function declaration, we can provide inline, trailing closures as arguments.


Closure expressions and trailing closure syntax

Great work!  Closures are an important tool in Swift that allows you to write and use higher-ordered functions.  In this lesson, you learned how to:

- Define closures
- Pass closures to functions
- Use trailing closure syntax and closure syntax sugar
- Call built-in higher-order functions like `filter`
- Mark closures as `@escaping` so they can be stored for later
- Capture values inside a closure

Using closures and higher-ordered functions can be a great way to make your code more compact and readable!

Review

Because closures are so common in Swift, there are quite a few niceties or “syntactic sugar” that are available to shorten your code. To explain these, let’s take a look at a function that takes a closure as an argument:

```swift
func performOperation(on valueOne: Int, and valueTwo: Int, using operation: (Int, Int) -> Int) -> Int {
    operation(valueOne, valueTwo)
}
```
Let’s break down how we can shorten our code with Swift closure syntax when calling the `performOperation(int1:int2:_)` above. Let’s start with a fully explicit call:

```swift
performOperation(on: 1, and: 3, using: { (valueOne: Int, valueTwo: Int) -> Int in
  return valueOne + valueTwo
})
```
Here we pass an inline closure to the operation input. We explicitly define the parameter types `(valueOne: Int, valueTwo: Int)` and return type `Int`. This is all well and good and perfectly valid code. But, it can be shortened quite a bit. If you recall from the last exercise, we could use trailing closure syntax to shorten the calling code here.

```swift
performOperation(on: 1, and: 3) { (valueOne: Int, valueTwo: Int) -> Int in
  return valueOne + valueTwo
}
```
Now, let’s dive into the other syntax shortening niceties that Swift provides:

Type inference: Swift is a strongly typed language meaning it can infer the types based on the function definition. Above, we don’t need to be explicit with the parameter types and return types:

```swift
performOperation(on: 1, and: 3) { valueOne, valueTwo in
 return valueOne + valueTwo
}
```

Implicit returns: If a closure has a single expression, the `return` keyword can be omitted. Swift can infer the return type based on the function definition:

```swift
performOperation(on: 1, and: 3) { valueOne, valueTwo in
 valueOne + valueTwo
}
```

Shorthand argument names: argument names can be omitted in favor of `$0`, `$1`, and so on, corresponding to each argument in the closure. Although this does shorten your calling code, it can sacrifice readability so use with caution:

```swift
performOperation(on: 1, and: 3) { $0 + $1 }
```

And lastly, operators: Swift’s `Int` type has an Int-specific definition of the `+` operation that matches the type of the closure. This mean we can pass a single operator as to the closure:

```swift
performOperation(on: 1, and: 3, using: +)
```

Notice we need the `using` argument label here. This is because `+` is a static function that adds two numbers together. Up until this point, we have been passing anonymous closures which are defined inline with the function call.

Pretty neat, eh? This is quite readable and can be reused with other operators like `-`, `\` and `*`. 


Closure syntactic sugar

Before we define a closure let’s recall the function definition from the **Functions** module. This will be helpful to reference while we step through the closure definition.

```swift
func functionName(parameters) -> ReturnType {
  // function tasks go here
}
```

And here is how we define a closure:

```swift
{ (parameters) -> returnType in
  // closure tasks go here
}
```
Notice any similarities between the definitions of a closure and a function? A closure kind of looks like a compressed function. The parameters and return types are inside the braces, and the `in` keyword separates them from the body. Let’s take a look at the closure definition in-depth:

* The open and closing braces are the beginning and end of the closure definition.
* `parameters` are what gets passed into the closure, just like function parameters. They are available within the closure. These are omitted if there are no parameters.
* The parameters are followed by an arrow and the return type (`-> returnType`). This is what the closure will return once execution is complete. If the closure doesn’t return anything, use the keyword `Void` or omit the return type and arrow entirely.
* `in` is a keyword that separates the input parameters and return type from the closure execution. 
* Any tasks the closure performs follow the `in` keyword.


Now that we have the basic definition of a closure, let’s take a look at an example:

```swift
let myClosure = {
  print("This is my closure")
}
```
This is a common way to define a closure. Closures can be assigned to variables just like any other type.  We can also define a closure using type annotation:

```swift
let myClosure: () -> Void = {
  print("This is my closure")
}
```

While it’s generally preferred to use type inference, it is a matter of preference how a closure is defined. 
Now that we have defined our closure, we can call it just like a function:

```swift
myClosure()  // prints “This is my closure”
```

Great! Not so bad right? If you get confused about the syntax, you can always reference the definitions above.

Defining a closure

A higher order function is a function that takes a closure as input or a functions that returns a closure. This is something we have defined ourselves already in the previous exercises. In this exercise we're going to take a look at some higher-order functions provided by Swift to help with common programming operations. The most common are `filter`, `sort`, `map` and `reduce`. Each of these are functions that take a closure as input and perform operations with the given closure.

We’re going to take a look at the `filter` function. We have an array of test grades below and we want to filter out the failing grades. 

```swift
var grades = [85, 76, 59, 47, 91, 88, 99, 64, 77, 50, 60, 80]
```

We want to filter out the grades that are below 60. Swift’s built-in `filter` function allows us to do just this. We provide a closure to the function telling it what we want to be filtered, and the function returns an array of integers that meet the criteria. Let’s take a look at this in action:

```swift
let passingGrades = grades.filter { (grade) -> Bool in
  return grade >= 60
}
```

Pretty cool. Swift provides a `filter` function on collections which we can use to easily filter our data. Above, we call `filter` on `grades` with the dot syntax, and provide an inline closure to define exactly what we want to include in the array. This is saying, “Include any grade that is greater than or equal to 60”. 

If you recall from the syntactic sugar exercise, we can shorten the calling code:

```swift
let passingGrades = grades.filter { $0 >= 60 }
```
Similarly, there is a `sorted(by:)` function for collections which we can use to sort data. Let’s sort our grades array from the lowest score to the highest:

```swift
print(grades.sorted(by: <)) // prints [47, 50, 59, 60, 64, 76, 77, 80, 85, 88, 91, 99]
```

How convenient!


Built-in Higher-Order Functions

It is possible for a closure to be called after the function it was passed into returns. This is called an *escaping closure* and is wrapped with the `@escaping` keyword. This is common when a function takes a closure, performs a long-running operation (e.g. a network request), and calls the closure after the function has returned. Closures also escape when they are assigned to a variable to be used later on. The closure may be called long after the calling function returns. Swift needs to hold a reference to the closure in this case which is accomplished with the `@escaping` keyword. Let’s take a look at an example:

```swift
struct Recipe {
  
  let ingredientAdder: (String) -> Void
  
  init(ingredientAdder: (String) -> Void) { //ERROR
    self.ingredientAdder = ingredientAdder
  }
}
```

Above we have a `struct` named `Recipe` that takes a closure in its initializer. Within the initializer, we assign it to a constant named `ingredientAdder` on the `Recipe` struct. This will not compile because we hold a reference to the closure via `ingredientAdder` which can be called at some point in the future. To fix this we wrap the closure with `@escaping` to tell the compiler to hold a reference to the closure for later use.

```swift
struct Recipe {
  
  let ingredientAdder: (String) -> Void
  
  init(ingredientAdder: @escaping (String) -> Void) { 
    self.ingredientAdder = ingredientAdder
  }
}
```


Escaping Closures 

Closures are first-class citizens in Swift. This means they can be assigned to variables and passed as arguments to functions. Now that we’ve looked at assigning them to variables, let’s see how we can pass them to functions.

A function that accepts a closure as an argument is known as a higher-order function. This pattern is very common in Swift, and we will take a closer look at some built-in higher-order functions in a later exercise.

For now though, the science division is so excited about the transformation closure that they assigned us another task! They would like us to create a function that takes a closure that describes a Teenage Mutant Ninja Turtle. We’re not quite sure what they’re cooking over there but it sounds pretty wild!

Let’s start by defining a closure that takes a `String` as input and prints the turtle’s ability to the console:

```swift
let turtleAbility: (String) -> Void = { turtle in  
  switch turtle {
  case "Leonardo":
    print("Jujitsu")
  case "Raphael":
    print("Super strength")  
  case "Donatello":
    print("Intelligence") 
  case "Michelangelo":
    print("Eating pizza")  
  default:
    print("Unknown TNMT")
  }
}
```

The closure definition should look familiar from the previous exercise. We name the closure `turtleAbility` which takes a `String` as an input and returns `Void`. Within the braces, we name the `String` parameter `turtle`. In the body of the closure, we switch on `turtle` and print its ability.

Next, lets define a function that takes a `String` and closure as a parameter:

```swift
func description(for turtle: String, descriptionClosure: (String) -> Void) {
  descriptionClosure(turtle)
}
```
We have a function named `description(for:descriptionClosure)` that takes a `String` as an input, named `turtle` and a closure named `descriptionClosure`. The closure type matches that of the `turtleAbility` we defined earlier. See where this is going? Just like with functions, if the type matches, we can pass it as an argument. Here’s what the calling code looks like:

```swift
description(for: "Michelangelo", descriptionClosure: turtleAbility) // prints “Eating pizza”
```

What’s cool about this is we can define an entirely new closure with the same type and pass it to the `description` function to get different functionality. Consider the following closure which print’s the turtle’s color:

```swift
let turtleColor: (String) -> Void = { turtle in  
  switch turtle {
  case "Leonardo":
    print("Blue")  
  case "Raphael":
    print("Red")  
  case "Donatello":
    print("Purple")  
  case "Michelangelo":
    print("Orange")  
  default:
    print("Unknown TNMT")
  }
}
```

And when we call the `description` function with the `turtleColor` closure:

```swift
description(for: "Donatello", descriptionClosure: turtleColor) // prints “Purple”
```

Awesome. Now we can pass closures to functions like it’s our own super ability! 


Passing a closure to a function

Up until now we have passed parameters into our closures to perform operations on. With closures we can also capture variables and constants outside the scope of the closure. This is known as “closing over” the values that are captured. One example is a nested function. Let’s take a look at a function that keeps track of new friends we make:

```swift
func makeFriendAdder() -> (String) -> [String] {
  var friends = [String]()
  let addFriend: (String) -> [String] = { name in
    friends.append(name)
    return friends
  }
  return addFriend
}
```
We have defined a function named `makeFriendAdder` that returns a closure that accepts a `String` and returns a `String` array. In the function’s body, we declare a variable named `friends` which is the array that will hold our friends. After that, we define a closure named `addFriend` with the same function return type. The closure closes over the `friends` array to add the name that is passed to the block. Finally we return the block. 

```swift
let friendAdder = makeFriendAdder()
friendAdder("Jake")
print(friendAdder("Kate")) // prints ["Jake", "Kate"]
```

The reason this is possible is because closures in Swift are reference types. When we assign the closure to the `friendAdder` constant we are creating a reference to the closure which has captured the `friends` array.

Also, with type inference, we can clean up the implementation a bit:

```swift
func makeFriendAdder() -> (String) -> [String] {
  var friends = [String]()
  return { name in
    friends.append(name)
    return friends
  }
}
```

The function return type matches the type of the closure we are returning so we can omit the type declarations.


Capturing Values

Closures are self-contained chunks of code that are first-class citizens in Swift. This means they can be assigned to variables and passed as arguments to functions. Closures may be referred to as blocks or lambdas in other programming languages. Closures can be a bit intimidating at first because of their syntax, but they are very similar to functions and are used extensively within the Swift language. In fact, as we’ll see, a function is a type of closure!

One main way that closures are used throughout Swift is with higher-order functions. Swift provides functions that take closures as arguments to perform common programming tasks. Filtering is one example of this.  To filter an array, we provide a closure that instructs the filtering function to remove elements that don't meet a condition.

Let’s get started by looking at the definition of a closure in the following exercise.


A conveyor belt that removes boxes that don't meet a condition.