Will implementation of this feature allow for instantiation of structs that add a recursive protocol constraint? i.e.

protocol Wrapper { associatedtype Wrapped }
indirect enum Foo<Bar: Wrapper> where Bar.Wrapped == Foo { case bar(Bar) }

This code currently compiles, but it is impossible to create an instance of `Foo` since you cannot write a type that is parameterized by itself. I guess I would also expect recursive typealiases to work as well.

typealias FooFix = Foo<FooFix?> // assuming Optional: Wrapper

What is the status on this? Seems a critical piece to the generic puzzle. 🙂

Code from a library I'm writing:

public protocol QueryBridgeable  {
    
    associatedtype Base = Self where Base : Queryable & QueryBridgeable
    
    var query:QueryFactory<Base> { get } // Error "'query' used within its own type"
    func query(_ options:SubQueryOptions) -> QueryFactory<Base>
}

All items that are "query bridgeable" should be able to generate ("query") items that are themselves "query bridgeable" so they have access to the same interface.

Still working on it, but getting a whole lot closer!

Go Doug Go!! 🙂

@davidbjames is there a reason why this wouldn't work for you?

public protocol QueryBridgeable  {
  var query: QueryFactory<QueryBridgeable & Queryable> { get }
  func query(_ options: SubQueryOptions) -> QueryFactory<QueryBridgeable & Queryable>
}

I'm going to mark this as "done" for now. While there are some known bugs (including non-trivial ones!), we've rolled out the feature in the standard library and developers should be able to use it in Swift 4.1.