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.

Practice

1. What does the @autoclosure attribute do in Swift?

easy

A. Converts a closure into a normal function

B. Forces immediate execution of a closure parameter

C. Automatically wraps an expression into a closure to delay its execution

D. Prevents a closure from capturing variables

Solution

1. Step 1: Understand the purpose of @autoclosure

   @autoclosure automatically wraps an expression passed as an argument into a closure, delaying its execution until called.

2. Step 2: Compare with other options

   Options B, C, and D describe behaviors unrelated to @autoclosure's purpose.

3. Final Answer:

   Automatically wraps an expression into a closure to delay its execution -> Option C

4. Quick Check:

   @autoclosure delays execution = A [OK]

Hint: Autoclosure delays code execution by wrapping it automatically [OK]

Common Mistakes:

• Thinking @autoclosure runs code immediately
• Confusing @autoclosure with normal closures
• Assuming it changes closure syntax

2. Which of the following is the correct way to declare a function parameter using @autoclosure in Swift?

easy

A. func check(_ condition: @autoclosure () -> Bool) { }

B. func check(@autoclosure condition: Bool) { }

C. func check(condition: @autoclosure Bool) { }

D. func check(_ condition: Bool @autoclosure) { }

Solution

1. Step 1: Recall correct syntax for @autoclosure

   The correct syntax places @autoclosure before the closure type: @autoclosure () -> Bool.

2. Step 2: Analyze each option

   func check(_ condition: @autoclosure () -> Bool) { } matches the correct syntax. Options A, B, and C misuse the attribute placement or type declaration.

3. Final Answer:

   func check(_ condition: @autoclosure () -> Bool) { } -> Option A

4. Quick Check:

   @autoclosure syntax = func check(_ condition: @autoclosure () -> Bool) { } [OK]

Hint: Remember: @autoclosure before closure type () -> Type [OK]

Common Mistakes:

• Placing @autoclosure after the type
• Using @autoclosure on non-closure types
• Omitting the closure arrow syntax

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

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

logIfTrue(3 > 5)

medium

A. True

B. Runtime crash

C. Compile-time error

D. False

Solution

1. Step 1: Understand the function behavior

   The function takes a condition as an autoclosure and calls it inside the if statement.

2. Step 2: Evaluate the passed expression

   The expression 3 > 5 is false, so predicate() returns false, triggering the else branch.

3. Final Answer:

   False -> Option D

4. Quick Check:

   3 > 5 is false, so output = False [OK]

Hint: Evaluate the expression inside autoclosure when called [OK]

Common Mistakes:

• Assuming autoclosure runs immediately before function call
• Confusing true/false logic
• Expecting compile errors due to autoclosure

4. Identify the error in this Swift function using @autoclosure:

func execute(_ action: @autoclosure () -> Void) {
    action
}

execute(print("Hello"))

medium

A. Missing parentheses to call the closure inside the function

B. Incorrect use of @autoclosure on a Void return type

C. Cannot pass print statement as autoclosure

D. Function parameter should not be marked @autoclosure

Solution

1. Step 1: Check how the closure is called inside the function

   The parameter action is a closure and must be called with parentheses: action().

2. Step 2: Identify the error

   The code uses action without parentheses, so the closure is not executed, causing no output.

3. Final Answer:

   Missing parentheses to call the closure inside the function -> Option A

4. Quick Check:

   Closure must be called with () = Missing parentheses to call the closure inside the function [OK]

Hint: Call autoclosure with () to execute it inside function [OK]

Common Mistakes:

• Forgetting to call the closure with parentheses
• Thinking @autoclosure forbids Void closures
• Assuming print can't be autoclosure

5. Consider this Swift code using @autoclosure to log messages only when needed:

func log(_ message: @autoclosure () -> String, onlyIf condition: Bool) {
    if condition {
        print(message())
    }
}

log("Debug info", onlyIf: false)

What is the main benefit of using @autoclosure here?

hard

A. The function runs faster because closures are always synchronous

B. The message string is constructed only if the condition is true, saving resources

C. The message is printed twice automatically

D. The condition parameter becomes optional

Solution

1. Step 1: Understand how @autoclosure delays evaluation

   The message string expression is wrapped in a closure and only evaluated when message() is called.

2. Step 2: Analyze the condition effect

   Since condition is false, message() is never called, so the string is not constructed, saving computation.

3. Final Answer:

   The message string is constructed only if the condition is true, saving resources -> Option B

4. Quick Check:

   @autoclosure delays message creation = The message string is constructed only if the condition is true, saving resources [OK]

Hint: Autoclosure delays expensive expressions until needed [OK]

Common Mistakes:

• Thinking message is always created regardless of condition
• Assuming autoclosure prints automatically
• Confusing condition with message parameter