How to use Swift @autoclosure

Consider a function that takes one argument, a simple closure that takes no argument:

func f(pred: () -> Bool) {    if pred() {        print("It's true")    }}

To call this function, we have to pass in a closure

f(pred: {2 > 1})// "It's true"

If we omit the braces, we are passing in an expression and that's an error:

f(pred: 2 > 1)// error: '>' produces 'Bool', not the expected contextual result type '() -> Bool'

@autoclosure creates an automatic closure around the expression. So when the caller writes an expression like 2 > 1, it's automatically wrapped into a closure to become {2 > 1} before it is passed to f. So if we apply this to the function f:

func f(pred: @autoclosure () -> Bool) {    if pred() {        print("It's true")    }}f(pred: 2 > 1)// It's true

So it works with just an expression without the need to wrap it in a closure.

Here's a practical example — my print override (this is Swift 3):

func print(_ item: @autoclosure () -> Any, separator: String = " ", terminator: String = "\n") {    #if DEBUG    Swift.print(item(), separator:separator, terminator: terminator)    #endif}

When you say print(myExpensiveFunction()), my print override overshadows Swift's print and is called. myExpensiveFunction() is thus wrapped in a closure and not evaluated. If we're in Release mode, it will never be evaluated, because item() won't be called. Thus we have a version of print that doesn't evaluate its arguments in Release mode.

Description of auto_closure from the docs:

You can apply the auto_closure attribute to a function type that has a parameter type of () and that returns the type of an expression (see Type Attributes). An autoclosure function captures an implicit closure over the specified expression, instead of the expression itself. The following example uses the auto_closure attribute in defining a very simple assert function:

And here's the example apple uses along with it.

func simpleAssert(condition: @auto_closure () -> Bool, message: String) {    if !condition() {        println(message)    }}let testNumber = 5simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")

Basically what it means is you pass a boolean expression as that first argument instead of a closure and it automatically creates a closure out of it for you. That's why you can pass false into the method because it is a boolean expression, but can't pass a closure.