Wzorce erasure typów (AnySequence/AnyIterator)

Dlaczego wymazywanie typów?

Ograniczenie

// Goal: return "some Sequence<Int>"
// This won't compile as a stored value type:
// let s: Sequence = [1,2,3]   // Protocol with associated types
// Instead, erase the type to AnySequence<Int>.

Opakowanie AnySequence

// Build an AnySequence<Int> from an Array
let a = [1, 2, 3]
let seq1: AnySequence<Int> = AnySequence(a)
// Consume like any sequence
for x in seq1 { print(x, terminator: " ") }
print("")

Opakowanie AnyIterator

// Create an AnyIterator<Int> by hand
var i = 0
let it = AnyIterator<Int> {
    // Return next number or nil to stop
    guard i < 3 else { return nil }
    defer { i += 1 }
    return i
}
let seq2 = AnySequence(it)
for x in seq2 { print(x, terminator: " ") }  // 0 1 2
print("")

Jednolity typ zwracany

// Return a sequence of Int without exposing concrete type
func numbers(flag: Bool) -> AnySequence<Int> {
    if flag {
        // Array-based
        return AnySequence([10, 20, 30])
    } else {
        // Lazy generated with AnyIterator
        var n = 1
        let it = AnyIterator<Int> {
            guard n <= 3 else { return nil }
            defer { n += 1 }
            return n * 100
        }
        return AnySequence(it)
    }
}

for x in numbers(flag: true)  { print(x, terminator: " ") }  // 10 20 30
print("")
for x in numbers(flag: false) { print(x, terminator: " ") }  // 100 200 300
print("")

Kiedy go używać

Zastosowanie AnySequence

Podsumowanie