Restrições genéricas e cláusulas where

Recapitulação dos fundamentos de genéricos

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

Restrição de um único tipo

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

Várias restrições com &

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

Cláusulas where em funções

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

where em extensões

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

Requisitos de mesmo tipo

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

Conformidade condicional

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

Classes genéricas com restrições

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

Protocolo com restrições de tipos associados

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

Várias cláusulas where

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

Especialização de tipos genéricos

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

Verificação rápida

Recapitulação da lição