Hello mailing list,

Since the following proposal was discussed before the release of Swift 3 and 
then delayed, I’m opening it up again for a short pre-review before to get some 
additional feedback before it can be merged.

Web link: 

Permit where clauses to constrain associated types

Proposal: SE-NNNN 
Authors: David Hart <https://github.com/hartbit>, Jacob Bandes-Storch 
<https://github.com/jtbandes>, Doug Gregor <https://github.com/DougGregor>
Review Manager: TBD
Status: Awaiting review

This proposal seeks to introduce a where clause to associated type declarations 
and improvements to protocol constraints to bring associated types the same 
expressive power as generic type parameters.

This proposal was discussed twice on the Swift Evolution list in the following 

[Completing Generics] Arbitrary requirements in protocols 
[Proposal] More Powerful Constraints for Associated Types
Week #1 
Week #2 
Week #3 

Currently, associated type declarations can only express simple inheritance 
constraints and not the more sophisticated constraints available to generic 
types with the where clause. Some designs, including many in the Standard 
Library, require more powerful constraints for associated types to be truly 
elegant. For example, the SequenceType protocol could be declared as follows if 
the current proposal was accepted:

protocol Sequence {
    associatedtype Iterator : IteratorProtocol
    associatedtype SubSequence : Sequence where SubSequence.Iterator.Element == 

First of all, this proposal modifies the grammar for a protocol's associated 
types to the following:

protocol-associated-type-declaration → attributesopt access-level-modifieropt 
associatedtype typealias-name ­type-inheritance-clause­opt 
typealias-assignment­opt requirement-clauseopt

The new requirement-clause is then used by the compiler to validate the 
associated types of conforming types.

Secondly, the proposal also allows protocols to use the associated types of 
their conforming protocols in their declaration where clause as below:

protocol IntSequence : Sequence where Iterator.Element == Int {
Name lookup semantics in the protocol declaration where clause only looks at 
associated types in the parent protocols. For example, the following code would 
cause an error:

protocol SomeSequence : Sequence where Counter : SomeProtocol { // error: Use 
of undefined associated type 'Counter'
    associatedtype Counter
But instead should be written on the associated type itself:

protocol IntSequence : Sequence {
    associatedtype Counter : SomeProtocol
 on ABI Stability

As mentioned previously, there are a number of places in the standard library 
where this feature would be adopted (such as the SubSequence.Iterator.Element 
== Iterator.Element example), each of which will change the mangling of any 
generic function/type that makes use of them.


Douglas Gregor argues that the proposed syntax is redundant when adding new 
constraints to an associated type declared in a parent protocol and proposes 
another syntax: 

protocol Collection : Sequence {
    where SubSequence : Collection
But as Douglas notes himself, that syntax is ambiguous since we adopted the 
generic where clause at the end of declarations of the following proposal: 
SE-0081: Move where clause to end of declaration 
 For those reasons, it might be wiser not to introduce the shorthand syntax.


Thanks to Dave Abrahams and Douglas Gregor for taking the time to help me 
through this proposal.
swift-evolution mailing list

Reply via email to