Ograniczenia (where), inferencja typów

Dlaczego ograniczenia?

Ograniczenie Equatable

// Find the first index of value in an array of T
func indexOf<T>(_ value: T, in array: [T]) -> Int? where T: Equatable {
    for (i, x) in array.enumerated() {
        if x == value { return i }        // allowed because T: Equatable
    }
    return nil
}
print(indexOf(3, in: [1,2,3,2]) ?? -1)     // 2
print(indexOf("b", in: ["a","b","c"]) ?? -1)  // 1

Ograniczenie Comparable

// Return the minimum value of a collection when elements are Comparable
func minimum<T: Comparable>(_ xs: [T]) -> T? {
    guard var best = xs.first else { return nil }
    for x in xs.dropFirst() {
        if x < best { best = x }
    }
    return best
}
print(minimum([7,3,9]) ?? -1)    // 3
print(minimum(["b","a","c"]) ?? "?") // "a"

Rozszerzenie z where

// Add a helper only when the array's Element is Equatable
extension Array where Element: Equatable {
    func removingDuplicates() -> [Element] {
        var seen: [Element] = []
        for x in self {
            if !seen.contains(x) { seen.append(x) }
        }
        return seen
    }
}
print([1,2,2,3].removingDuplicates())   // [1,2,3]

Wiele ograniczeń

// Require both Sequence and Equatable elements; force same-type relationship
func allEqual<S>(_ s: S) -> Bool
where S: Sequence, S.Element: Equatable {
    var it = s.makeIterator()
    guard let first = it.next() else { return true }
    while let v = it.next() { if v != first { return false } }
    return true
}
print(allEqual([2,2,2]))   // true
print(allEqual([1,2,1]))   // false

Wnioskowanie w praktyce

// Inference: compiler deduces concrete types
let i = indexOf(10, in: [5,10,15])   // T is Int
let j = minimum(["z","x"])           // T is String
print(i ?? -1, j ?? "")

Znaczenie where

Podsumowanie