Define a protocol that holds Collection as a property

Question

I want to define a protocol that defines a variable "sequence" that is of type "Collection". I want that, because i have several conforming types, that will all hold an array of different types. Example:

protocol BioSequence {
    associatedtype T
    var sequence: Collection { get }

    // Will also implement conformance to Collection and redirect all Collection functions to the property "sequence". This is because my types that conform to BioSequence are just wrappers for an array of Nucleotide or AminoAcid with some extra functionality
}

struct DNASequence: BioSequence {
    // Will hold "sequence" of type [Nucleotide]
}

struct AminoSequence: BioSequence {
    // Will hold "sequence" of type [AminoAcid]
}

Why do i want this? Because i need to implement the conformance to "Collection" only once in BioSequence and all conforming type inherit it automatically. Plus i can freely add extra functionality on the conforming types.

Now, when i try this like the code above, the compiler says: "Protocol Collection can only be used as a generic constraint". Yes, i googled what this error means, but how can i actually fix it to make my code work, like i want. Or is it not even possible to do what i want?

Thank you.

Answer 1

You can easily achieve this by using an associatedtype in your protocol, which can be constrained to Collection, allowing conforming types to satisfy the requirement with a concrete type when they adopt the protocol.

For example:

protocol CollectionWrapper : Collection {
    associatedtype Base : Collection
    var base: Base { get }
}

extension CollectionWrapper {

    var startIndex: Base.Index {
        return base.startIndex
    }

    var endIndex: Base.Index {
        return base.endIndex
    }

    func index(after i: Base.Index) -> Base.Index {
        return base.index(after: i)
    }

    subscript(index: Base.Index) -> Base.Iterator.Element {
        return base[index]
    }

    // Note that Collection has default implementations for the rest of the
    // requirements. You may want to explicitly implement them and forward them to
    // the base collection though, as it's possible the base collection implements
    // them in a more efficient manner (e.g being non random access and having
    // a stored count).
}

// S adopts CollectionWrapper and satisfies the 'Base' associatedtype with [String].
struct S: CollectionWrapper {
    var base: [String]
}

let s = S(base: ["foo", "bar", "baz"])
print(s[1]) // "bar"

---

Regarding your comment:

If I want to use this like that: let a: CollectionWrapper = S() [...] this leaves me with "Protocol can only be used as a generic constraint" again.

The problem is that you cannot currently talk in terms of a protocol with associated type requirements, as the types which are used to satisfy those requirements are unknown to the compiler (this isn't a technical limitation though). You can solve this by using Swift's AnyCollection type eraser to wrap an arbitrary Collection with a given element type.

For example:

let a = AnyCollection(S(base: ["foo", "bar", "baz"]))

If you need to work with additional protocol requirements from CollectionWrapper, you'll have to implement your own type eraser to do so. See Rob's answer here for an idea of how to go about this.