제네릭 제약 조건과 where 절

제네릭 기초 복습

func identity<T>(_ value: T) -> T { return value }
print(identity(42))
print(identity("hello"))

단일 타입 제약

func largest<T: Comparable>(_ a: T, _ b: T) -> T {
  return a > b ? a : b
}
print(largest(3, 7))

&를 사용한 다중 제약

func process<T: Equatable & Hashable>(_ items: [T]) -> Set<T> {
  return Set(items)
}
print(process([1,2,2,3]))

함수의 where 절

func allEqual<T: Equatable>(_ array: [T]) -> Bool where T: CustomStringConvertible {
  guard let first = array.first else { return true }
  return array.allSatisfy { $0 == first }
}

확장의 where

extension Array where Element: Numeric {
  var sum: Element { reduce(0, +) }
}
print([1,2,3].sum)

동일 타입 요구 사항

func zip2<A: Sequence, B: Sequence>(_ a: A, _ b: B) -> [(A.Element, B.Element)]
  where A.Element == B.Element {
  return Swift.zip(a, b).map { ($0.0, $0.1) }
}

조건부 준수

extension Array: Equatable where Element: Equatable {
  // stdlib already does this, shown for illustration
}
print([1,2] == [1,2])

제약 조건이 있는 제네릭 클래스

class Box<T: Codable> {
  var value: T
  init(_ v: T) { self.value = v }
}
let box = Box(42)

연관 타입 제약 조건이 있는 프로토콜

protocol Container {
  associatedtype Item: Equatable
  var items: [Item] { get }
  func contains(_ item: Item) -> Bool
}

여러 where 절

func merge<C: Collection>(_ a: C, _ b: C) -> [C.Element]
  where C.Element: Comparable, C.Element: Hashable {
  return Array(Set(a + b)).sorted()
}

제네릭 타입 특수화

// @_specialize instructs the compiler to emit a specialized version
@_specialize(where T == Int)
func add<T: Numeric>(_ a: T, _ b: T) -> T { a + b }

빠른 확인

강의 복습