 public func ..<*
   <Index : Comparable>(lhs: Index, rhs: Index) -> MyRange<Index> {
   return MyRange(start: lhs, end: rhs)
+}
+
+// FIXME: replace this type with a conditional conformance on MyRange.
+public struct MyIterableRange<Index : MyStrideable> :
+  MyBidirectionalCollectionType {
+
+  public let startIndex: Index
+  public let endIndex: Index
+
+  public init(start: Index, end: Index) {
+    _precondition(start <= end, "Can't form a backwards MyIterableRange")
+    self.startIndex = start
+    self.endIndex = end
+  }
+
+  @warn_unused_result
+  public func next(i: Index) -> Index {
+    let result = i.advancedBy(1)
+    _precondition(startIndex <= result, "can't advance past endIndex")
+    return i.advancedBy(1)
+  }
+
+  @warn_unused_result
+  public func previous(i: Index) -> Index {
+    let result = i.advancedBy(-1)
+    _precondition(result <= endIndex, "can't advance before startIndex")
+    return result
+  }
+
+  public subscript(i: Index) -> Index {
+    return i
+  }
+}
+
+public func ..<*
+  <Index : MyStrideable>(lhs: Index, rhs: Index) -> MyIterableRange<Index> {
+  return MyIterableRange(start: lhs, end: rhs)
 }
 
 // FIXME: in order for all this to be usable, we need to unify MyRange and

}

//------------------------------------------------------------------------

// FIXME: how does AnyCollection look like in the new scheme?


  expectEmpty(s.popFirst())
}

NewCollection.test("RangeLiterals") {
  let comparable = MinimalComparableValue(0)
  let strideable = MySimplestStrideable(0)

  var comparableRange = comparable..<*comparable
  expectType(MyRange<MinimalComparableValue>.self, &comparableRange)

  var strideableRange = strideable..<*strideable
  expectType(MyIterableRange<MySimplestStrideable>.self, &strideableRange)

  for _ in OldSequence(0..<*10) {}
}

runAllTests()

