[stdlib] Collapse DropWhileBidirectionalCollection and de-gyb DropWhile.swift (swiftlang#14906)

Collapse DropWhileBidirectionalCollection and de-gyb DropWhile.swift

Author: airspeedswift

stdlib/public/core/CMakeLists.txt

@@ -48,7 +48,7 @@ set(SWIFTLIB_ESSENTIAL
   CTypes.swift
   DebuggerSupport.swift
   DoubleWidth.swift.gyb
-  DropWhile.swift.gyb
+  DropWhile.swift
   Dump.swift
   EmptyCollection.swift
   Equatable.swift

stdlib/public/core/DropWhile.swift.gyb renamed to stdlib/public/core/DropWhile.swift

@@ -1,4 +1,4 @@
-//===--- DropWhile.swift.gyb - Lazy views for drop(while:) ----*- swift -*-===//
+//===--- DropWhile.swift - Lazy views for drop(while:) --------*- swift -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,27 +10,57 @@
 //
 //===----------------------------------------------------------------------===//
 
-%{
-from gyb_stdlib_support import (
-    TRAVERSALS,
-    collectionForTraversal
-)
-}%
+/// A sequence whose elements consist of the elements that follow the initial
+/// consecutive elements of some base sequence that satisfy a given predicate.
+@_fixed_layout // FIXME(sil-serialize-all)
+public struct LazyDropWhileSequence<Base: Sequence> {
+  public typealias Element = Base.Element
+  
+  /// Create an instance with elements `transform(x)` for each element
+  /// `x` of base.
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal init(_base: Base, predicate: @escaping (Element) -> Bool) {
+    self._base = _base
+    self._predicate = predicate
+  }
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var _base: Base
+  @_versioned // FIXME(sil-serialize-all)
+  internal let _predicate: (Element) -> Bool
+}
 
-//===--- Iterator & Sequence ----------------------------------------------===//
+extension LazyDropWhileSequence {
+  /// An iterator over the elements traversed by a base iterator that follow the
+  /// initial consecutive elements that satisfy a given predicate.
+  ///
+  /// This is the associated iterator for the `LazyDropWhileSequence`,
+  /// `LazyDropWhileCollection`, and `LazyDropWhileBidirectionalCollection`
+  /// types.
+  @_fixed_layout // FIXME(sil-serialize-all)
+  public struct Iterator {
+    public typealias Element = Base.Element
+    
+    @_inlineable // FIXME(sil-serialize-all)
+    @_versioned // FIXME(sil-serialize-all)
+    internal init(_base: Base.Iterator, predicate: @escaping (Element) -> Bool) {
+      self._base = _base
+      self._predicate = predicate
+    }
 
-/// An iterator over the elements traversed by a base iterator that follow the
-/// initial consecutive elements that satisfy a given predicate.
-///
-/// This is the associated iterator for the `LazyDropWhileSequence`,
-/// `LazyDropWhileCollection`, and `LazyDropWhileBidirectionalCollection`
-/// types.
-@_fixed_layout // FIXME(sil-serialize-all)
-public struct LazyDropWhileIterator<Base : IteratorProtocol> :
-  IteratorProtocol, Sequence {
+    @_versioned // FIXME(sil-serialize-all)
+    internal var _predicateHasFailed = false
+    @_versioned // FIXME(sil-serialize-all)
+    internal var _base: Base.Iterator
+    @_versioned // FIXME(sil-serialize-all)
+    internal let _predicate: (Element) -> Bool
+  }
+}
 
+extension LazyDropWhileSequence.Iterator: IteratorProtocol {
   @_inlineable // FIXME(sil-serialize-all)
-  public mutating func next() -> Base.Element? {
+  public mutating func next() -> Element? {
     // Once the predicate has failed for the first time, the base iterator
     // can be used for the rest of the elements.
     if _predicateHasFailed {
@@ -46,52 +76,23 @@ public struct LazyDropWhileIterator<Base : IteratorProtocol> :
       }
     }
     return nil
-  }
-
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned // FIXME(sil-serialize-all)
-  internal init(_base: Base, predicate: @escaping (Base.Element) -> Bool) {
-    self._base = _base
-    self._predicate = predicate
-  }
-
-  @_versioned // FIXME(sil-serialize-all)
-  internal var _predicateHasFailed = false
-  @_versioned // FIXME(sil-serialize-all)
-  internal var _base: Base
-  @_versioned // FIXME(sil-serialize-all)
-  internal let _predicate: (Base.Element) -> Bool
+  }  
 }
 
-/// A sequence whose elements consist of the elements that follow the initial
-/// consecutive elements of some base sequence that satisfy a given predicate.
-@_fixed_layout // FIXME(sil-serialize-all)
-public struct LazyDropWhileSequence<Base : Sequence> : LazySequenceProtocol {
-
-  public typealias Elements = LazyDropWhileSequence
+extension LazyDropWhileSequence: Sequence {
+  public typealias SubSequence = AnySequence<Element> // >:(
 
   /// Returns an iterator over the elements of this sequence.
   ///
   /// - Complexity: O(1).
   @_inlineable // FIXME(sil-serialize-all)
-  public func makeIterator() -> LazyDropWhileIterator<Base.Iterator> {
-    return LazyDropWhileIterator(
-      _base: _base.makeIterator(), predicate: _predicate)
-  }
-
-  /// Create an instance with elements `transform(x)` for each element
-  /// `x` of base.
-  @_inlineable // FIXME(sil-serialize-all)
-  @_versioned // FIXME(sil-serialize-all)
-  internal init(_base: Base, predicate: @escaping (Base.Element) -> Bool) {
-    self._base = _base
-    self._predicate = predicate
+  public func makeIterator() -> Iterator {
+    return Iterator(_base: _base.makeIterator(), predicate: _predicate)
   }
+}
 
-  @_versioned // FIXME(sil-serialize-all)
-  internal var _base: Base
-  @_versioned // FIXME(sil-serialize-all)
-  internal let _predicate: (Base.Element) -> Bool
+extension LazyDropWhileSequence: LazySequenceProtocol {
+  public typealias Elements = LazyDropWhileSequence
 }
 
 extension LazySequenceProtocol {
@@ -110,125 +111,127 @@ extension LazySequenceProtocol {
   }
 }
 
-//===--- Collections ------------------------------------------------------===//
-
-/// A position in a `LazyDropWhileCollection` or
-/// `LazyDropWhileBidirectionalCollection` instance.
+/// A lazy wrapper that includes the elements of an underlying
+/// collection after any initial consecutive elements that satisfy a
+/// predicate.
+///
+/// - Note: The performance of accessing `startIndex`, `first`, or any methods
+///   that depend on `startIndex` depends on how many elements satisfy the
+///   predicate at the start of the collection, and may not offer the usual
+///   performance given by the `Collection` protocol. Be aware, therefore,
+///   that general operations on lazy collections may not have the
+///   documented complexity.
 @_fixed_layout // FIXME(sil-serialize-all)
-public struct LazyDropWhileIndex<Base : Collection> : Comparable {
-  /// The position corresponding to `self` in the underlying collection.
-  public let base: Base.Index
-
+public struct LazyDropWhileCollection<Base: Collection> {
+  public typealias Element = Base.Element
+  
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)
-  internal init(base: Base.Index) {
-    self.base = base
+  internal init(_base: Base, predicate: @escaping (Element) -> Bool) {
+    self._base = _base
+    self._predicate = predicate
+  }
+
+  @_versioned // FIXME(sil-serialize-all)
+  internal var _base: Base
+  @_versioned // FIXME(sil-serialize-all)
+  internal let _predicate: (Element) -> Bool
+}
+
+extension LazyDropWhileCollection: Sequence {
+  public typealias Iterator = LazyDropWhileSequence<Base>.Iterator
+  
+  /// Returns an iterator over the elements of this sequence.
+  ///
+  /// - Complexity: O(1).
+  @_inlineable // FIXME(sil-serialize-all)
+  public func makeIterator() -> Iterator {
+    return Iterator(_base: _base.makeIterator(), predicate: _predicate)
+  }
+}
+
+extension LazyDropWhileCollection {
+  public typealias SubSequence = Slice<LazyDropWhileCollection<Base>>
+
+  /// A position in a `LazyDropWhileCollection` or
+  /// `LazyDropWhileBidirectionalCollection` instance.
+  @_fixed_layout // FIXME(sil-serialize-all)
+  public struct Index {
+    /// The position corresponding to `self` in the underlying collection.
+    public let base: Base.Index
+
+    @_inlineable // FIXME(sil-serialize-all)
+    @_versioned // FIXME(sil-serialize-all)
+    internal init(_base: Base.Index) {
+      self.base = _base
+    }
   }
+}
 
+extension LazyDropWhileCollection.Index: Equatable, Comparable {
   @_inlineable // FIXME(sil-serialize-all)
   public static func == (
-    lhs: LazyDropWhileIndex, rhs: LazyDropWhileIndex
+    lhs: LazyDropWhileCollection<Base>.Index,
+    rhs: LazyDropWhileCollection<Base>.Index
   ) -> Bool {
     return lhs.base == rhs.base
   }
 
   @_inlineable // FIXME(sil-serialize-all)
   public static func < (
-    lhs: LazyDropWhileIndex, rhs: LazyDropWhileIndex
+    lhs: LazyDropWhileCollection<Base>.Index,
+    rhs: LazyDropWhileCollection<Base>.Index
   ) -> Bool {
     return lhs.base < rhs.base
   }
 }
 
-extension LazyDropWhileIndex : Hashable where Base.Index : Hashable {
+extension LazyDropWhileCollection.Index: Hashable where Base.Index: Hashable {
   public var hashValue: Int {
     return base.hashValue
   }
 }
 
-% for Traversal in ['Forward', 'Bidirectional']:
-%   Collection = collectionForTraversal(Traversal)
-%   Self = "LazyDropWhile" + Collection
-
-/// A lazy `${Collection}` wrapper that includes the elements of an underlying
-/// collection after any initial consecutive elements that satisfy a
-/// predicate.
-///
-/// - Note: The performance of accessing `startIndex`, `first`, or any methods
-///   that depend on `startIndex` depends on how many elements satisfy the
-///   predicate at the start of the collection, and may not offer the usual
-///   performance given by the `Collection` protocol. Be aware, therefore,
-///   that general operations on `${Self}` instances may not have the
-///   documented complexity.
-@_fixed_layout // FIXME(sil-serialize-all)
-public struct ${Self}<
-  Base : ${Collection}
-> : LazyCollectionProtocol, ${Collection} {
-
-  // FIXME(compiler limitation): should be inferable.
-  public typealias Index = LazyDropWhileIndex<Base>
-
+extension LazyDropWhileCollection: Collection {
   @_inlineable // FIXME(sil-serialize-all)
   public var startIndex: Index {
     var index = _base.startIndex
     while index != _base.endIndex && _predicate(_base[index]) {
       _base.formIndex(after: &index)
     }
-    return LazyDropWhileIndex(base: index)
+    return Index(_base: index)
   }
 
   @_inlineable // FIXME(sil-serialize-all)
   public var endIndex: Index {
-    return LazyDropWhileIndex(base: _base.endIndex)
+    return Index(_base: _base.endIndex)
   }
 
   @_inlineable // FIXME(sil-serialize-all)
   public func index(after i: Index) -> Index {
     _precondition(i.base < _base.endIndex, "Can't advance past endIndex")
-    return LazyDropWhileIndex(base: _base.index(after: i.base))
+    return Index(_base: _base.index(after: i.base))
   }
 
-%   if Traversal == 'Bidirectional':
 
   @_inlineable // FIXME(sil-serialize-all)
-  public func index(before i: Index) -> Index {
-    _precondition(i > startIndex, "Can't move before startIndex")
-    return LazyDropWhileIndex(base: _base.index(before: i.base))
-  }
-
-%   end
-
-  @_inlineable // FIXME(sil-serialize-all)
-  public subscript(position: Index) -> Base.Element {
+  public subscript(position: Index) -> Element {
     return _base[position.base]
   }
+}
 
-  @_inlineable // FIXME(sil-serialize-all)
-  public func makeIterator() -> LazyDropWhileIterator<Base.Iterator> {
-    return LazyDropWhileIterator(
-      _base: _base.makeIterator(), predicate: _predicate)
-  }
+extension LazyDropWhileCollection: LazyCollectionProtocol { }
 
+extension LazyDropWhileCollection: BidirectionalCollection 
+where Base: BidirectionalCollection {
   @_inlineable // FIXME(sil-serialize-all)
-  @_versioned // FIXME(sil-serialize-all)
-  internal init(_base: Base, predicate: @escaping (Base.Element) -> Bool) {
-    self._base = _base
-    self._predicate = predicate
+  public func index(before i: Index) -> Index {
+    _precondition(i > startIndex, "Can't move before startIndex")
+    return Index(_base: _base.index(before: i.base))
   }
-
-  @_versioned // FIXME(sil-serialize-all)
-  internal var _base: Base
-  @_versioned // FIXME(sil-serialize-all)
-  internal let _predicate: (Base.Element) -> Bool
 }
 
-extension LazyCollectionProtocol
-%   if Collection != 'Collection':
-  where
-  Self : ${Collection},
-Elements : ${Collection}
-%   end
-{
+extension LazyCollectionProtocol {
   /// Returns a lazy collection that skips any initial elements that satisfy
   /// `predicate`.
   ///
@@ -239,14 +242,16 @@ Elements : ${Collection}
   @_inlineable // FIXME(sil-serialize-all)
   public func drop(
     while predicate: @escaping (Elements.Element) -> Bool
-  ) -> LazyDropWhile${Collection}<Self.Elements> {
-    return LazyDropWhile${Collection}(
+  ) -> LazyDropWhileCollection<Self.Elements> {
+    return LazyDropWhileCollection(
       _base: self.elements, predicate: predicate)
   }
 }
 
-% end
+@available(*, deprecated, renamed: "LazyDropWhileSequence.Iterator")
+public typealias LazyDropWhileIterator<T> = LazyDropWhileSequence<T>.Iterator where T: Sequence
+@available(*, deprecated, renamed: "LazyDropWhileCollection.Index")
+public typealias LazyDropWhileIndex<T> = LazyDropWhileCollection<T>.Index where T: Collection
+@available(*, deprecated, renamed: "LazyDropWhileCollection")
+public typealias LazyDropWhileBidirectionalCollection<T> = LazyDropWhileCollection<T> where T: BidirectionalCollection
 
-// ${'Local Variables'}:
-// eval: (read-only-mode 1)
-// End:

stdlib/public/core/PrefixWhile.swift

@@ -74,6 +74,8 @@ extension LazyPrefixWhileSequence.Iterator: IteratorProtocol, Sequence {
 }
 
 extension LazyPrefixWhileSequence: Sequence {
+  public typealias SubSequence = AnySequence<Element> // >:(
+  
   @_inlineable // FIXME(sil-serialize-all)
   public func makeIterator() -> Iterator {
     return Iterator(_base: _base.makeIterator(), predicate: _predicate)
@@ -112,6 +114,7 @@ extension LazySequenceProtocol {
 @_fixed_layout // FIXME(sil-serialize-all)
 public struct LazyPrefixWhileCollection<Base: Collection> {
   public typealias Element = Base.Element
+  public typealias SubSequence = Slice<LazyPrefixWhileCollection<Base>>
 
   @_inlineable // FIXME(sil-serialize-all)
   @_versioned // FIXME(sil-serialize-all)