Type Constraints

func findLargest<T: Comparable>(_ items: [T]) -> T? {
    guard var largest = items.first else { return nil }
    for item in items where item > largest {
        largest = item
    }
    return largest
}
print(findLargest([3, 7, 2, 9, 4]) as Any)
print(findLargest(["banana", "apple", "cherry"]) as Any)

protocol Summable {
    static func + (lhs: Self, rhs: Self) -> Self
    static var zero: Self { get }
}
extension Int: Summable {
    static var zero: Int { 0 }
}
func total<T: Summable>(_ items: [T]) -> T {
    var result = T.zero
    for item in items {
        result = result + item
    }
    return result
}
print(total([1, 2, 3, 4]))

1. Writing a generic function that uses < or == on its placeholder type without constraining it to Comparable or Equatable first -- the compiler will reject unconstrained comparisons.
2. Confusing a class-inheritance constraint (T: SomeClass) with a protocol constraint (T: SomeProtocol); both use the same colon syntax but mean different things.
3. Over-constraining a generic function with requirements it doesn't actually need, unnecessarily limiting what types can be used.

• A constraint restricts a generic placeholder to types conforming to a protocol or inheriting a class.
• Constraints are written after the placeholder name with a colon, like <T: Comparable>.
• Constraints let you use operations (like < or ==) that aren't available on every possible type.
• Multiple constraints can be combined using & or a where clause.