   /// - complexity: O(1)
   public func generate() -> Generator {
     return Generator(
-      sequences.0.generate(), 
-      sequences.1.generate())
+      _sequences.0.generate(),
+      _sequences.1.generate())
   }
 
-  var sequences: (S0,S1)
+  internal let _sequences: (Sequence1, Sequence2)
 }

/// A sequence of pairs built out of two underlying sequences, where
/// the elements of the `i`th pair are the `i`th elements of each
/// underlying sequence.
public func zip<S0: SequenceType, S1: SequenceType>(
  s0: S0, _ s1: S1
) -> Zip2<S0, S1> {
  return Zip2(s0, s1)
}

/// A generator for the `Zip2` sequence
public struct ZipGenerator2<
  E0 : GeneratorType, E1 : GeneratorType
> : GeneratorType {
  /// The type of element returned by `next()`.
  public typealias Element = (E0.Element,E1.Element)

  /// Construct around a pair of underlying generators.
  public init(_ e0: E0, _ e1: E1) {
    baseStreams = (e0,e1)
  }

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

    return .Some((e0!, e1!))
  }

  internal var _baseStreams: (Generator1, Generator2)
  internal var _reachedEnd: Bool = false
}

/// A sequence of pairs built out of two underlying sequences, where
/// the elements of the `i`th pair are the `i`th elements of each
/// underlying sequence.
public struct Zip2<Sequence1 : SequenceType, Sequence2 : SequenceType>
  : SequenceType {

  public typealias Stream1 = Sequence1.Generator
  public typealias Stream2 = Sequence2.Generator

  /// A type whose instances can produce the elements of this
  /// sequence, in order.
  public typealias Generator = ZipGenerator2<Stream1, Stream2>

  /// Construct an instance that makes pairs of elements from `sequence1` and
  /// `sequence2`.
  public init(_ sequence1: Sequence1, _ sequence2: Sequence2) {
    _sequences = (sequence1, sequence2)
  }

  /// Return a *generator* over the elements of this *sequence*.
