Conditional conformances
Make a generic type conform to a protocol only if its type parameter meets constraints (e.g., Box<T>: Equatable where T: Equatable ).
Conditional conformances is a free Swift Academy lesson on CoddyKit — lesson 1 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Why conditional conformance?
Conditional conformance adds a protocol conformance only when type parameters meet constraints. This keeps APIs precise, avoids boilerplate, and composes powerfully with the standard library.
Generic type baseline
Start with a generic type. Without extra work, Box does not conform to Equatable/Hashable even if T does.
struct Box<T> {
var value: T
}
let bi = Box(value: 3)
let bs = Box(value: "hi")
// At this point Box has no Equatable/Hashable, regardless of T.Equatable conditionally
Add Equatable only if T: Equatable. Code that compares boxes of non-Equatable types will not compile (good safety).
extension Box: Equatable where T: Equatable {
static func == (lhs: Box<T>, rhs: Box<T>) -> Bool {
lhs.value == rhs.value
}
}
print(Box(value: 5) == Box(value: 5)) // true
// Works because Int is Equatable
// print(Box(value: someNonEquatable) == ...) // won't compileHashable conditionally
Similarly, adopt Hashable only when the element is Hashable. Then Set/Dictionary work with Box<T>.
extension Box: Hashable where T: Hashable {
func hash(into hasher: inout Hasher) {
hasher.combine(value)
}
}
let set: Set<Box<Int>> = [Box(value: 1), Box(value: 1)]
print(set.count) // 1 because Hashable is available only when T: HashableFeature-gate with where
Use extension ... where to expose methods only for certain capabilities (e.g., T: Numeric), keeping the base API small.
// Add extra APIs only when T supports them
extension Box where T: Numeric {
func doubled() -> T { value + value }
}
print(Box(value: 7).doubled()) // 14 (Int is Numeric)
// Box(value: "hi").doubled() // won't compile — String not NumericSeen in the standard library
You already use this daily:
- Array: Equatable only when
Element: Equatable. - Dictionary/Set hashing only when keys/elements are
Hashable. - Optional equality only when
Wrapped: Equatable.
Benefit: APIs are accurate and compile-time safe.
Definition check
Quick check: What does conditional conformance allow?
Recap
Recap: Use extension Type: Protocol where ... to add conformances and APIs only when constraints hold. This keeps code precise, safe, and easy to reason about.
Frequently asked questions
Is the “Conditional conformances” lesson free?
Yes — the full text of “Conditional conformances” is free to read here on the web, and the Swift Academy course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.
What will I learn in “Conditional conformances”?
Make a generic type conform to a protocol only if its type parameter meets constraints (e.g., Box<T>: Equatable where T: Equatable ). You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Swift Academy?
No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 3, so you can start here or from the beginning and move at your own pace.
How long does the “Conditional conformances” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Swift Academy lesson?
Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Conditional conformances
- Recursive constraints & higher-order generics
- where clauses on extensions