Budowanie niestandardowych sekwencji leniwych

let view = [1, 2, 3].lazy
let mapped = view.map { $0 * 2 }
print(Array(mapped))  // [2, 4, 6]  -- LazyMapSequence

struct Fibonacci: Sequence, IteratorProtocol {
    var a = 0, b = 1
    mutating func next() -> Int? {
        let r = a
        (a, b) = (b, a + b)
        return r
    }
}
print(Array(Fibonacci().prefix(6)))  // [0, 1, 1, 2, 3, 5]

struct Naturals: Sequence, IteratorProtocol {
    var n = 1
    mutating func next() -> Int? { defer { n += 1 }; return n }
}
print(Array(Naturals().prefix(4)))  // [1, 2, 3, 4]

struct Counter: Sequence, IteratorProtocol, LazySequenceProtocol {
    var n = 0; let limit: Int
    mutating func next() -> Int? {
        guard n < limit else { return nil }
        defer { n += 1 }
        return n
    }
}
print(Array(Counter(n: 0, limit: 3).map { $0 * 10 }))  // [0, 10, 20]

let powers = sequence(first: 1) { $0 <= 16 ? $0 * 2 : nil }
print(Array(powers))  // [1, 2, 4, 8, 16, 32]

let fibs = sequence(state: (0, 1)) { (s: inout (Int, Int)) -> Int? in
    let r = s.0
    s = (s.1, s.0 + s.1)
    return r
}
print(Array(fibs.prefix(6)))  // [0, 1, 1, 2, 3, 5]

func evens(upTo n: Int) -> AnySequence<Int> {
    AnySequence((0...n).lazy.filter { $0 % 2 == 0 })
}
print(Array(evens(upTo: 8)))  // [0, 2, 4, 6, 8]

let stream = (1...5).lazy.map { (n: Int) -> Int in
    print("computing \(n)")
    return n * n
}
print(stream.first!)  // computing 1, then 1

let countdown = sequence(state: 3) { (s: inout Int) -> Int? in
    guard s > 0 else { return nil }
    defer { s -= 1 }
    return s
}
print(Array(countdown))  // [3, 2, 1]

let primesIsh = sequence(first: 2) { $0 < 20 ? $0 + 1 : nil }
    .lazy
    .filter { n in (2..<n).allSatisfy { n % $0 != 0 } }
print(Array(primesIsh))  // [2, 3, 5, 7, 11, 13, 17, 19]