Swift: setting an optional property of a protocol

Question

How does one set an optional property of a protocol? For example UITextInputTraits has a number of optional read/write properties. When I try the following I get a compile error (Cannot assign to 'keyboardType' in 'textInputTraits'):

func initializeTextInputTraits(textInputTraits: UITextInputTraits) {
  textInputTraits.keyboardType = .Default
}

Normally when accessing an optional property of a protocol you add a question mark but this doesn't work when assigning a value (error: Cannot assign to the result of this expression):

textInputTraits.keyboardType? = .Default

The protocol looks like:

protocol UITextInputTraits : NSObjectProtocol {
  optional var keyboardType: UIKeyboardType { get set }
}

score 9 · Accepted Answer · answered Sep 28 '14 at 09:52

9

It's impossible in Swift (yet?). Referenced from an ADF thread:

Optional property requirements, and optional method requirements that return a value, will always return an optional value of the appropriate type when they are accessed or called, to reflect the fact that the optional requirement may not have been implemented.

So it's no surprise to get optional values easily. However, setting a property requires implementation to be guaranteed.

answered Sep 28 '14 at 09:52

akashivskyy

44,342
16
106
116

Still impossible as of Swift 2.2 – adib Jun 18 '16 at 08:51
Still impossible as of Swift 4 – Maxim Kholyavkin Nov 01 '17 at 01:13
Still impossible as of Swift 5.3.2 – Eugene Dudnyk Jan 16 '21 at 15:42

score 7 · Answer 2 · edited Jun 05 '19 at 08:16

I'd consider making an extension returning your default value for keyboardType, and having the setter do nothing.

extension UITextInputTraits {
   var keyboardType: UIKeyboardType { 
      get { return .default }
      set { /* do nothing */ } 
   }
}

That way you can remove the optional from your property declaration.

protocol UITextInputTraits : NSObjectProtocol {
  var keyboardType: UIKeyboardType { get set }
}

Or, if you prefer, you can make it of optional return type, var keyboardType: UIKeyboardType?, and return nil instead of .Default in your extension.

This way, you can test for myObject.keyboardType == nil to see if your property is implemented.

score 3 · Answer 3 · edited May 23 '17 at 10:29

One workaround is to create another protocol that conforms to the first one, but that declare that optional property as mandatory. Then to try to cast the object as that new protocol, and if the cast succeed, we can access the property directly.

protocol UITextInputTraitsWithKeyboardType : UITextInputTraits {
  // redeclare the keyboardType property of the parent protocol, but this time as mandatory
  var keyboardType: UIKeyboardType { get set }
}

func initializeTextInputTraits(textInputTraits: UITextInputTraits) {
  // We try to cast ('as?') to the UITextInputTraitsWithKeyboardType protocol
  if let traitsWithKBType = textInputTraits as? UITextInputTraitsWithKeyboardType {
    // if the cast succeeded, that means that the keyboardType property is implemented
    // so we can access it on the casted variable
    traitsWithKBType.keyboardType = .Default
  } 
  // (and if the cast failed, this means that the property is not implemented)
}

I also demonstrated that at the bottom on this SO answer if you want another example of the idea.

I tried this with Swift 2.2, but the as? is not taking - I seem to recall that protocols are actually evaluated by their name. If the core object hasn't implemented "UITextInputTraitsWithKeyboardType" then its not going to pass. Wondering how you got this to work... — David H, Jun 10 '16 at 22:11

score -1 · Answer 4 · answered Apr 21 '16 at 14:33

The following is what I came up with for Swift 2.2 compatibility:

@objc protocol ComponentViewProtocol: class {
    optional var componentModel: ComponentModelProtocol? { get set }
    optional var componentModels: [String:ComponentModelProtocol]? { get set }
}

class ComponentView: NSObject, ComponentViewProtocol {
    var componentModel: ComponentModelProtocol?
    ...
    ..
    .
}

class SomeCodeThatUsesThisStuff {

    func aMethod() {
        if var componentModel = componentView.componentModel {
            componentModel = .... (this succeeds - you can make assignment)
        } else if var componentModels = componentView.componentModels {
            componentModels = .... (this failed - no assignment possible)
        }
    }
}

In essence you need to perform an "if/let binding" on the optional property to ensure it actually is implemented? If it's nil then the encapsulating object didn't implement it, but otherwise you can now make assignments to it and the compiler will no longer complain.

This just changes a local variable you made - its doesn't change the objects value. — David H, Jun 10 '16 at 22:05

Swift: setting an optional property of a protocol

4 Answers4

Linked

Related