protocol P {
  associatedtype Q = String
  func foo<T>(_ t: T) where T == Q
}

extension P {
  func foo<T>(_ t: T) where T == Q {}
}

class C : P {}

// error: type 'C' does not conform to protocol 'P'
// class C : P {}
//       ^
// note: candidate has non-matching type '<Self, T> (T) -> ()' [with Q = String]
// func foo<T>(_ t: T) where T == Q { }
//      ^
// note: protocol requires function 'foo' with type '<T> (T) -> ()'; do you want to add a stub?
// func foo<T>(_ t: T) where T == Q
//      ^

class Foo<Element> {
  required init() {}
  // required init<S : Sequence>(_ elements: S) where Element == S.Element {}
  private var base: [Element] = []
}

extension Foo : Collection {
  typealias Index = Int

  var startIndex: Index {
    return base.startIndex
  }

  var endIndex: Index {
    return base.endIndex
  }

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

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

extension Foo : RangeReplaceableCollection {

  // func append<S : Sequence>(contentsOf newElements: S) where Element == S.Element {}
  func replaceSubrange<C : Collection>(
    _ subrange: Range<Index>, with newElements: C
  ) where Element == C.Element {}
}


// error: type 'Foo<Element>' does not conform to protocol 'RangeReplaceableCollection'
// extension Foo : RangeReplaceableCollection {
// ^
//   Swift.RangeReplaceableCollection:5:26: note: candidate has non-matching type '<Self, S> (contentsOf: S) -> ()' [with SubSequence = Foo<Element>.SubSequence]
//   public mutating func append<S>(contentsOf newElements: S) where S : Sequence, Self.Element == S.Element
//                        ^
//   Swift.RangeReplaceableCollection:9:26: note: protocol requires function 'append(contentsOf:)' with type '<S> (contentsOf: S) -> ()'; do you want to add a stub?
//   public mutating func append<S>(contentsOf newElements: S) where S : Sequence, Self.Element == S.Element
//                        ^