What is the swift equivalent to setting properties on `id`?

Question

I wonder what's the Swift equivalent in calling a method on id in which the availability of the method is determined at runtime. Specifically I'm looking to do this pattern in Swift:

-(IBAction) handleEvent:(id) sender {
    BOOL didDisable = NO;
    if([sender respondsToSelector:@selector(setEnabled:)]) {
        [sender setEnabled:NO];
        didDisable = YES;
    }
    [self doSomethingAsyncWithCompletionHandler:^{
        if(didDisable) {
            [sender setEnabled:YES];
        }
    }];
}

The biggest problem is that setEnabled: is imported in Swift as a property (e.g. UIBarItem) and none of the following constructs compile

func handleEvent(sender: AnyObject) {
    // Error: AnyObject does not have a member named "enabled"
    sender.enabled? = false

    // Error: (BooleanLiteralCompatible) -> _ is not identical to Bool
    sender.setEnabled?(false)
}

Answer 1

You can in fact do it exactly the same way you were doing it before: by calling respondsToSelector:. Indeed, that is exactly what your proposed expression does:

sender.setEnabled?(false)

That expression is actually a shorthand - it calls respondsToSelector: first, and then calls setEnabled: only if the respondsToSelector: test passes. Unfortunately, as you say, you can't get that code to compile. That, however, is merely a quirk of Swift's known repertory of available methods. The fact is that, although it is a little tricky to get it to compile, it can be done - and once you get it to compile, it behaves just as you would expect.

However, I'm not going to explain how to make it compile, because I don't want to encourage this kind of trickery. This sort of dynamic messaging is discouraged in Swift. In general, dynamic messaging tricks such as key-value coding, introspection, and so forth are not needed in Swift and are not consonant with Swift's strong typing approach. It would be better to do things the Swift way, by casting optionally to something that you have reason to believe this thing might be and that has an enabled property. For example:

@IBAction func doButton(sender: AnyObject) {
    switch sender {
    case let c as UIControl: c.enabled = false
    case let b as UIBarItem: b.enabled = false
    default:break
    }
}

Or:

@IBAction func doButton(sender: AnyObject) {
    (sender as? UIControl)?.enabled = false
    (sender as? UIBarItem)?.enabled = false
}