swift 3 中的@escaping 闭包函数

Question

Error with this below function Closure use of non-escaping parameter 'completion' may allow it to escape

func retrieveCannedRecommendedEntities() -> Future<CannedRecommendedEntities, NSError> {
  return Future() { completion in
    self.retrieve(.onboarding) { response in
      switch response {
      case .success(let val):
        let payload: AnyObject = val.value.json! as AnyObject
        let json = JSON(payload)

        guard let suggestions = self.parseEntitiesFromJSON(json, atKey: "suggestion") else {
          completion(SqorResult.error(self.parsingError))
        }

        let teams = suggestions.filter {
          $0.entityType != .Player
        }

        let athletes = suggestions.filter {
          $0.entityType == .Player
        }

        completion(SqorResult.success(Box((teams, athletes))))

      case .error(let error):
        completion(SqorResult.error(error))
      }
    }
  }
}

Answer 1

A closure is said to escape a function when the closure is passed as an argument to the function, but is called after the function returns.

If you use for closure asynchrony, mean the closure may be called after the function execution, you need to add @escaping .

Even if you have no error compilation, you might have run time error, because the closure memory can be released.

@escaping assure you to prevent your closure.

Answer 2

The compiler error means that the parameter completion in function Future - which is a closure - is specified as "non-escaping" (this is the default). This means, that the closure completion must be executed before function Future returns.

However, the implementation indicates that completion may "escape" the function Future - which means, that completion may be executed after function Future returns.

In order to fix this programmer error, you need to ensure that the closure completion will be executed before function Future returns, or you need to add the modifier @escaping to the parameter completion .

See also Escaping Closures

Note, that both solutions may have implications, because they either need a change of the API of a function possibly defined in an existing library (eg "Future") or it is incompatible with your use-case, since you call completion in another - possibly escaping - closure which is set as a parameter in self.retrieve .

However, the notion "completion" in the context of a "Future" clearly dictates, that completion should be "escaping". So, adding @escaping to the function signature of Future seems to be to way to go.