Hey everyone, I've got some questions and concerns about PATs and what the roadmap for them is. I've asked about them before, but I can't find that thread nor do I really get what's going on. When I've brought stuff like this up before, words like "higher-kinded types" or "generalized existentials" get thrown around that just make me feel stupid and don't really do anything to contribute to the conversation nor enlighten those of us who don't actually write our own compilers.
To give a bit of clarification about what's causing these questions, I was recently trying to implement some generic predicate code using protocols and was running in to serious issues.
protocol Predicate {
associatedtype Element
func contains(_ other: Element) -> Bool
}
On the surface, this is a very very simple protocol, and you can see how this protocol could be easily adopted by NSPredicate, IndexSet, or any SetAlgebra type.
For the sake of continuing examples, we're going to focus on two implementations: IndexSet and a custom set of structs where the Element == Int, and the desire to union two sets.
To do this, we'll want a struct OrPredicate<Int> type that does the unioning logic.
The obvious thinking might be to do this:
protocol Predicate {
associatedtype Element
func contains(_ other: Element) -> Bool
func union(_ other: Self) -> Self
}
The problem with this approach, however, is that we cannot provide a default implementation of union() that uses our OrPredicate<T> implementation. The use of Self imposes a same-type requirement that is great for IndexSet, but broken for everything else. For example, you could imagine wanting to be able to union() a Set<Int> and an IndexSet, and get back some sort of Predicate that contains Int values. However, using Self disallows that.
So, since we don't necessarily want the same-type requirement, we next turn to generics:
protocol Predicate {
associatedtype Element
func contains(_ other: Element) -> Bool
func union<P: Predicate, R: Predicate>(_ other: P) -> R where P.Element == Element, R.Element == Element
}
This breaks in lots of ways, and IndexSet no longer fully implements the protocol when it has this definition, nor can you really imagine how it could implement this.
Next we'll turn to associatedtypes:
protocol Predicate {
associatedtype Element
associatedtype UnionResult: Predicate where UnionResult == Element
func contains(_ other: Element) -> Bool
func union<P: Predicate>(_ other: P) -> UnionResult where P.Element == Element
}
This is better, but we still run in to situations where requirements aren't satisfied. Additionally, we're limited to a single return type. If we union an IndexSet with an IndexSet, it makes sense we'd want an IndexSet back. But if we union a Set<Int> with an IndexSet, we'd want a UnionPredicate<Int> back. The associatedtype does not allow this.
What I really want to do is this:
protocol Predicate<Element> {
func contains(_ other: Element) -> Bool
func union(_ other: Predicate<Element>) -> Predicate<Element>
}
Of course, the compiler doesn't let me do this.
I want to express the idea that union() can take any Predicate-conforming value with the same element type, and you're going to get back some sort of Predicate-conforming value that contains elements of that type.
Then in specific situations where I can provide a much more efficient implementation (like the IndexSet + IndexSet = IndexSet scenario), I want to provide those explicit overrides for that method, and otherwise default back to the implementations I provide in my protocol extension (which happen to return an OrPredicate<Int>)
I guess my questions are:
- Why don't we actually have generic protocols?
- Will we ever get generic protocols?
- Is what I'm wanting to do something that will ever be possible in Swift, or are we kind of screwed and stuck with how things are now?
)