 /// A sequence that forwards its implementation to an underlying
 /// sequence instance while exposing lazy computations as methods.
 public struct _prext_LazySequence<Base_ : SequenceType> : _SequenceWrapperType {
-  var _base: Base_
+  public var _base: Base_
 }
 
 /// Augment `s` with lazy methods such as `map`, `filter`, etc.

public struct _prext_LazyCollection<Base_ : CollectionType>
  : /*_prext_LazyCollectionType,*/ _CollectionWrapperType {

  typealias Base = Base_
  typealias Index = Base.Index
  
  /// Construct an instance with `base` as its underlying Collection
  /// instance.

  public typealias Base = Base_
  public typealias Distance = Base_.Distance
  
  public init(_ base: Base) { self._base = base }
  public let _base: Base
}

public func == <I> (lhs: _prext_ReverseIndex<I>, rhs: _prext_ReverseIndex<I>) -> Bool {
