TL;DR; Solution can be also found here.

Supposing we’re writing a client-server communication layer, and we want to add support for retrying failed calls for a number of times before giving up and reporting error. A classical example would be updating a user’s profile when pressing a Save button from the UI.

A typical function might look like this:
[swift gutter=”false”]
func updateProfile(firstName: String, lastName: String, success: Any -> Void, failure: NSError -> Void) {
    let urlRequest = NSURLRequest()
    // …
    NSURLSession.sharedSession().dataTaskWithRequest(urlRequest,
        completionHandler: { data, response, error in
            // if we have no error and have received data, we’re OK
            guard error == nil, let data = data else {
                failure(error ?? NSError(domain: "MyDomain", code: 1, userInfo:  nil))
                return
            }
            success(data)
    }).resume()
}
[/swift]
How can we make this retry-able any number of times we need?

Firstly, let’s add a type alias corresponding to a no-parameter async function that we can
pass around:

[swift gutter=”false”]typealias Async = (success: Void -> Void, failure: NSError -> Void) -> Void[/swift]

Next, we need to modify the `updateProfile` function to return an `Async` value, and the `retry` function to make use of that value. This change doesn’t require much effort, it’s just a matter of removing the callbacks from the parameters list and wrapping the function body into a closure:
[swift gutter=”false”]
func updateProfile(firstName: String, lastName: String) -> Async {
return {success, failure in
let urlRequest = NSURLRequest()
// …
NSURLSession.sharedSession().dataTaskWithRequest(urlRequest,
completionHandler: { data, response, error in
// if we have no error and have received data, we’re OK
guard error == nil, let data = data else {
failure(error ?? NSError(domain: "MyDomain", code: 1, userInfo: nil))
return
}
success(data)
}).resume()
}
}
[/swift]
We also need the actual retry function, which could look like this:
[swift gutter=”false”]
func retry(numberOfTimes: Int, task: () -> Async, success: Void -> Void, failure: NSError -> Void) {
task()(success: success, failure: { error in
if numberOfTimes > 1 {
retry(numberOfTimes – 1, task: task, success: success, failure: failure)
} else {
failure(error)
}
})
}
[/swift]

One minor inconvenient is that the retry function expects a closure that takes no arguments and returns an Async, while our updateProfile function takes two arguments. This is not however a big problem, as we can wrap the updateProfile call into a closure:
[swift]
retry(3, task: { updateProfile("firstName", lastName:"lastName") },
success: { data in
print("Succeeded")
},
failure: { err in
print("Failed: \(err)")
}
)
[/swift]
Nice and clean, we can easily configure the number of times to retry, as most of all our existing async functions need very few changes in order to benefit of this retry mechanism.

P.S. If however you don’t want or can’t change existing functions, then you can simply add wrappers for those functions, like in this example for updateProfile:
[swift gutter=”false”]
func updateProfileAsync(firstName: String, lastName: String) -> Async {
return { success, failure in
updateProfile(firstName, lastName: lastName, success: success, failure: failure)
}
}
[/swift]