 
   public var count: Index.Distance {
     return distanceFrom(startIndex, to: endIndex)
+  }
+
+  @warn_unused_result
+  public func dropFirst(n: Int) -> SubSequence {
+    _precondition(n >= 0, "Can't drop a negative number of elements from a collection")
+/*
+    let start = advance(startIndex, by: numericCast(n), limit: endIndex)
+    return self[start..<endIndex]
+*/
+    fatalError()
+  }
+
+  @warn_unused_result
+  public func dropLast(n: Int) -> SubSequence {
+    _precondition(n >= 0, "Can't drop a negative number of elements from a collection")
+    let amount = max(0, numericCast(count) - n)
+    let end = advance(startIndex, by: numericCast(amount), limit: endIndex)
+    return self[startIndex..<*end]
+  }
+
+  @warn_unused_result
+  public func prefix(maxLength: Int) -> SubSequence {
+    _precondition(maxLength >= 0, "Can't take a prefix of negative length from a collection")
+    let end = advance(startIndex, by: numericCast(maxLength), limit: endIndex)
+    return self[startIndex..<*end]
+  }
+
+  @warn_unused_result
+  public func suffix(maxLength: Int) -> SubSequence {
+    _precondition(maxLength >= 0, "Can't take a suffix of negative length from a collection")
+    let amount = max(0, numericCast(count) - maxLength)
+    let start = advance(startIndex, by: numericCast(amount), limit: endIndex)
+    return self[start..<*endIndex]
   }
 }
 extension MyForwardCollectionType

    return _elements.endIndex
  }
  public subscript(i: Int) -> Element {
    return _elements[i]
  }
}


  associatedtype Index : MyIndexType
  var startIndex: Index { get }
  var endIndex: Index { get }
  subscript(from start: Index, to end: Index) -> Self { get }
}

public func == <IR : MyIndexRangeType> (lhs: IR, rhs: IR) -> Bool {
