subscript(bounds: Range<Index>) -> SubSequence { get set }

subscript(bounds: Range<Index>) -> Slice<Self> { get set }

struct MyMutableRange {
  public let start: Int
  public let count: Int

  public init(_ range: Range<Int>) {
    start = range.lowerBound
    count = range.count
  }
}

extension MyMutableRange: Sequence {
  public struct Iterator: IteratorProtocol {
    public mutating func next() -> Int? { nil }
  }

  public func makeIterator() -> Iterator { Iterator() }
}

extension MyMutableRange: Collection, MutableCollection {
  public typealias Index = Int
  public typealias SubSequence = Self

  public var startIndex: Index { start }
  public var endIndex: Index { start + count }

  public func index(after i: Index) -> Index {
    i.advanced(by: 1)
  }


  public subscript(position: Index) -> Int {
    get {
      precondition(position >= start)
      precondition(position < endIndex)
      return position
    }
    nonmutating set(newValue) {
      precondition(position >= start)
      precondition(position < endIndex)
      _ = newValue
    }
  }

//  public subscript(bounds: Range<Index>) -> SubSequence {
//    get {
//      precondition(bounds.lowerBound >= startIndex)
//      precondition(bounds.upperBound <= endIndex)
//      return SubSequence(start: bounds.lowerBound, count: bounds.count)
//    }
//    nonmutating set {
//      precondition(bounds.lowerBound >= startIndex)
//      precondition(bounds.upperBound <= endIndex)
//      precondition(bounds.count == newValue.count)
//      if !newValue.isEmpty {
//        bounds.lowerBound.copyMemory(from: newValue.baseAddress,
//                                     byteCount: newValue.count)
//      }
//    }
//  }
}

var rb: MyMutableRange
rb = MyMutableRange(0..<48)

// Not the correct SubSequence type
let slice: Slice<MyMutableRange> = rb[16..<24]
rb[32..<40] = slice