public protocol Fooable {
  func foo<T>(_ x: T)
}

public class FooClass : Fooable {
  public init() { }
  public func foo<U>(_ x: U) {}
}

public struct FooStruct : Fooable {
  public func foo<V>(_ x: V) {}
  public init() {}
}


public protocol Barrable {
  func bar<T>(_ x: Self, y: T)
}

public class BarClass : Barrable {
  public init() { }
  public func bar<U>(_ x: BarClass, y: U) { }
}

public struct BarStruct : Barrable {
  public var x = 0
  public func bar<V>(_ x: BarStruct, y: V) { }
  public init() {}
}


public protocol HasAssociatedType {
  associatedtype Foo : Fooable
}

public protocol Bassable {
  func bas<T : HasAssociatedType>(_ x: T, y: T.Foo)
}

public class BasClass : Bassable {
  public init() { }
  public func bas<U : HasAssociatedType>(_ x: U, y: U.Foo) {}
}

public struct BasStruct : Bassable {
  public func bas<V : HasAssociatedType>(_ x: V, y: V.Foo) {}
  public init() {}
}


prefix operator ~~~

public protocol _CyclicAssociated {
  associatedtype Assoc = CyclicImpl
}

public protocol CyclicAssociated : _CyclicAssociated {
  static prefix func ~~~(_: Self.Type)
}

prefix public func ~~~ <T: _CyclicAssociated>(_: T.Type) {}

public struct CyclicImpl : CyclicAssociated {
  public typealias Assoc = CyclicImpl
  public init() {}
}