Extracted internal classes. Removed AnySequence.

Author: palimondo

stdlib/public/core/DropFirst.swift

@@ -0,0 +1,71 @@
+//===-- DropFirst.swift ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A sequence that lazily consumes and drops `n` elements from an underlying
+/// `Base` iterator before possibly returning the first available element.
+///
+/// The underlying iterator's sequence may be infinite.
+///
+/// This is a class - we require reference semantics to keep track
+/// of how many elements we've already dropped from the underlying sequence.
+@_versioned
+@_fixed_layout
+public class _DropFirstSequence<Base : IteratorProtocol>
+    : Sequence, IteratorProtocol {
+
+  @_versioned
+  internal var _iterator: Base
+  @_versioned
+  internal let _limit: Int
+  @_versioned
+  internal var _dropped: Int
+
+  @_versioned
+  @_inlineable
+  internal init(_iterator: Base, limit: Int, dropped: Int = 0) {
+    self._iterator = _iterator
+    self._limit = limit
+    self._dropped = dropped
+  }
+
+  @_versioned
+  @_inlineable
+  internal func makeIterator() -> _DropFirstSequence<Base> {
+    return self
+  }
+
+  @_versioned
+  @_inlineable
+  internal func next() -> Base.Element? {
+    while _dropped < _limit {
+      if _iterator.next() == nil {
+        _dropped = _limit
+        return nil
+      }
+      _dropped += 1
+    }
+    return _iterator.next()
+  }
+
+  @_versioned
+  @_inlineable
+  internal func dropFirst(_ n: Int) -> AnySequence<Base.Element> {
+    // If this is already a _DropFirstSequence, we need to fold in
+    // the current drop count and drop limit so no data is lost.
+    //
+    // i.e. [1,2,3,4].dropFirst(1).dropFirst(1) should be equivalent to
+    // [1,2,3,4].dropFirst(2).
+    return AnySequence(
+      _DropFirstSequence(
+        _iterator: _iterator, limit: _limit + n, dropped: _dropped))
+  }
+}

stdlib/public/core/DropWhile.swift

@@ -0,0 +1,76 @@
+//===-- DropWhile.swift ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A sequence that lazily consumes and drops `n` elements from an underlying
+/// `Base` iterator before possibly returning the first available element.
+///
+/// The underlying iterator's sequence may be infinite.
+///
+/// This is a class - we require reference semantics to keep track
+/// of how many elements we've already dropped from the underlying sequence.
+@_fixed_layout
+@_versioned
+public class _DropWhileSequence<Base : IteratorProtocol>
+    : Sequence, IteratorProtocol {
+
+      typealias Element = Base.Element
+
+  @_versioned
+  internal var _iterator: Base
+  @_versioned
+  internal var _nextElement: Base.Element?
+
+  @_versioned
+  @_inlineable
+  internal init(
+    iterator: Base,
+    nextElement: Base.Element?,
+    predicate: (Base.Element) throws -> Bool
+  ) rethrows {
+    self._iterator = iterator
+    self._nextElement = nextElement ?? _iterator.next()
+
+    while try _nextElement.flatMap(predicate) == true {
+      _nextElement = _iterator.next()
+    }
+  }
+
+  @_versioned
+  @_inlineable
+  internal func makeIterator() -> _DropWhileSequence<Base> {
+    return self
+  }
+
+  @_versioned
+  @_inlineable
+  internal func next() -> Element? {
+    guard _nextElement != nil else {
+      return _iterator.next()
+    }
+
+    let next = _nextElement
+    _nextElement = nil
+    return next
+  }
+
+  @_versioned
+  @_inlineable
+  internal func drop(
+    while predicate: (Element) throws -> Bool
+  ) rethrows -> AnySequence<Element> {
+    // If this is already a _DropWhileSequence, avoid multiple
+    // layers of wrapping and keep the same iterator.
+    return try AnySequence(
+      _DropWhileSequence(
+        iterator: _iterator, nextElement: _nextElement, predicate: predicate))
+  }
+}

stdlib/public/core/Prefix.swift

@@ -0,0 +1,68 @@
+//===-- Prefix.swift ------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A sequence that lazily consumes up to `n` elements from an underlying
+/// `Base` iterator.
+///
+/// The underlying iterator's sequence may be infinite.
+///
+/// This is a class - we require reference semantics to keep track
+/// of how many elements we've already taken from the underlying sequence.
+@_fixed_layout
+@_versioned
+public class _PrefixSequence<Base : IteratorProtocol>
+    : Sequence, IteratorProtocol {
+  @_versioned
+  internal let _maxLength: Int
+  @_versioned
+  internal var _iterator: Base
+  @_versioned
+  internal var _taken: Int
+
+  @_versioned
+  @_inlineable
+  internal init(_iterator: Base, maxLength: Int, taken: Int = 0) {
+    self._iterator = _iterator
+    self._maxLength = maxLength
+    self._taken = taken
+  }
+
+  @_versioned
+  @_inlineable
+  internal func makeIterator() -> _PrefixSequence<Base> {
+    return self
+  }
+
+  @_versioned
+  @_inlineable
+  internal func next() -> Base.Element? {
+    if _taken >= _maxLength { return nil }
+    _taken += 1
+
+    if let next = _iterator.next() {
+      return next
+    }
+
+    _taken = _maxLength
+    return nil
+  }
+
+  @_versioned
+  @_inlineable
+  internal func prefix(_ maxLength: Int) -> AnySequence<Base.Element> {
+    return AnySequence(
+      _PrefixSequence(
+        _iterator: _iterator,
+        maxLength: Swift.min(maxLength, self._maxLength),
+        taken: _taken))
+  }
+}