Creating a ValidIndexCollection protocol in Swift 3 - swift

Question

A while ago, I made a Binary Search Tree type in Swift that I wanted to conform to the Collection protocol. However, the endIndex requirement is a "past the end" index which isn't really appropriate for a tree because each index should hold a reference to its corresponding node for O(1) access. I ended up with an optional reference (being nil in the case of endIndex), but it involved a lot of boilerplate code that I'd rather avoid.
I decided to make a ValidIndexCollection protocol that looks like this:
/// A collection defined by valid indices only, rather than a
/// startIndex and a "past the end" endIndex.
protocol ValidIndexCollection: Collection {
associatedtype ValidIndex: Comparable
/// The first valid index if the collection is nonempty,
/// nil otherwise.
var firstValidIndex: ValidIndex? { get }
/// The last valid index if the collection is nonempty,
/// nil otherwise.
var lastValidIndex: ValidIndex? { get }
/// Returns the index right after the given index.
func validIndex(after index: ValidIndex) -> ValidIndex
/// Returns the element at the given index.
func element(at index: ValidIndex) -> Iterator.Element
}
Before I can extend this protocol to satisfy the Collection requirements, I have to introduce an appropriate index first:
enum ValidIndexCollectionIndex<ValidIndex: Comparable> {
case index(ValidIndex)
case endIndex
}
extension ValidIndexCollectionIndex: Comparable {
// ...
}
Now I can extend ValidIndexCollection:
// Implementing the Collection protocol requirements.
extension ValidIndexCollection {
typealias _Index = ValidIndexCollectionIndex<ValidIndex>
var startIndex: _Index {
return firstValidIndex.flatMap { .index($0) } ?? .endIndex
}
var endIndex: _Index {
return .endIndex
}
func index(after index: _Index) -> _Index {
guard case .index(let validIndex) = index else { fatalError("cannot increment endIndex") }
return .index(self.validIndex(after: validIndex))
}
subscript(index: _Index) -> Iterator.Element {
guard case .index(let validIndex) = index else { fatalError("cannot subscript using endIndex") }
return element(at: validIndex)
}
}
All seems well, the compiler doesn't complain! However, I tried to implement this protocol for a custom type:
struct CollectionOfTwo<Element> {
let first, second: Element
}
extension CollectionOfTwo: ValidIndexCollection {
var firstValidIndex: Int? { return 0 }
var lastValidIndex: Int? { return 1 }
func validIndex(after index: Int) -> Int {
return index + 1
}
subscript(index: Int) -> Element {
return index == 0 ? first : second
}
}
Now the compiler complains that CollectionOfTwo doesn't conform to Collection, Sequence, and IndexableBase. The error messages are very unhelpful, it's mostly messages like:
Protocol requires nested type SubSequence; do you want to add it?
or
Default type DefaultIndices<CollectionOfTwo<Element>> for associated type Indices (from protocol Collection) does not conform to IndexableBase
Is there any way to make this work? As far as I can tell, ValidIndexCollection satisfies the Collection requirements just fine.
Some things to note:
I called the ValidIndexCollection protocol method
validIndex(after:) that way because calling it index(after:)
resulted in a segmentation fault when trying to implement this protocol. That probably has something to do with the
index(after:) method from the Collection protocol.
For the same reason I used element(at:) instead of a subscript.
I used typealias _Index instead of typealias Index because the latter resulted in an error message saying "Index is ambiguous for type lookup in this context". Again, this probably has something to do with Collection's Index associated type.

Answer 1

Adding associatedtype Element to ValidIndexCollection and replacing all occurrences of Iterator.Element by Element fixed it.