What does an optional function violate in the…

Adding protocol requirements after it has been used by other modules or libraries. If the protocol is already adopted and implemented, adding non-optional (mandatory) methods or properties will cause compilation errors wherever the protocol is used until these new requirements are fulfilled.

Optional requirements allow protocols to be extended without breaking existing implementations. Classes or structures can implement only some of the optional methods. This is useful when working with delegates or adding new features to an established API.

Example of an optional requirement in an Objective-C protocol (since Swift does not support @optional without @objc):

// In Swift, @optional is used with @objc protocol
import Foundation

@objc protocol MyDelegate {
    func requiredMethod() -> Bool

    @optional func optionalMethod1()
    @optional func optionalMethod2(value: Int)
}

class MyClass {
    weak var delegate: MyDelegate?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Call optional method with check
            delegate?.optionalMethod1?()

            if let delegate = delegate {
                if delegate.responds(to: #selector(delegate.optionalMethod2(value:))) {
                    delegate.optionalMethod2?(value: 10)
                }
            }
        }
    }
}

In Swift, pure protocols (without @objc) do not support @optional. To have optional requirements, the protocol must be marked as @objc. Implementations of such protocols can use extensions to add default implementations of optional methods, which is a more modern approach in Swift.

Example of optional behavior via protocol extensions in Swift:

// More Swift-like approach: protocol extensions with default implementations
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Provide default implementations for "optional" methods
extension MyProtocol {
    func optionalMethod1() {
        // Default empty implementation or some standard behavior
        print("Default implementation of optional method 1")
    }

    func optionalMethod2(value: Int) {
        // Default empty implementation
        print("Default implementation of optional method 2 with value: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Call methods without nil check for optionalMethod, as they
            // are either implemented in class/struct or default via extension
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Required method implemented")
        return true
    }

    // optionalMethod1() and optionalMethod2(value:) are not mandatory to implement,
    // default implementation from extension will be used.
    // But they can be overridden if different behavior is needed:
    // func optionalMethod1() {
    //     print("Custom implementation of optional method 1")
    // }
}

let customDelegate = MyCustomDelegate()
let myClassSwift = MyClassSwift()
myClassSwift.delegate = customDelegate
myClassSwift.doSomething()

Thus, adding a new mandatory requirement to an existing protocol that is already in use in code breaks backward compatibility. Using optional requirements (via @objc or protocol extensions) prevents this issue.

What does an optional function violate in the protocol?