 > : GeneratorType, SequenceType {
   /// The type of element returned by `next()`.
   public typealias Element = (offset: Int, element: Base.Element)
-  var base: Base
-  var count: Int
+  var _base: Base
+  var _count: Int
 
   /// Construct from a `Base` generator.
   public init(_ base: Base) {
-    self.base = base
-    count = 0
+    self._base = base
+    self._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))
  }
}


/// - Note: Idiomatic usage is to call `enumerate` instead of
///   constructing an `EnumerateSequence` directly.
public struct EnumerateSequence<Base : SequenceType> : SequenceType {
  internal var _base: Base

  /// Construct from a `Base` sequence.
  public init(_ 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())
  }
}

