> ## 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 Generic Type A generic type in Swift is a custom class, structure, enumeration, or actor declared with one or more type parameters. These type parameters act as placeholders for concrete types that are specified at the time of instantiation, allowing the compiler to enforce strict type safety while maintaining type-agnostic implementations. ## Type Parameters Type parameters are defined inside angle brackets (`< >`) immediately following the type's name. They are conventionally named using UpperCamelCase (e.g., `Element`, `T`, `Key`). Once defined, the type parameter can be used throughout the type's definition to declare properties, method parameters, and return types. ```swift theme={"dark"} struct Container { var items: [Element] mutating func add(_ item: Element) { items.append(item) } } ``` Multiple type parameters are separated by commas: ```swift theme={"dark"} class Pair { let first: T let second: U init(first: T, second: U) { self.first = first self.second = second } } ``` ## Type Constraints By default, a type parameter can accept any concrete type. Type constraints restrict the allowed types by requiring the type parameter to inherit from a specific class or conform to a specific protocol (or protocol composition). Constraints are applied directly in the type parameter list using the `:` syntax. ```swift theme={"dark"} import UIKit // 'Key' is constrained to types conforming to the 'Hashable' protocol struct HashMap { var storage: [Key: Value] = [:] } // 'T' is constrained to inherit from 'UIViewController' class ViewControllerWrapper { let viewController: T init(viewController: T) { self.viewController = viewController } } ``` ## Generic Implementation and Specialization When a generic type is instantiated, concrete types replace the type parameters. Unlike languages that strictly rely on monomorphization (generating distinct code for every type), Swift uses a hybrid approach to balance performance and binary size. By default, Swift compiles a single shared implementation for a generic type. This shared code uses runtime type metadata and value witness tables to dynamically handle operations (like memory allocation, copying, and destruction) for different concrete types, which minimizes code bloat. However, as a compiler optimization, Swift performs generic specialization (monomorphization) when the concrete types are statically knowable and visible to the optimizer. In these cases, the compiler generates highly optimized, distinct machine code for the specific concrete type, eliminating the runtime overhead of dynamic dispatch. ```swift theme={"dark"} // Depending on visibility and optimization levels, the compiler may use the // shared generic implementation or generate specialized machine code for Int and String. var intContainer = Container(items: []) var stringContainer = Container(items: []) ``` ## Extending Generic Types When extending a generic type, you do not provide the type parameter list in the extension declaration. The original type parameters from the type definition are implicitly available within the body of the extension. ```swift theme={"dark"} extension Container { var topItem: Element? { return items.last } } ``` ### Conditional Extensions You can use a generic `where` clause in an extension to add functionality only when the type parameters satisfy specific conditions. This allows a generic type to gain additional methods or properties based on the capabilities of its resolved concrete type. ```swift theme={"dark"} // This method is only available if 'Element' conforms to 'Equatable' extension Container where Element: Equatable { func contains(_ item: Element) -> Bool { return items.contains(item) } } ``` ## Generics in Protocols (Associated Types) While classes, structs, enums, and actors use type parameters (``), Swift protocols handle generics differently to avoid complex type hierarchies. Protocols use `associatedtype` to declare a placeholder name for a type that is used as part of the protocol. The concrete type is determined by the conforming type. ```swift theme={"dark"} protocol DataProvider { associatedtype DataType func fetch() -> DataType } struct StringProvider: DataProvider { // The compiler infers DataType == String based on the return type func fetch() -> String { return "Data" } } ```

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