 }
 
 //------------------------------------------------------------------------
+// Simplest Strideable
+
+public struct MySimplestStrideable : MyStrideable {
+  internal let _value: Int
+  internal init(_ value: Int) {
+    self._value = value
+  }
+
+  @warn_unused_result
+  public func distanceTo(other: MySimplestStrideable) -> Int {
+    return _value.distanceTo(other._value)
+  }
+
+  @warn_unused_result
+  public func advancedBy(n: Int) -> MySimplestStrideable {
+    return MySimplestStrideable(_value.advancedBy(n))
+  }
+}
+
+public func == (
+  lhs: MySimplestStrideable,
+  rhs: MySimplestStrideable
+) -> Bool {
+  return lhs._value == rhs._value
+}
+
+public func < (
+  lhs: MySimplestStrideable,
+  rhs: MySimplestStrideable
+) -> Bool {
+  return lhs._value < rhs._value
+}
+
+//------------------------------------------------------------------------
 
 // FIXME: how does AnyCollection look like in the new scheme?
 

  expectEmpty(s.popFirst())
}

runAllTests()


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
