> ## 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 Associated Type An associated type acts as a placeholder name for a type used within a protocol. It defers the specification of the exact concrete type until the protocol is adopted and implemented by a conforming type. This mechanism allows protocols to define generic requirements while maintaining strict compile-time type safety. ## Declaration Syntax Associated types are declared inside a protocol body using the `associatedtype` keyword. They can be used as parameter types, return types, or property types within the protocol's requirements. ```swift theme={"dark"} protocol Container { associatedtype Item mutating func append(_ item: Item) var count: Int { get } subscript(i: Int) -> Item { get } } ``` ## Type Resolution When a concrete type (struct, class, or enum) conforms to a protocol with an associated type, the compiler must resolve the placeholder to a specific concrete type. This occurs in two ways: **1. Explicit Resolution** The conforming type explicitly defines the mapping using a `typealias`. ```swift theme={"dark"} struct IntContainer: Container { typealias Item = Int var items: [Int] = [] mutating func append(_ item: Int) { items.append(item) } var count: Int { items.count } subscript(i: Int) -> Int { items[i] } } ``` **2. Implicit Resolution (Type Inference)** The compiler infers the concrete type based on the signatures of the implemented protocol requirements. If the conforming type implements `append(_ item: String)`, the compiler automatically infers that `Item` is `String`. ```swift theme={"dark"} struct StringContainer: Container { var items: [String] = [] // The compiler infers `Item == String` from this parameter mutating func append(_ item: String) { items.append(item) } var count: Int { items.count } subscript(i: Int) -> String { items[i] } } ``` ## Type Constraints Associated types can be constrained to require that the resolved concrete type conforms to specific protocols or inherits from specific base classes. ```swift theme={"dark"} protocol EquatableContainer { // The resolved type must conform to Equatable associatedtype Item: Equatable func contains(_ item: Item) -> Bool } ``` ## Generic `where` Clauses You can apply complex constraints to associated types using a generic `where` clause. This allows you to enforce relationships between multiple associated types or between an associated type and the conforming type (`Self`). ```swift theme={"dark"} protocol Sequence { associatedtype Element associatedtype Iterator: IteratorProtocol where Iterator.Element == Element func makeIterator() -> Iterator } ``` ## Primary Associated Types (Swift 5.7+) Protocols can declare one or more "primary" associated types by placing them in angle brackets after the protocol name. This syntax enables lightweight generic constraints when using the protocol as an opaque type (`some`) or an existential type (`any`). ```swift theme={"dark"} // 'Element' is declared as the primary associated type protocol Collection { associatedtype Element associatedtype Index } // The primary associated type can now be constrained directly at the usage site func process(items: some Collection) { // ... } ```

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