Functions as types in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean that functions are types in Swift?

In Swift, functions can be treated like any other type, such as Int or String. This means you can store functions in variables, pass them as arguments, and return them from other functions.

beginner

How do you declare a variable that holds a function taking two Ints and returning an Int?

You declare it like this: var operation: (Int, Int) -> Int. This means operation is a variable that stores a function which takes two Int values and returns an Int.

intermediate

Can you pass a function as a parameter to another function in Swift? How?

Yes! You specify the parameter type as a function type. For example: func performOperation(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int. Then you can call operation(a, b) inside the function.

intermediate

What is the syntax to return a function from another function in Swift?

You specify the return type as a function type. For example: func makeAdder(_ x: Int) -> (Int) -> Int returns a function that takes an Int and returns an Int.

beginner

Why is treating functions as types useful in Swift?

It allows you to write flexible and reusable code. You can pass behavior around, customize actions, and create powerful abstractions like callbacks and event handlers.

How do you declare a variable that holds a function taking a String and returning Void in Swift?

A var action: (String) -> Void

B var action: String -> Void

C var action: (String) => Void

D var action: function(String) -> Void

The correct syntax uses parentheses around parameters and an arrow: (String) -> Void.

Which of these is a valid way to pass a function as a parameter in Swift?

A func run(operation: Int, Int) -> Int {}

B func run(operation: (Int, Int)) {}

C func run(operation: function) {}

D func run(operation: (Int, Int) -> Int) {}

Option D correctly declares a parameter that is a function taking two Ints and returning an Int.

What is the return type of this function? func makeMultiplier() -> (Int) -> Int

A A function that takes an Int and returns an Int

B An Int value

C A tuple of Ints

D Void

The return type (Int) -> Int means the function returns another function that takes an Int and returns an Int.

Can you assign a function to a variable in Swift?

A Only if the function returns Void

B No, functions cannot be assigned to variables

C Yes, if the variable type matches the function type

D Only if the function has no parameters

Functions are types, so you can assign them to variables if the types match.

What is the benefit of using functions as types?

A It makes code run faster

B It allows passing behavior as data

C It prevents errors automatically

D It makes variables immutable

Using functions as types lets you pass behavior around, making code more flexible.

Explain how you can use functions as types to pass a function as an argument in Swift.

Think about how you write the parameter type and how you use it inside the function.

Describe how returning a function from another function works and why it might be useful.

Consider how you can create customized functions on the fly.

Practice

1. What does it mean when we say "functions are types" in Swift?

easy

A. Functions can be stored in variables and passed around like values.

B. Functions cannot be assigned to variables.

C. Functions must always return an Int type.

D. Functions cannot accept parameters.

Solution

1. Step 1: Understand the concept of types in Swift

   In Swift, types define what kind of values variables can hold.

2. Step 2: Apply this to functions

   Functions have types too, meaning they can be assigned to variables, passed as arguments, or returned from other functions.

3. Final Answer:

   Functions can be stored in variables and passed around like values. -> Option A

4. Quick Check:

   Functions as values = Functions can be stored in variables and passed around like values. [OK]

Hint: Remember: functions behave like any other value in Swift [OK]

Common Mistakes:

• Thinking functions can't be assigned to variables
• Assuming functions must return Int
• Believing functions can't take parameters

2. Which of the following is the correct way to declare a variable that holds a function taking two Ints and returning an Int?

easy

A. var operation: (Int, Int) Int

B. var operation: Int -> Int -> Int

C. var operation: (Int Int) -> Int

D. var operation: (Int, Int) -> Int

Solution

1. Step 1: Recall Swift function type syntax

   Function types are written as (ParameterTypes) -> ReturnType, with parameters separated by commas.

2. Step 2: Check each option

   var operation: (Int, Int) -> Int correctly uses (Int, Int) -> Int. Others have syntax errors or missing arrows.

3. Final Answer:

   var operation: (Int, Int) -> Int -> Option D

4. Quick Check:

   Correct function type syntax = var operation: (Int, Int) -> Int [OK]

Hint: Use (Type1, Type2) -> ReturnType for function types [OK]

Common Mistakes:

• Omitting commas between parameter types
• Missing arrow '->' in function type
• Incorrect parameter grouping

3. What will be the output of the following Swift code?

func add(_ a: Int, _ b: Int) -> Int { a + b }
var mathOperation: (Int, Int) -> Int = add
print(mathOperation(3, 4))

medium

A. 7

B. 34

C. Error: Cannot assign function

D. 0

Solution

1. Step 1: Understand function assignment

   The function 'add' matches the type (Int, Int) -> Int, so it can be assigned to 'mathOperation'.

2. Step 2: Evaluate the function call

   Calling mathOperation(3, 4) calls add(3, 4), which returns 3 + 4 = 7.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   Function call result = 7 [OK]

Hint: Assign matching function types to variables to call them [OK]

Common Mistakes:

• Expecting string concatenation instead of addition
• Thinking function assignment causes error
• Confusing function call syntax

4. Identify the error in this Swift code snippet:

var multiply: (Int, Int) -> Int
multiply = { a, b in a * b }
print(multiply(2))

medium

A. Missing return statement in closure

B. Variable multiply not initialized

C. Calling multiply with wrong number of arguments

D. Incorrect closure syntax

Solution

1. Step 1: Check closure assignment

   The closure { a, b in a * b } correctly matches (Int, Int) -> Int type.

2. Step 2: Check function call

   Calling multiply(2) provides only one argument, but multiply expects two Ints.

3. Final Answer:

   Calling multiply with wrong number of arguments -> Option C

4. Quick Check:

   Argument count mismatch = Calling multiply with wrong number of arguments [OK]

Hint: Match argument count with function type parameters [OK]

Common Mistakes:

• Assuming closure needs explicit return
• Ignoring argument count in function call
• Thinking variable is uninitialized

5. Given the function type (Int) -> (Int) -> Int, what does this type represent in Swift?

hard

A. A function that takes an Int and returns an Int array.

B. A function that takes an Int and returns another function that takes an Int and returns an Int.

C. A function that takes two Ints and returns an Int.

D. A function that takes no parameters and returns an Int.

Solution

1. Step 1: Analyze the nested function type

   The type (Int) -> (Int) -> Int means the function takes one Int and returns another function.

2. Step 2: Understand the returned function

   The returned function itself takes an Int and returns an Int.

3. Final Answer:

   A function that takes an Int and returns another function that takes an Int and returns an Int. -> Option B

4. Quick Check:

   Curried function type = A function that takes an Int and returns another function that takes an Int and returns an Int. [OK]

Hint: Read from left to right: input then output, output can be a function [OK]

Common Mistakes:

• Confusing nested function types with multiple parameters
• Assuming it returns an array
• Ignoring that return type can be a function