9

I am converting code to Swift using Xcode 8, but compiler warns to add @escape in some of the nested functions already created in Swift 2.3, with closure syntax. I have found some other keywords also @noescape and @autoclosure, but I have some question regarding this :

  1. What is functional need of this keyword?
  2. What is impact of writing @escaping ?
  3. Is it necessary to write ?
  4. Is @autoclosure behave same as @escape?
  5. When to use which keyword and why ?

Here is Swift-evolution document, but not getting much from it.

XLE_22
  • 5,124
  • 3
  • 21
  • 72
technerd
  • 14,144
  • 10
  • 61
  • 92
  • I have just noticed that you have tagged the question Swift 3. There is no `@noescape` or `@escape` in Swift 3. – Sulthan Sep 21 '16 at 09:58

2 Answers2

13

The most important difference is between @escaping and @noescaping (there is no such keyword in Swift 3!). When a closure is marked as @noescape, you can be sure that the closure won't be retained by the method (e.g. to perform an asynchronous call), therefore you don't have to worry about ownership cycles (there are some other minor benefits).

@escaping closures can be saved or called sometimes in the future therefore you have to be sure to handle ownership (e.g. [weak self]) correctly.

For @autoclosure see How to use Swift @autoclosure . In short, it allows you to skip braces around the closure in some situations.

The default (when not specified) is @noescaping in Swift 3 (see rationale). They keyword does not actually exist anymore. There is only @escaping.

Community
  • 1
  • 1
Sulthan
  • 128,090
  • 22
  • 218
  • 270
  • 1
    Nice answer, it would be better if you will add code example , so other will get better idea for all three keywords. Thanks – technerd Sep 25 '16 at 12:28
6

@escape means that your function can be called after method ends. @noescape means that your closure will be called before the end of function it passed to. @autoclosure means that you can omit writing closure braces, but it automatically becomes @noescape. @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 some function.

2 - Easier for compiler to perform optimisations.

3 - beter to write, to give compiler(or anybody that using your function) information how it behaves with your closure

4 - no

5 - described on the top of the answer

Volodymyr
  • 1,165
  • 5
  • 16