Why functions are first-class in Swift - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function variable that adds two numbers.

Swift

let add: (Int, Int) -> Int = [1]

Drag options to blanks, or click blank then click option'

Aadd(a: Int, b: Int) -> Int { a + b }

Bfunc add(a: Int, b: Int) -> Int { return a + b }

C{ (a, b) in a + b }

D(a, b) -> a + b

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to assign a function declaration instead of a closure.

Missing the 'in' keyword in the closure.

In Swift, you can assign a closure to a variable. The correct syntax for a closure that adds two numbers is { (a, b) in a + b }.

2fill in blank

medium

Complete the code to call the function stored in the variable.

Swift

let result = add[1]3, 5)

Drag options to blanks, or click blank then click option'

A<

B[

C{

D(

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets or braces instead of parentheses.

Forgetting to include the opening parenthesis.

To call a function or closure in Swift, use parentheses with arguments inside, like add(3, 5).

3fill in blank

hard

Fix the error in the function assignment by choosing the correct syntax.

Swift

let multiply: (Int, Int) -> Int = [1](a, b) in { return a * b }

Drag options to blanks, or click blank then click option'

A{

Bfunc

Clet

Dvar

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'func' keyword inside a closure assignment.

Not using curly braces for closures.

When assigning a closure to a variable, use curly braces {} around the closure body, not the func keyword.

4fill in blank

hard

Fill both blanks to create a function that takes another function as a parameter and calls it.

Swift

func performOperation(_ operation: (Int, Int) -> Int, _ a: Int, _ b: Int) -> Int {
    return operation[1]a, b[2]
}

Drag options to blanks, or click blank then click option'

A(

B)

C[

D]

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets instead of parentheses.

Forgetting to close the parentheses.

To call the function parameter operation, use parentheses around the arguments: operation(a, b).

5fill in blank

hard

Fill all three blanks to create a dictionary that maps strings to functions and call one of them.

Swift

let operations: [String: (Int, Int) -> Int] = [
    "add": [1],
    "subtract": [2]
]

let result = operations["add"][3](10, 5)!

Drag options to blanks, or click blank then click option'

A{ (a, b) in a + b }

B{ (a, b) in a - b }

C?

D!

Attempts:

3 left

💡 Hint

Common Mistakes

Using '?' instead of '!' to unwrap the optional.

Not using closures as dictionary values.

The dictionary stores closures for addition and subtraction. To call a function from the dictionary safely, use the forced unwrap operator ! after the call, since the dictionary returns an optional.

Practice

1. Why are functions considered first-class citizens in Swift?

easy

A. Because functions can be assigned to variables and passed as arguments

B. Because functions cannot return values

C. Because functions must always be declared globally

D. Because functions cannot be nested inside other functions

Solution

1. Step 1: Understand what first-class means in Swift

   First-class means functions can be treated like any other value, such as assigned to variables or passed around.

2. Step 2: Identify the correct property of functions in Swift

   Swift allows functions to be stored in variables and passed as arguments, which matches the definition of first-class citizens.

3. Final Answer:

   Because functions can be assigned to variables and passed as arguments -> Option A

4. Quick Check:

   Functions as values = Because functions can be assigned to variables and passed as arguments [OK]

Hint: Remember: first-class means functions act like normal values [OK]

Common Mistakes:

• Thinking functions cannot be passed as arguments
• Believing functions must be global only
• Assuming functions cannot return values

2. Which of the following is the correct way to assign a function to a variable in Swift?

easy

A. let greet = func sayHello() { print("Hello") }

B. let greet = sayHello

C. func greet = sayHello()

D. var greet: sayHello = func()

Solution

1. Step 1: Recall Swift syntax for assigning functions

   In Swift, you assign a function by its name without parentheses to a variable or constant.

2. Step 2: Check each option for correct syntax

   let greet = sayHello correctly assigns the function name without calling it. Other options have syntax errors or misuse keywords.

3. Final Answer:

   let greet = sayHello -> Option B

4. Quick Check:

   Assign function by name without () = let greet = sayHello [OK]

Hint: Assign function by name only, no parentheses [OK]

Common Mistakes:

• Adding parentheses when assigning function
• Using 'func' keyword in assignment
• Incorrect variable declaration syntax

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

func multiplyByTwo(_ number: Int) -> Int {
    return number * 2
}

let operation = multiplyByTwo
print(operation(5))

medium

A. 5

B. multiplyByTwo

C. 10

D. Error: Cannot assign function to variable

Solution

1. Step 1: Understand function assignment and call

   The function multiplyByTwo is assigned to 'operation' without calling it, so 'operation' is a function reference.

2. Step 2: Call the function through the variable

   Calling operation(5) runs multiplyByTwo(5), which returns 5 * 2 = 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Function call via variable returns 10 [OK]

Hint: Calling assigned function runs original logic [OK]

Common Mistakes:

• Expecting variable to hold result, not function
• Confusing function name with string output
• Thinking assignment causes error

4. Identify the error in this Swift code snippet:

func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

let sum = add(3, 4)
let operation = add(3, 4)
print(operation(5, 6))

medium

A. Function add is not defined properly

B. Missing return statement in add function

C. Cannot assign function call to a constant

D. Cannot call operation as a function because it holds an Int, not a function

Solution

1. Step 1: Analyze variable assignments

   sum is assigned the result of add(3, 4), which is an Int (7). operation is also assigned add(3, 4), so operation is an Int, not a function.

2. Step 2: Check the call to operation(5, 6)

   Since operation is an Int, calling operation(5, 6) causes an error because Int is not callable.

3. Final Answer:

   Cannot call operation as a function because it holds an Int, not a function -> Option D

4. Quick Check:

   Calling Int as function causes error = Cannot call operation as a function because it holds an Int, not a function [OK]

Hint: Assign function name, not function call, to variable [OK]

Common Mistakes:

• Assigning function call instead of function reference
• Expecting function call to be callable again
• Ignoring type mismatch errors

5. How can you write a Swift function that returns another function which adds a fixed number to its input? For example, calling makeAdder(3)(5) should return 8.

hard

A. func makeAdder(_ x: Int) -> (Int) -> Int {
return { y in x + y }
}

B. func makeAdder(_ x: Int) -> Int {
return x + y
}

C. func makeAdder(x: Int, y: Int) -> Int {
return x + y
}

D. func makeAdder(_ x: Int) -> (Int) {
return x
}

Solution

1. Step 1: Understand the requirement for returning a function

   The function makeAdder must return another function that takes an Int and adds it to x.

2. Step 2: Check which option returns a function type

   func makeAdder(_ x: Int) -> (Int) -> Int { return { y in x + y } } returns a closure (function) of type (Int) -> Int that adds x and y, matching the requirement.

3. Final Answer:

   func makeAdder(_ x: Int) -> (Int) -> Int { return { y in x + y } } -> Option A

4. Quick Check:

   Return function adding x to input = func makeAdder(_ x: Int) -> (Int) -> Int { return { y in x + y } } [OK]

Hint: Return a closure capturing x to add later [OK]

Common Mistakes:

• Returning Int instead of function
• Not using closure syntax for returned function
• Incorrect function signature