Why do I have to implement append(contentsOf newElements: S) in my custom RangeReplaceableCollection

Question

I am currently trying to update a custom collection type to Swift 4.1. However, when I adhere to the documentation and implement all requirements for Collection and RangeReplaceableCollection, Xcode is still complaining that my type does not conform to RangeReplaceableCollection.

Here's an mcve for the problem (generously provided by Hamish, thank you for that :)

class Foo<Element : AnyObject> {
  required init() {}
  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 replaceSubrange<C : Collection>(
    _ subrange: Range<Index>, with newElements: C
  ) where Element == C.Element {}
}

According to the documentation, the code should compile:

To add RangeReplaceableCollection conformance to your custom collection, add an empty initializer and the replaceSubrange(_:with:) method to your custom type. RangeReplaceableCollection provides default implementations of all its other methods using this initializer and method.

Unfortunately though, it doesn't. Instead, Xcode emits the following error message:

// 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
//   

To make sure it's not an error in the documentation, I checked the source code of Swift 4.1 and found the default implementation of func append<S>(contentsOf newElements: S) where S: Sequence, Element == S.Element in RangeReplaceableCollection.swift, lines 442-452:

@_inlineable
public mutating func append<S : Sequence>(contentsOf newElements: S) where S.Element == Element {
  let approximateCapacity = self.count + numericCast(newElements.underestimatedCount)
  self.reserveCapacity(approximateCapacity)
  for element in newElements {
    append(element)
  }
}

---

Question:

• Why does Xcode ask for an implementation of this function although a default implementation is provided?
• How do I get my code to compile?

Answer 1

Why does Xcode ask for an implementation of this function although a default implementation is provided?

This is due to a bug in the TypeChecker, introduced in Swift 4.1:
[SR-7429]: Cannot conform a non-final class to a protocol with a defaulted requirement with a generic placeholder constrained to an associated type

How do I get my code to compile?

Until the bug is fixed, there's currently three ways to get it to compile.

• Implement these two functions:

  • required init<S : Sequence>(_ elements: S) where Element == S.Element {}
  • func append<S : Sequence>(contentsOf newElements: S) where Element == S.Element

• Mark the class as final.

• Implement the collection type as a struct. For this, the required init() {} must be removed.