How to define optional methods in Swift protocol?

1. Using default implementations (preferred).

protocol MyProtocol {    func doSomething()}extension MyProtocol {    func doSomething() {        /* return a default value or just leave empty */    }}struct MyStruct: MyProtocol {    /* no compile error */}

Advantages

• No Objective-C runtime is involved (well, no explicitly at least). This means you can conform structs, enums and non-NSObject classes to it. Also, this means you can take advantage of powerful generics system.

• You can always be sure that all requirements are met when encountering types that conform to such protocol. It's always either concrete implementation or default one. This is how "interfaces" or "contracts" behave in other languages.

Disadvantages

• For non-Void requirements, you need to have a reasonable default value, which is not always possible. However, when you encounter this problem, it means that either such requirement should really have no default implementation, or that your you made a mistake during API design.

• You can't distinguish between a default implementation and no implementation at all, at least without addressing that problem with special return values. Consider the following example:

  protocol SomeParserDelegate {    func validate(value: Any) -> Bool}

  If you provide a default implementation which just returns true — it's fine at the first glance. Now, consider the following pseudo code:

  final class SomeParser {    func parse(data: Data) -> [Any] {        if /* delegate.validate(value:) is not implemented */ {            /* parse very fast without validating */        } else {            /* parse and validate every value */        }    }}

  There's no way to implement such an optimization — you can't know if your delegate implements a method or not.

  Although there's a number of different ways to overcome this problem (using optional closures, different delegate objects for different operations to name a few), that example presents the problem clearly.

2. Using @objc optional.

@objc protocol MyProtocol {    @objc optional func doSomething()}class MyClass: NSObject, MyProtocol {    /* no compile error */}

Advantages

• No default implementation is needed. You just declare an optional method or a variable and you're ready to go.

Disadvantages

• It severely limits your protocol's capabilities by requiring all conforming types to be Objective-C compatible. This means, only classes that inherit from NSObject can conform to such protocol. No structs, no enums, no associated types.

• You must always check if an optional method is implemented by either optionally calling or checking if the conforming type implements it. This might introduce a lot of boilerplate if you're calling optional methods often.

In Swift 2 and onwards it's possible to add default implementations of a protocol. This creates a new way of optional methods in protocols.

protocol MyProtocol {    func doSomethingNonOptionalMethod()    func doSomethingOptionalMethod()}extension MyProtocol {    func doSomethingOptionalMethod(){         // leaving this empty     }}

It's not a really nice way in creating optional protocol methods, but gives you the possibility to use structs in in protocol callbacks.

I wrote a small summary here:https://www.avanderlee.com/swift-2-0/optional-protocol-methods/

Here is a concrete example with the delegation pattern.

Setup your Protocol:

@objc protocol MyProtocol:class{    func requiredMethod()    optional func optionalMethod()}class MyClass: NSObject{    weak var delegate:MyProtocol?    func callDelegate()    {        delegate?.requiredMethod()        delegate?.optionalMethod?()    }}

Set the delegate to a class and implement the Protocol. See that the optional method does not need to be implemented.

class AnotherClass: NSObject, MyProtocol{    init()    {        super.init()        let myInstance = MyClass()        myInstance.delegate = self    }    func requiredMethod()    {    }}

One important thing is that the optional method is optional and needs a "?" when calling. Mention the second question mark.

delegate?.optionalMethod?()