 }
 
 extension Concatenation : RandomAccessCollection
-  where C1: RandomAccessCollection, C2: RandomAccessCollection
+  where Base1: RandomAccessCollection, Base2: RandomAccessCollection
 {
   public func index(_ i: Index, offsetBy n: Int) -> Index {
     if n == 0 { return i }

  }
}

//===--- ConcatenatedCollection -------------------------------------------===//
//===----------------------------------------------------------------------===//

// ConcatenatedCollection improves on a flattened array or other collection by
// allowing random-access traversal if the underlying collections are
// random-access.
//
// Q: Add a ConcatenatedSequence for consistency? Would be nice to be able to
// call `let seqAB = concatenate(seqA, seqB)`.

/// A concatenation of two collections with the same element type.
public struct Concatenation<C1 : Collection, C2: Collection>: Collection
  where C1.Element == C2.Element
{
  let _base1: C1
  let _base2: C2

  init(_base1: C1, base2: C2) {
    self._base1 = _base1
    self._base2 = base2
  }

  /// A position in a `Concatenation`.
  public struct Index : Comparable {
    internal enum _Representation : Equatable {
      case first(C1.Index)
      case second(C2.Index)
    }

    /// Creates a new index into the first underlying collection.
    internal init(first i: C1.Index) {
      _position = .first(i)
    }

    /// Creates a new index into the second underlying collection.
    internal init(second i: C2.Index) {
      _position = .second(i)
    }


    return Index(second: _base2.endIndex)
  }

  public subscript(i: Index) -> Base1.Element {
    switch i._position {
    case let .first(i):
      return _base1[i]
