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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function assigned to a variable

What is the output of this Swift code?

Swift

func greet(name: String) -> String {
    return "Hello, \(name)!"
}

let greeter = greet
print(greeter("Alice"))

A Error: Cannot assign function to variable

B greet

C Hello, greeter!

D Hello, Alice!

💡 Hint

Remember, in Swift, functions can be assigned to variables and called through them.

The function greet is assigned to the variable greeter. Calling greeter("Alice") runs the original function, producing "Hello, Alice!".

🧠 Conceptual

intermediate

Why can Swift functions be passed as arguments?

Why can Swift functions be passed as arguments to other functions?

A Because Swift automatically converts functions to strings when passed as arguments.

B Because functions are treated as values and can be stored in variables or passed around.

C Because functions are only allowed as global variables in Swift.

D Because Swift does not support passing functions as arguments.

💡 Hint

Think about what it means for functions to be 'first-class'.

Functions in Swift are first-class citizens, meaning they can be assigned to variables, passed as arguments, and returned from other functions just like any other value.

🔧 Debug

advanced

Identify the error when returning a function

What error does this Swift code produce?

Swift

func makeIncrementer() -> (Int) -> Int {
    func addOne(number: Int) -> Int {
        return number + 1
    }
    return addOne
}

A Error: Cannot call function when returning, should return function itself

B No error, returns a function correctly

C Error: Missing return type for inner function

D Error: addOne is not defined

💡 Hint

Look carefully at what is returned: the function call or the function itself?

The code tries to return addOne(), which calls the function and returns an Int. The return type expects a function (Int) -> Int, so it should return addOne without parentheses.

📝 Syntax

advanced

Correct syntax for function type variable

Which option correctly declares a variable that holds a function taking an Int and returning a String?

A var converter: (Int) -> String

B var converter: (Int) => String

C var converter: Int -> String

D var converter = Int -> String

💡 Hint

Remember the syntax for function types in Swift uses parentheses and arrow.

The correct syntax for a function type variable is var name: (InputType) -> ReturnType. Option A follows this.

🚀 Application

expert

Using functions as first-class citizens to sort an array

Given this Swift code, which option correctly sorts the array numbers in descending order using a function passed as an argument?

Swift

let numbers = [3, 1, 4, 2]

func descending(_ a: Int, _ b: Int) -> Bool {
    return a > b
}

let sortedNumbers = numbers.sorted(by: ???)
print(sortedNumbers)

A { a, b in a < b }

B descending()

C descending

D numbers.descending

💡 Hint

When passing a function as an argument, do you call it or just pass its name?

The sorted(by:) method expects a function of type (Int, Int) -> Bool. Passing descending (without parentheses) passes the function itself. Using descending() calls the function and passes its result, which is incorrect.