Rekursive Constraints und Generics höherer Ordnung

Was und warum

Verschachtelte Sequenzen abflachen

// Works for any Collection whose elements are Sequences
func flatten<C: Collection>(_ c: C) -> [C.Element.Element]
where C.Element: Sequence {
    var result: [C.Element.Element] = []
    result.reserveCapacity(c.reduce(0) { $0 + ($1 as AnySequence<C.Element.Element>).underestimatedCount })
    for inner in c {
        for e in inner { result.append(e) }
    }
    return result
}
let nested = [[1,2], [3], [4,5]]
print(flatten(nested))  // [1,2,3,4,5]

Verschachtelt generisch abbilden

// Map over a two-level structure without fixing concrete types
func mapNested<C: Collection, R>(_ c: C, _ transform: (C.Element.Element) -> R) -> [[R]]
where C.Element: Collection {
    return c.map { inner in inner.map(transform) }
}
let doubled = mapNested([[1,2],[3]], { $0 * 2 })
print(doubled) // [[2,4],[6]]

compose(f,g)

// Compose two generic transforms that work on the same element type
func compose<A, B, C>(
    _ f: @escaping (B) -> C,
    _ g: @escaping (A) -> B
) -> (A) -> C {
    { a in f(g(a)) }
}
let toString: (Int) -> String = { "\\($0)" }
let length: (String) -> Int = { $0.count }
let intToLen = compose(length, toString)
print(intToLen(1234))  // 4

Generische Closure-Parameter

// A generic "transform each" that accepts ANY transform (generic in T/U)
func transformEach<T, U, C: Collection>(_ c: C, using f: (T) -> U) -> [U]
where C.Element == T {
    var out: [U] = []
    out.reserveCapacity(c.count)
    for x in c { out.append(f(x)) }
    return out
}
let words = ["swift","kit"]
print(transformEach(words, using: { $0.uppercased() })) // ["SWIFT","KIT"]

Richtlinien

Definition von Higher-Order-Generics

Zusammenfassung