> ## 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 Conditional Extension A conditional extension in Swift allows you to add methods, computed properties, subscripts, or protocol conformances to a generic type or a protocol only when its generic parameters, associated types, or `Self` satisfy specific type constraints. This is achieved by appending a generic `where` clause to the `extension` declaration, ensuring the extended functionality is strictly bound to the type safety rules evaluated at compile time. ## Syntax The syntax requires the `extension` keyword, the generic type or protocol name, the `where` keyword, and one or more comma-separated constraints using either the conformance/inheritance operator (`:`) or the same-type operator (`==`). ```swift theme={"dark"} // Conformance or inheritance constraint extension GenericTypeOrProtocol where TypeParameter : Constraint { // Declarations } // Same-type constraint extension GenericTypeOrProtocol where TypeParameter == ConcreteType { // Declarations } ``` ## Constraint Types Conditional extensions rely on three primary types of constraints within the `where` clause: **1. Protocol Conformance Requirement** Restricts the extension to instances where the generic type parameter conforms to a specific protocol. ```swift theme={"dark"} extension Array where Element: Numeric { func sum() -> Element { return self.reduce(0, +) } } ``` **2. Same-Type Requirement** Restricts the extension to instances where the generic type parameter is exactly equal to a specific concrete type. ```swift theme={"dark"} extension Optional where Wrapped == String { var isBlank: Bool { return self?.isEmpty ?? true } } ``` **3. Superclass Requirement** Restricts the extension to instances where the generic type parameter inherits from a specific class. ```swift theme={"dark"} class BaseNode {} struct Tree { var root: Node } extension Tree where Node: BaseNode { func validateNode() -> Bool { return true } } ``` ## Protocol Extensions Conditional extensions are heavily utilized with protocols to provide default implementations or additional APIs based on the characteristics of the conforming type (`Self`) or its associated types. **Constraining an Associated Type:** ```swift theme={"dark"} protocol ContainerProtocol { associatedtype Item var items: [Item] { get } } extension ContainerProtocol where Item: Equatable { func containsItem(_ item: Item) -> Bool { return items.contains(item) } } ``` **Constraining `Self`:** ```swift theme={"dark"} extension ContainerProtocol where Self: Collection { var isContainerEmpty: Bool { return self.isEmpty } } ``` ## Conditional Protocol Conformance A generic type can be made to conform to a protocol conditionally. The type itself will only satisfy the protocol requirements if its underlying generic parameters meet the specified constraints. ```swift theme={"dark"} struct Box { var value: T } // Box only conforms to Equatable if T conforms to Equatable extension Box: Equatable where T: Equatable { static func == (lhs: Box, rhs: Box) -> Bool { return lhs.value == rhs.value } } ``` ## Method Dispatch and Overlapping Constraints When multiple conditional extensions apply to a type and define methods with identical signatures, Swift's compiler resolves method dispatch by selecting the extension with the most specific constraints. ```swift theme={"dark"} struct Container { var items: [T] } // General constraint extension Container where T: Equatable { func process() -> String { return "Processed Equatable" } } // More specific constraint extension Container where T == Int { func process() -> String { return "Processed Int" } } // If T is Int, the compiler statically dispatches to the (T == Int) implementation. ``` ## Technical Limitations * **Non-Generic Types:** You cannot apply a `where` clause to an extension of a non-generic concrete type. * **Stored Properties:** Like all Swift extensions, conditional extensions cannot add stored properties to a type; they are limited to computed properties, methods, and subscripts. * **Constraint Visibility:** The constraints defined in the `where` clause must be visible and resolvable at compile time. Dynamic type checking (`is` or `as?`) cannot be used to satisfy a conditional extension at runtime.

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