> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift Protocol A protocol defines a strict blueprint of methods, properties, initializers, and associated types required to implement a specific piece of functionality. It acts as an interface contract that classes, structures, and enumerations can adopt. When a type satisfies all the requirements of a protocol, it is said to conform to that protocol. ## Protocol Declaration and Conformance Protocols are declared using the `protocol` keyword. Types declare conformance by appending the protocol name after the type name, separated by a colon. Multiple protocols are separated by commas. ```swift theme={"dark"} protocol Displayable { // Requirements go here } struct User: Displayable, Equatable { // Implementation goes here } ``` ## Property Requirements Protocols can require conforming types to provide specific instance properties or type properties. * Properties must always be declared as variables (`var`), never constants (`let`). * The protocol specifies whether the property must be gettable (`{ get }`) or both gettable and settable (`{ get set }`). * Type properties are prefixed with the `static` keyword. ```swift theme={"dark"} import Foundation protocol Resource { var id: String { get } var data: Data { get set } static var maxCapacity: Int { get } } ``` ## Method Requirements Protocols can require specific instance methods and type methods. * Method signatures are defined without a body (no curly braces). * Default parameters are not allowed in protocol method declarations. * Type methods are prefixed with `static`. * If a method modifies the instance of a value type (struct or enum), it must be prefixed with the `mutating` keyword. Classes conforming to the protocol ignore the `mutating` keyword. ```swift theme={"dark"} protocol StateMachine { func transition(to state: Int) throws static func reset() mutating func increment() } ``` ## Initializer Requirements Protocols can require specific initializers. When a class conforms to a protocol with an initializer requirement, the implementation must be marked with the `required` modifier to ensure all subclasses also provide the initializer. (Structs do not need the `required` modifier). ```swift theme={"dark"} protocol Deserializable { init(dictionary: [String: Any]) } class Model: Deserializable { required init(dictionary: [String: Any]) { // Implementation } } ``` ## Associated Types Protocols cannot use standard generic type parameters (e.g., ``). Instead, they use associated types to define placeholders for types used within the protocol's requirements. The conforming type determines the actual concrete type. ```swift theme={"dark"} protocol Container { associatedtype Item mutating func append(_ item: Item) var count: Int { get } } struct IntStack: Container { typealias Item = Int // Optional: Swift can usually infer this var count: Int { return 0 // implementation } mutating func append(_ item: Int) { // implementation } } ``` ## Protocol Inheritance A protocol can inherit requirements from one or more other protocols. The syntax mirrors class inheritance. Conforming types must satisfy the requirements of the inherited protocols as well as the new protocol. ```swift theme={"dark"} protocol Persistable: Displayable, Deserializable { func save() } ``` ## Class-Only Protocols To restrict protocol conformance exclusively to reference types (classes), the protocol must inherit from `AnyObject`. This is commonly used to prevent strong reference cycles by allowing protocol-typed properties to be declared as `weak`. ```swift theme={"dark"} protocol Delegate: AnyObject { func didCompleteTask() } ``` ## Protocol Composition You can require a type to conform to multiple protocols simultaneously using the `&` operator. This creates an existential type representing the intersection of the specified protocols. In modern Swift, existential types must be explicitly marked with the `any` keyword (or `some` for opaque types). ```swift theme={"dark"} func process(data: any Displayable & Deserializable) { // data must conform to both protocols } ``` ## Protocol Extensions Protocols can be extended to provide method and property implementations. This allows you to define default behavior for protocol requirements or add new functionality to all conforming types without modifying the conforming types themselves. ```swift theme={"dark"} protocol Loggable { var logMessage: String { get } func printLog() } extension Loggable { // Default implementation func printLog() { print(logMessage) } } ```

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More