Providing a default implementation for Collection conformance prevents additional subscript requirements

Question

I have a protocol that itself conforms to Swift's Collection protocol, and that requires an additional subscript (Key) -> Value? returning the value associated with a given key, only if it exists (pretty much like Swift's Dictionary does).

protocol SearchTree: Collection {
    subscript(key: Int) -> String? { get }
}

struct ConformingTree: SearchTree {
    // Implementation ...
}

Now, I'd like to extend it with a default implementation for all Collection's requirements, plus my additional subscript (I guess the implementation specifics are irrelevant, which is why I removed them).

protocol SearchTree: Collection {
    subscript(key: Int) -> String? { get }
}

extension SearchTree {
    // MARK: Conformance to Sequence
    func makeIterator() -> AnyIterator<(key: Int, value: String)> { /* ... */ }

    // MARK: Conformance to Collection
    var startIndex: Int { /* ... */ }
    var endIndex: Int { /* ... */ }
    func index(after i: Int) -> Int { /* ... */ }
    subscript(key: Int) -> (key: Int, value: String) { /* ... */ }

    // MARK: Conformance to SearchTree
    subscript(key: Int) -> String? { /* ... */ }
}

struct ConformingTree: SearchTree {
    // Removing previous implementations ...
}

Unfortunately, this code will fail with Swift complaining that ConformingTree doesn't conforms to Collection, unless I keep an implementation for at least one of the subscripts in the conforming type.

struct ConformingTree: SearchTree {
    subscript(key: Int) -> String? { /* ... */ }
}

I originally thought that Swift was unable to infer the type of the correct subscript in my extension. But this seems unlikely as it eventually can figure out which implementation correspond to which protocol requirement if I push them in the conforming type. As I understand, the return type of makeIterator() should force the subscript with signature (Int) -> (Key, String) to fulfil Collection's requirement anyway.

Does anyone know what I'm missing here?

Answer 1

Two problems:

1. Your declaration of the subscript in the SearchTree protocol needs to have { get } after it.

2. Collection requires a subscript that returns its Element. You have two subscripts, one of which returns a String? and one of which returns a (key: Int, value: String), but neither of these is Element, which the compiler needs; therefore the type does not conform to Collection. If you define Element in either your protocol or in the extension, it should compile.

In the protocol:

associatedtype Element = (key: Int, value: String)

or:

associatedtype Element = String?

Or in the extension:

typealias Element = (key: Int, value: String)

or:

typealias Element = String?

EDIT:

The above is true for Swift 4; however, for Swift 3, you also need to define _Element in addition to Element. Copying and pasting your code into a project, the following declaration of the protocol causes everything to compile in Swift 3:

protocol SearchTree: Collection {
    associatedtype Element = (key: Int, value: String)
    associatedtype _Element = (key: Int, value: String)

    subscript(key: Int) -> String? { get }
}