SE-0241: Explicit Encoded Offsets for String Indices

[Michael_Ilseman]

I think it would be much better to extend all Collections with the means to get the offset of a given index, and an index at a given offset. Such as:

@Michael_Ilseman

I think this is what the final solution may look like:

extension [Bidirectional/Ordered?]Collection {
  func index(atOffset offset: Int) -> Index? {
    if offset < 0 {
      // Non-Bidirectional traps instead
      return index(endIndex, offsetBy: offset, limitedBy: startIndex) 
    }
    return index(startIndex, offsetBy: offset, limitedBy: endIndex)
  }
  subscript(offset offset: Int) -> Element? {
    guard let idx = index(atOffset: offset) else { return nil }
    return self[idx]
  }
  subscript(offset range: Range<Int>) -> SubSequence {
  subscript(offset range: Range<Int>) -> SubSequence {
    let lower = index(atOffset: range.lowerBound) ?? endIndex
    let upper = index(atOffset: range.upperBound) ?? endIndex
    guard lower <= upper else { return self[endIndex..<endIndex] }
    return self[lower..<upper]
  }
  ...
}

and a corresponding offset(of: Index) -> Int method as well. Way out of scope for 5.0 at this point.

Reasons I kept this on String.Index:

1. It's a off-ramp for misuses of encodedOffset which is already on String.Index.
2. String.Index is an infrequent namespace; if we had to pollute something that will be superseded in the future, better in an infrequent namespace.
3. It's name wouldn't conflict with a more general addition to all Collections.