skip to content

Associated Types and Self

Associated types make a protocol generic over a type each conformer picks, and primary associated types allow some Collection<Int>. Interviewers ask why such protocols were hard to use as types.

on this pageshow

explore

questions

5

In Swift, how does a type conforming to a protocol with an `associatedtype` choose the concrete type, and when must it write a typealias?

level: middleimportance: must knowfreq 60%

answer

  1. a placeholder each conformer fills
  2. read from the witnesses' signatures
  3. a nested type with that name
  4. nothing mentions it, nothing to infer

basics

~20 s

An associatedtype is a placeholder each conformer fills. Swift usually infers it from the witnesses, such as save(_ entity: User); write typealias Entity = User when no requirement mentions it, when inference is ambiguous, or to make the choice explicit.

solid answer

~40 s

`associatedtype Entity` in a `Repository` protocol names a type the protocol uses without fixing it; each conformer supplies its own. Usually the compiler **infers** it: if `UserRepository` implements `func find(id: Int) -> User?` and `mutating func save(_ entity: User)`, it matches those witnesses against the requirements and concludes `Entity == User`. You can also satisfy it explicitly with `typealias Entity = User`, a nested type named `Entity`, or a generic parameter named `Entity`, and the protocol may give a default with `associatedtype Entity = User`. You must be explicit when nothing can be inferred, because no requirement mentions the associated type (the error says the protocol "requires nested type 'Entity'"), or when two witnesses suggest different types, which the compiler reports as ambiguous inference.

code

swift · 27 lines
swift
struct User { let id: Int; var name: String }

protocol Repository {
    associatedtype Entity
    func find(id: Int) -> Entity?
    mutating func save(_ entity: Entity)
}

// No typealias: Entity is inferred as User from find(id:) and save(_:).
struct UserRepository: Repository {
    private var storage: [Int: User] = [:]
    func find(id: Int) -> User? { storage[id] }
    mutating func save(_ entity: User) { storage[entity.id] = entity }
}

protocol AuditTrail {
    associatedtype Entity
    var count: Int { get }
}

// No requirement mentions Entity, so there is nothing to infer from: pin it.
struct LoginAudit: AuditTrail {
    typealias Entity = String
    var count: Int { 0 }
}

print(UserRepository.Entity.self, LoginAudit.Entity.self)   // Prints "User String"

go deeper

for a junior

Recall that an associatedtype is a placeholder each conforming type fills in, and that writing typealias Entity = User is one way to fill it.

for a middle

Explain how the compiler infers the associated type from witness signatures, the other ways to satisfy it, and which situations force an explicit typealias.

for a senior

Read the inference diagnostics fluently, and argue when an explicit typealias protects a conformance from silently changing type after a signature edit.

for a principal

Decide where a codebase should require explicit typealiases in shared protocol conformances, trading brevity against reviewability and accidental type changes.

