 /// - Note: Idiomatic usage is to call `enumerate` instead of
 ///   constructing an `EnumerateSequence` directly.
 public struct EnumerateSequence<Base : SequenceType> : SequenceType {
-  var base: Base
+  internal var _base: Base
 
   /// Construct from a `Base` sequence.
   public init(_ base: Base) {
-    self.base = base
+    self._base = base
   }
 
   /// Returns a *generator* over the elements of this *sequence*.
   ///
   /// - Complexity: O(1).
   public func generate() -> EnumerateGenerator<Base.Generator> {
-    return EnumerateGenerator(base.generate())
+    return EnumerateGenerator(_base.generate())
   }
 }
 

> : GeneratorType, SequenceType {
  /// The type of element returned by `next()`.
  public typealias Element = (offset: Int, element: Base.Element)
  var base: Base
  var count: Int

  /// Construct from a `Base` generator.
  public init(_ base: Base) {
    self.base = base
    count = 0
  }

  /// Advance to the next element and return it, or `nil` if no next

  ///
  /// - Requires: No preceding call to `self.next()` has returned `nil`.
  public mutating func next() -> Element? {
    guard let b = _base.next() else { return .None }
    return .Some((offset: _count++, element: b))
  }
}

