Lescai Ionel
Lescai Ionel

Reputation: 4383

Swift optional escaping closure parameter

Given:

typealias Action = () -> ()

var action: Action = { }

func doStuff(stuff: String, completion: @escaping Action) {
    print(stuff)
    action = completion
    completion()
}

func doStuffAgain() {
    print("again")
    action()
}

doStuff(stuff: "do stuff") { 
    print("swift 3!")
}

doStuffAgain()

Is there any way to make the completion parameter (and action) of type Action? and also keep @escaping ?

Changing the type gives the following error:

@escaping attribute only applies to function types

Removing the @escaping attribute, the code compiles and runs, but doesn't seem to be correct since the completion closure is escaping the scope of the function.

Upvotes: 184

Views: 89802

Answers (6)

Eldar
Eldar

Reputation: 554

Optional closure is a value of type optional, not of type closure, which stores as an associative closure value in .some(Wrapped). And closure is a reference type, so optional closures default @escaping.

Upvotes: 0

Freeman Man
Freeman Man

Reputation: 401

I ran into a similar problem because mixing @escaping and non-@escaping is very confusing, especially if you need to pass the closures around.

I ended up assigning a no-op default value to the closure parameter via = { _ in }, which I think makes more sense:

func doStuff(stuff: String = "do stuff",
        completion: @escaping (_ some: String) -> Void = { _ in }) {
     completion(stuff)
}

doStuff(stuff: "bla") {
    stuff in
    print(stuff)
}

doStuff() {
    stuff in
    print(stuff)
}

Upvotes: 26

matt
matt

Reputation: 536028

The important thing to understand in the example is that if you change Action to Action? the closure is escaping. So, let's do what you propose:

typealias Action = () -> ()

var action: Action? = { }

func doStuff(stuff: String, completion: Action?) {
    print(stuff)
    action = completion
    completion?()
}

Okay, now we'll call doStuff:

class ViewController: UIViewController {
    var prop = ""
    override func viewDidLoad() {
        super.viewDidLoad()
        doStuff(stuff: "do stuff") {
            print("swift 3!")
            print(prop) // error: Reference to property 'prop' in closure 
                        // requires explicit 'self.' to make capture semantics explicit
        }
    }
}

Well, that requirement only arises for escaping closures. So the closure is escaping. That's why you don't mark it escaping - it's escaping already.

Upvotes: 5

Jans
Jans

Reputation: 11250

There is a SR-2552 reporting that @escaping is not recognizing function type alias. that's why the error @escaping attribute only applies to function types. you can workaround by expanding the function type in the function signature:

typealias Action = () -> ()

var action: Action? = { }

func doStuff(stuff: String, completion: (@escaping ()->())?) {
    print(stuff)
    action = completion
    completion?()
}

func doStuffAgain() {
    print("again")
    action?()
}

doStuff(stuff: "do stuff") {
    print("swift 3!")
}

doStuffAgain()

EDIT 1::

I was actually under a xcode 8 beta version where the bug SR-2552 was not resolved yet. fixing that bug, introduced a new one(the one you're facing) that is still open. see SR-2444.

The workaround @Michael Ilseman pointed as a temporary solution is remove the @escaping attribute from optional function type, that keep the function as escaping.

func doStuff(stuff: String, completion: Action?) {...}

EDIT 2::

The SR-2444 has been closed stating explicitly that closures in parameters positions are not escaping and need them to be marked with @escaping to make them escaping, but the optional parameters are implicitly escaping, since ((Int)->())? is a synonyms of Optional<(Int)->()>, optional closures are escaping.

Upvotes: 136

Igor
Igor

Reputation: 12303

I got it working in Swift 3 without any warnings only this way:

func doStuff(stuff: String, completion: (()->())? ) {
    print(stuff)
    action = completion
    completion?()
}

Upvotes: 18

Dmitrii Cooler
Dmitrii Cooler

Reputation: 4132

from: swift-users mailing list

Basically, @escaping is valid only on closures in function parameter position. The noescape-by-default rule only applies to these closures at function parameter position, otherwise they are escaping. Aggregates, such as enums with associated values (e.g. Optional), tuples, structs, etc., if they have closures, follow the default rules for closures that are not at function parameter position, i.e. they are escaping.

So optional function parameter is @escaping by default.
@noeascape only apply to function parameter by default.

Upvotes: 261

Related Questions