Swift Extension

extension ExistingType {
    // New functionality declarations
}

extension ExistingType: SomeProtocol, AnotherProtocol {
    // Protocol requirement implementations
}

​

Capabilities

• Properties: Computed instance properties, computed type properties, and stored type properties.
• Methods: Both instance and type methods. For value types (structures and enumerations), instance methods that modify self or its properties must be explicitly marked with the mutating keyword.
• Initializers: Custom initializers. For value types, defining an initializer inside an extension allows the type to retain access to its compiler-generated default and memberwise initializers.
• Subscripts: New subscript definitions for accessing elements.
• Nested Types: New classes, structures, enumerations, or typealiases scoped within the extended type.
• Protocol Conformance: Declaring that an existing type satisfies a protocol’s requirements.

​

Limitations

• No Stored Instance Properties: Extensions cannot alter the memory layout of an existing instance. Therefore, they cannot add stored instance properties. They are restricted to computed instance properties and stored type properties (e.g., static let or static var).
• No Property Observers: Extensions cannot add willSet or didSet observers to properties declared in the original type implementation.
• No Overriding: Extensions cannot override existing methods, properties, or initializers.
• Class Initialization Restrictions: Extensions cannot add designated initializers or deinitializers to a class. They may only add convenience initializers.

​

Conditional Extensions

extension Array where Element: Equatable {
    // Members are only available when the Array's elements conform to Equatable
    func customEqualityCheck(against other: [Element]) -> Bool {
        return self == other
    }
}

​

Syntax Mechanics

extension Double {
    // Computed instance property
    var doubledValue: Double {
        return self * 2.0
    }
    
    // Stored type property
    static let defaultTolerance: Double = 0.001
}

struct StateContainer {
    var count: Int
}

extension StateContainer {
    mutating func increment() {
        self.count += 1
    }
}

class Entity {
    var id: String
    
    // Designated initializer
    init(id: String) { 
        self.id = id
    }
}

extension Entity {
    // Must be a convenience initializer and must delegate to a designated initializer
    convenience init() {
        self.init(id: "default_identifier")
    }
}

protocol Describable {
    var description: String { get }
}

extension Describable {
    // Default implementation provided to all conforming types
    func printDescription() {
        print(self.description)
    }
}