Autoclosures (@autoclosure) in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using @autoclosure?

Consider the following Swift code snippet. What will be printed when it runs?

Swift

func logIfTrue(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print("It's true!")
    } else {
        print("It's false!")
    }
}

logIfTrue(2 > 1)

A It's true!

B It's false!

C Compilation error due to missing parentheses

D Runtime error

💡 Hint

Remember that @autoclosure delays evaluation until the function uses the predicate.

The @autoclosure attribute wraps the expression '2 > 1' so it is only evaluated when predicate() is called. Since 2 > 1 is true, the function prints "It's true!".

🧠 Conceptual

intermediate

What is the main benefit of using @autoclosure in Swift?

Why would a Swift programmer use the @autoclosure attribute on a function parameter?

A To force the expression to be evaluated multiple times

B To convert a closure into a normal function

C To delay the evaluation of an expression until it is used inside the function

D To automatically evaluate the expression before passing it

💡 Hint

Think about when the expression inside the function is actually run.

Using @autoclosure delays the evaluation of the passed expression until the function explicitly calls it, which can improve readability and performance by avoiding unnecessary computation.

🔧 Debug

advanced

Why does this Swift code cause a compile error?

Examine the code below. Why does it fail to compile?

Swift

func check(_ condition: @autoclosure () -> Bool) {
    if condition {
        print("True")
    } else {
        print("False")
    }
}

check(5 > 3)

A Because the function call is missing parentheses

B Because the condition parameter is missing the @escaping attribute

C Because @autoclosure cannot be used with Bool return types

D Because @autoclosure parameters must be called as functions inside the body

💡 Hint

How do you use a closure parameter inside a function?

The parameter 'condition' is a closure due to @autoclosure, so it must be called with parentheses 'condition()' to get the Bool value. Using 'if condition' causes a type mismatch error.

📝 Syntax

advanced

Which option correctly declares a function with an @autoclosure parameter that can escape?

Select the correct Swift function declaration that uses @autoclosure and allows the closure to escape the function body.

A func storeCondition(_ condition: @autoclosure () -> Bool) { /* ... */ }

B func storeCondition(_ condition: @autoclosure @escaping () -> Bool) { /* ... */ }

C func storeCondition(_ condition: @escaping @autoclosure () -> Bool) { /* ... */ }

D func storeCondition(_ condition: () -> @autoclosure Bool) { /* ... */ }

💡 Hint

Remember the order of attributes matters in Swift.

The correct syntax places @autoclosure before @escaping: '@autoclosure @escaping () -> Bool'. Option B is correct. Option B reverses the order which is invalid. Option B is invalid syntax. Option B lacks @escaping.

🚀 Application

expert

How many times is the expression evaluated in this Swift code?

Given the code below, how many times will the expression 'print("Evaluated") ; return true' be executed?

Swift

func test(_ condition: @autoclosure () -> Bool) {
    if condition() {
        print("First check passed")
    }
    if condition() {
        print("Second check passed")
    }
}

test(print("Evaluated"); return true)

A Twice

B Zero times

C Once

D Three times

💡 Hint

Think about when the closure is called and how many times.

The @autoclosure wraps the expression, but each call to condition() evaluates it again. Since condition() is called twice, the expression runs twice, printing "Evaluated" two times.