Generators functions allow you to declare a function that can receive multiple inputs, and produce just in time the output. Because the generation of values is performed lazily, we don’t need to allocate a large number of resources to build up complex sequences in advance.

For instance, let’s say we want to produce the Fibonacci sequence, up to the 50th element. We know that’s expensive, and we might want to introduce memoization. That would certainly be a smart move if we need to compute the sequence more than once.

var fibCache: [Int: Int] = [:]

func fibonacci(_ number: Int) -> Int {
    if let fib = fibCache[number] {
        return fib

    let newValue = number < 2 ? number : fibonacci(number - 2) + fibonacci(number - 1)
    fibCache[number] = newValue 
    return newValue

for i in 1...50 {

But then, we are incurring the cost of holding a vast cache to speed up computation.

A different approach would be to compute values only when needed. Following the Fibonacci computation, we can reduce the data stored to just two variables. All we need to do is to adhere to IteratorProtocol, which requires the definition of func next() -> Self.Element?

struct FibonacciIterator: IteratorProtocol {
    private var a = 0
    private var b = 0

    init() {
        a = 0
        b = 0

    mutating func next() -> Int? {
        let (f, o) = a.addingReportingOverflow(b) // the returned tuple will let us know if we are overflowing Int
        guard !o else {
            return nil

        if a == 0 { // special case, first iteration
            a = 1
        } else {
            a = b
            b = f

        return f

Because IteratorProtocol is tightly linked with the Sequence protocol, we can create our own Sequence, and by exposing an iterator, for loops are a breeze.

struct Fibonacci: Sequence {
    func makeIterator() -> some IteratorProtocol {

var fi = Fibonacci()

for f in fi {