     self._base = base
   }
 
-  public var _base: Base_
-
-  // FIXME: Why is this needed?
-  // public var elements: Base { return _base }
+  public var elements: Base { return _base }
+
+  internal var _base: Base_
+}
+
+extension _prext_LazyCollection : SequenceType {
+  public func generate() -> Base.Generator { return _base.generate() }
+  public func underestimateCount() -> Int { return _base.underestimateCount() }
+
+  public func _copyToNativeArrayBuffer() 
+     -> _ContiguousArrayBuffer<Base.Generator.Element> {
+    return _base._copyToNativeArrayBuffer()
+  }
+  
+  public func _initializeTo(ptr: UnsafeMutablePointer<Base.Generator.Element>) {
+    return _base._initializeTo(ptr)
+  }
+
+  public func _customContainsEquatableElement(
+    element: Base.Generator.Element
+  ) -> Bool? { 
+    return _base._customContainsEquatableElement(element)
+  }
+}
+
+extension _prext_LazyCollection : CollectionType {
+  /// The position of the first element in a non-empty collection.
+  ///
+  /// In an empty collection, `startIndex == endIndex`.
+  public var startIndex: Base.Index {
+    return _base.startIndex
+  }
+  
+  /// The collection's "past the end" position.
+  ///
+  /// `endIndex` is not a valid argument to `subscript`, and is always
+  /// reachable from `startIndex` by zero or more applications of
+  /// `successor()`.
+  public var endIndex: Base.Index {
+    return _base.endIndex
+  }
+
+  /// Access the element at `position`.
+  ///
+  /// - Requires: `position` is a valid position in `self` and
+  ///   `position != endIndex`.
+  public subscript(position: Base.Index) -> Base.Generator.Element {
+    return _base[position]
+  }
 }
 
 /// Augment `s` with lazy methods such as `map`, `filter`, etc.
-public func _prext_lazy<Base: CollectionType>(s: Base) -> _prext_LazyCollection<Base> {
-  return _prext_LazyCollection(s)
-}
-
-
 //===--- Map.swift --------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure

}
*/

var tests = TestSuite("Lazy")

tests.test("basics") {
  
}

runAllTests()

}

extension CollectionType
  where Self : _ReverseCollectionType, Self.Index.Base == Self.Base.Index
{
  public var startIndex : Index { return Self.Index(_base.endIndex) }
  public var endIndex : Index { return Self.Index(_base.startIndex) }
  public subscript(position: Index) -> Self.Base.Generator.Element {
    return _base[position._base.predecessor()]
