Generische Einschränkungen und where-Klauseln

Zusammenfassung der Generics-Grundlagen

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

Einschränkung auf einen Typ

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

Mehrere Einschränkungen mit &

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

where-Klauseln für Funktionen

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

where bei Erweiterungen

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

Anforderungen an denselben Typ

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) }
}

Bedingte Konformität

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

Generische Klassen mit Einschränkungen

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

Protokoll mit Einschränkungen für zugehörige Typen

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

Mehrere where-Klauseln

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

Spezialisierung generischer Typen

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

Kurztest

Zusammenfassung der Lektion