conforming to Sequence and IteratorProtocol in Swift

Question

I am trying to write my own version of IndexingIterator to increase my understanding of Sequence. I haven't assign any type to associatetype Iterator in my struct. However, the complier doesn't complain about that and I get a default implementation of makeIterator.

Following are my codes:

struct __IndexingIterator<Elements: IndexableBase>: Sequence, IteratorProtocol {
    mutating func next() -> Elements._Element? {
        return nil
    }
}
let iterator = __IndexingIterator<[String]>()
// this works and returns an instance of __IndexingIterator<Array<String>>. why?
iterator.makeIterator() 

I think there must be some extensions on Sequence which add the default implementation. Thus, I searched it in Sequence.swift and only found this.

extension Sequence where Self.Iterator == Self, Self : IteratorProtocol {
  /// Returns an iterator over the elements of this sequence.
  public func makeIterator() -> Self {
    return self
  }
}

I thought it would be like this:

extension Sequence where Self: IteratorProtocol {
    typealias Iterator = Self
    ...
}

Did I miss something or I misunderstood the extension?

Answer 1

It looks like Alexander's answer is correct. Here's a boiled down version, without using Sequence:

protocol MySequence {
    associatedtype Iterator: IteratorProtocol
    func maakeIterator() -> Iterator
}

extension MySequence where Self.Iterator == Self, Self : IteratorProtocol {
    /// Returns an iterator over the elements of this sequence.
    func maakeIterator() -> Self {
        return self
    }
}

struct __IndexingIterator<Element>: MySequence, IteratorProtocol {
    mutating func next() -> Element? {
        return nil
    }
}

let iterator = __IndexingIterator<[String]>()
iterator.maakeIterator()

Answer 2

You can write your own Iterator which confrom to IteratorProtocol first, then write what you need confrom to Sequence.

Make sure that you have to implement requried func.

   struct IteratorTest : IteratorProtocol {
        typealias Element = Int

        var count : Int

        init(count :Int) {
            self.count = count
        }

        mutating func next() -> Int? {
            if count == 0 {
                return nil
            }else {
                defer {
                    count -= 1
                }
                return count;
            }
        }
    }

    struct CountDown : Sequence {
        typealias Iterator = IteratorTest
        func makeIterator() -> IteratorTest {
            return IteratorTest.init(count: 10)
        }
    }