## What an associated type is An **associated type** is a named placeholder inside a protocol, declared with the `associatedtype` keyword. It lets a protocol describe an API in terms of "some type each conformer chooses" without making the protocol itself generic: ```swift protocol Repository { associatedtype Entity func find(id: Int) -> Entity? mutating func save(_ entity: Entity) } ``` A repository of users stores `User` values; a repository of orders stores `Order` values. The protocol fixes the *shape* (find and save the same kind of value) and leaves the *type* to each conformer. The reference manual describes associated types as similar to type parameters in a generic parameter clause, but associated with `Self`: each conforming type supplies exactly one concrete type for each associated type. That last point matters. A conformer picks **one** `Entity`, once, for the whole conformance. It cannot store `User` in one method and `Order` in another, and two different conformers are free to pick different types. ## The four ways a conformer fills it 1. **Inference from witnesses.** The compiler matches each requirement against the conformer's members and reads the associated type off their signatures. `func find(id: Int) -> User?` against `func find(id: Int) -> Entity?` gives `Entity == User`. This is how many conformances work, and The Swift Programming Language points out that deleting an explicit typealias in such a type changes nothing. 2. **A typealias.** `typealias Entity = User` inside the conformer states the choice outright. 3. **A nested type.** A conformer that declares `struct Entity { ... }` inside itself has satisfied the requirement with that type. 4. **A generic parameter.** `struct InMemoryRepository<Entity>: Repository` satisfies the requirement with its own type parameter named `Entity`. The protocol may also supply a **default**: `associatedtype Entity = User` is used when the conformer neither declares nor implies anything else. ## When inference fails Inference needs something to read. These cases end in a compile error, never in a silent fallback to `Any`: | Situation | What the Swift 6.4 compiler says | |---|---| | No requirement mentions `Entity` and there is no default | "type 'LoginAudit' does not conform to protocol 'AuditTrail'", with the note "protocol requires nested type 'Entity'" | | Two witnesses imply different types | the note "ambiguous inference of associated type 'Entity': 'Int' vs. 'String'" | | The inferred type breaks a constraint on `Entity` | the note "candidate would match and infer 'Entity' = 'Note' if 'Note' conformed to 'Identifiable'" | The first row is the classic reason to write a typealias: a protocol whose associated type is used only by extensions, or by requirements the conformer satisfies through defaults, gives inference nothing to work with. ## Choosing between inference and an explicit typealias Inference keeps conformances short, but it has costs worth knowing: - An explicit `typealias` documents the choice at the top of the type, where a reviewer sees it before reading every method. - It usually makes a "does not conform" error easier to read, because the compiler checks each witness against a known type instead of reporting what it could not infer. - It protects against accidental changes: if someone edits the signature of the one method that drove inference, the inferred type can change silently, while a typealias makes the mismatch a compile error. - It satisfies a requirement that no witness mentions, which inference can never do. A common team habit is to rely on inference for small conformances and write the typealias whenever the associated type is not obvious from a single glance. ## How the choice is used Once chosen, the associated type is a real member type of the conformer. `UserRepository.Entity` is `User` and can be written anywhere a type is expected. Code written against the protocol refers to it as `Entity` inside the protocol and its extensions, or as `R.Entity` for a generic parameter `R`. Constraints declared on the associated type, such as `associatedtype Entity: Identifiable`, are checked against whatever the conformer picked, which is covered in the material on constraining associated types. In an interview, the strongest short answer names all three parts: the conformer chooses, the compiler usually infers from witness signatures, and a typealias is needed exactly when there is nothing, or too much, to infer from. Mentioning that the choice is per conformance, not per call, shows you understand why two repositories in one codebase can store different entities while sharing every algorithm written against the protocol.

  • What happens if a Swift conformer has two overloads that would infer different associated types?
    Conformance fails. With `func all() -> [Int]` and `func all() -> [String]` both matching `func all() -> [Entity]`, the compiler reports that the type does not conform and adds the note "ambiguous inference of associated type 'Entity': 'Int' vs. 'String'". A `typealias Entity = Int` resolves it, and the other overload stays an ordinary method.
  • Can a Swift protocol give an associated type a default, and how does a conformer override it?
    Yes: `associatedtype Entity = User`. A conformer that implies nothing gets `User`; one that declares `typealias Entity = String`, a nested `struct Entity`, or witnesses that infer another type replaces the default. Standard-library protocols use this, for example `Collection`'s `SubSequence` defaults to `Slice<Self>`.
  • Can a generic struct's type parameter satisfy an associated type of the same name?
    Yes. `struct InMemoryRepository<Entity>: Repository` satisfies `associatedtype Entity` with its own generic parameter, so each specialization, such as `InMemoryRepository<User>`, has its own `Entity`. Witnesses typed in terms of that parameter then agree with it automatically.

  • Every conformer must declare a typealias for each associated type.
  • The protocol, not the conformer, decides what the associated type is.
  • One conformer can use a different associated type in each method.
  • When inference fails, Swift quietly falls back to Any for the associated type.
  • Two types conforming to one protocol must pick the same associated type.
open as a page

Before Swift 5.7, why could a protocol with an `associatedtype` or `Self` requirement be used only as a generic constraint, and what is still restricted today?

level: seniorimportance: must knowfreq 55%

basics

~20 s

A protocol-typed value hides its concrete type, so Swift cannot know what Entity or Self means there. Before 5.7 such protocols were rejected as types; now any Repository compiles, but members taking Entity or Self as parameters stay unusable.

open as a page

In a Swift protocol, what does capital `Self` mean in a requirement such as `func copy() -> Self`?

level: juniorimportance: should knowfreq 45%

basics

~20 s

In a protocol, Self stands for the eventual conforming type: func copy() -> Self obliges a struct Draft to return a Draft, not just any conforming value. Lowercase self is the instance; a non-final class must write the return type as Self.

open as a page

In a Swift protocol, how do you constrain an `associatedtype` with a protocol or a `where` clause, and what does that constraint buy?

level: middleimportance: should knowfreq 35%

basics

~20 s

Write a conformance after the name (associatedtype Entity: Identifiable) or a where clause relating it to another (where Batch.Element == Entity). Every conformer's choice is checked against it, and code written against the protocol may then use those guarantees.

open as a page

What does declaring a primary associated type, as in Swift's `protocol Repository<Entity>`, let callers write that a plain `associatedtype` does not?

level: seniorimportance: should knowfreq 30%

basics

~20 s

It lets the protocol take type arguments: Repository<User> means conforms to Repository with Entity == User. The shorthand works in generic constraints and extensions, and it is the only way to constrain Entity on some or any types.

open as a page