Autoclosures (@autoclosure) in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an @autoclosure in Swift?

An @autoclosure automatically wraps an expression in a closure, delaying its evaluation until it's called. It lets you write cleaner code by avoiding explicit closure syntax.

beginner

How does @autoclosure improve function call syntax?

It lets you pass an expression directly instead of a closure, making the call look simpler and more natural, while still delaying evaluation.

intermediate

Example: What does this function signature mean?<br>

func logIfTrue(_ predicate: @autoclosure () -> Bool)

It means you can pass a Boolean expression directly to logIfTrue, and the expression will only be evaluated inside the function when needed.

intermediate

Why use @autoclosure instead of a normal closure?

Because it makes the call site cleaner and easier to read by letting you write expressions directly, without extra braces or { } syntax.

advanced

Can @autoclosure be combined with @escaping? What does that mean?

Yes, combining @autoclosure with @escaping means the delayed expression can be stored and called later, not just during the function call.

What does @autoclosure do in Swift?

A Automatically wraps an expression in a closure delaying its evaluation

B Immediately executes a closure

C Converts a closure to a function

D Prevents a closure from capturing variables

@autoclosure wraps an expression so it runs only when called, delaying evaluation.

Which is a benefit of using @autoclosure?

A Prevents functions from returning values

B Forces immediate evaluation of expressions

C Automatically unwraps optionals

D Simplifies function call syntax by allowing expressions instead of closures

@autoclosure lets you pass expressions directly, making calls cleaner.

How do you declare a function parameter as an autoclosure?

A Use <code>inout</code> keyword

B Use <code>@autoclosure</code> before the parameter type

C Use <code>lazy</code> keyword

D Use <code>@escaping</code> before the parameter type

Place @autoclosure before the parameter type to declare it.

What happens if you combine @autoclosure with @escaping?

A The closure can be stored and called later, not just immediately

B The closure runs immediately

C The closure cannot capture variables

D The closure is converted to a synchronous function

Combining @autoclosure and @escaping allows delayed execution beyond the function call.

Which of these is a correct use of @autoclosure?

A func check(_ condition: () -> Bool) { if condition { print("True") } }

B func check(_ condition: Bool) { if condition { print("True") } }

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

D func check(_ condition: @escaping Bool) { if condition { print("True") } }

Option C correctly declares an autoclosure parameter and calls it inside the function.

Explain what @autoclosure does and why it is useful in Swift.

Think about how it changes the way you write function arguments.

Describe a situation where combining @autoclosure with @escaping would be helpful.

Consider when you want to save a condition to check later.