[stdlib] Conditional conformances for LazyFilterCollection

Author: Max Moiseev

benchmark/single-source/LazyFilter.swift

@@ -47,7 +47,7 @@ public func run_LazilyFilteredArrays(_ N: Int) {
   CheckResults(res == 123)
 }
 
-fileprivate var multiplesOfThree: LazyFilterBidirectionalCollection<Array<Int>>?
+fileprivate var multiplesOfThree: LazyFilterCollection<Array<Int>>?
 
 fileprivate func setup_LazilyFilteredArrayContains() {
   multiplesOfThree = Array(1..<5_000).lazy.filter { $0 % 3 == 0 }

stdlib/public/core/CMakeLists.txt

@@ -54,7 +54,7 @@ set(SWIFTLIB_ESSENTIAL
   Equatable.swift
   ErrorType.swift
   Existential.swift
-  Filter.swift.gyb
+  Filter.swift
   FixedArray.swift.gyb
   FlatMap.swift
   Flatten.swift.gyb

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

@@ -1,4 +1,4 @@
-//===--- Filter.swift.gyb -------------------------------------*- swift -*-===//
+//===--- Filter.swift -----------------------------------------*- swift -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,12 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-%{
-from gyb_stdlib_support import (
-    collectionForTraversal
-)
-}%
-
 /// An iterator over the elements traversed by some base iterator that also
 /// satisfy a given predicate.
 ///
@@ -122,14 +116,6 @@ public struct LazyFilterSequence<Base : Sequence>
 @available(swift, deprecated: 3.1, obsoleted: 4.0, message: "Use Base.Index")
 public typealias LazyFilterIndex<Base : Collection> = Base.Index
 
-// FIXME(ABI)#27 (Conditional Conformance): `LazyFilter*Collection` types should be
-// collapsed into one `LazyFilterCollection` using conditional conformances.
-// Maybe even combined with `LazyFilterSequence`.
-// rdar://problem/17144340
-
-% for Traversal in ['Forward', 'Bidirectional']:
-%   Self = "LazyFilter" + collectionForTraversal(Traversal)
-
 /// A lazy `Collection` wrapper that includes the elements of an
 /// underlying collection that satisfy a predicate.
 ///
@@ -140,16 +126,16 @@ public typealias LazyFilterIndex<Base : Collection> = Base.Index
 ///   general operations on `LazyFilterCollection` instances may not have the
 ///   documented complexity.
 @_fixed_layout // FIXME(sil-serialize-all)
-public struct ${Self}<
-  Base : ${collectionForTraversal(Traversal)}
-> : LazyCollectionProtocol, ${collectionForTraversal(Traversal)}
-{
+public struct LazyFilterCollection<
+  Base : Collection
+> : LazyCollectionProtocol, Collection {
 
   /// A type that represents a valid position in the collection.
   ///
   /// Valid indices consist of the position of every element and a
   /// "past the end" position that's not valid for use as a subscript.
   public typealias Index = Base.Index
+  public typealias Element = Base.Element
 
 
   /// Creates an instance containing the elements of `base` that
@@ -221,26 +207,6 @@ public struct ${Self}<
     i = index
   }
 
-%   if Traversal == 'Bidirectional':
-  @_inlineable // FIXME(sil-serialize-all)
-  public func index(before i: Index) -> Index {
-    var i = i
-    formIndex(before: &i)
-    return i
-  }
-
-  @_inlineable // FIXME(sil-serialize-all)
-  public func formIndex(before i: inout Index) {
-    // TODO: swift-3-indexing-model: _failEarlyRangeCheck i?
-    var index = i
-    _precondition(index != _base.startIndex, "Can't retreat before startIndex")
-    repeat {
-      _base.formIndex(before: &index)
-    } while !_predicate(_base[index])
-    i = index
-  }
-%   end
-
   /// Accesses the element at `position`.
   ///
   /// - Precondition: `position` is a valid position in `self` and
@@ -250,7 +216,7 @@ public struct ${Self}<
     return _base[position]
   }
 
-  public typealias SubSequence = ${Self}<Base.SubSequence>
+  public typealias SubSequence = LazyFilterCollection<Base.SubSequence>
 
   @_inlineable // FIXME(sil-serialize-all)
   public subscript(bounds: Range<Index>) -> SubSequence {
@@ -290,7 +256,27 @@ public struct ${Self}<
   internal let _predicate: (Base.Element) -> Bool
 }
 
-% end
+extension LazyFilterCollection : BidirectionalCollection
+  where Base : BidirectionalCollection {
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func index(before i: Index) -> Index {
+    var i = i
+    formIndex(before: &i)
+    return i
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func formIndex(before i: inout Index) {
+    // TODO: swift-3-indexing-model: _failEarlyRangeCheck i?
+    var index = i
+    _precondition(index != _base.startIndex, "Can't retreat before startIndex")
+    repeat {
+      _base.formIndex(before: &index)
+    } while !_predicate(_base[index])
+    i = index
+  }
+}
 
 extension LazySequenceProtocol {
   /// Returns the elements of `self` that satisfy `isIncluded`.
@@ -303,20 +289,11 @@ extension LazySequenceProtocol {
   public func filter(
     _ isIncluded: @escaping (Elements.Element) -> Bool
   ) -> LazyFilterSequence<Self.Elements> {
-    return LazyFilterSequence(
-      _base: self.elements, isIncluded)
+    return LazyFilterSequence(_base: self.elements, isIncluded)
   }
 }
 
-% for Traversal in ['Forward', 'Bidirectional']:
-
-extension LazyCollectionProtocol
-%   if Traversal != 'Forward':
-  where
-  Self : ${collectionForTraversal(Traversal)},
-  Elements : ${collectionForTraversal(Traversal)}
-%   end
-{
+extension LazyCollectionProtocol {
   /// Returns the elements of `self` that satisfy `predicate`.
   ///
   /// - Note: The elements of the result are computed on-demand, as
@@ -326,14 +303,10 @@ extension LazyCollectionProtocol
   @_inlineable // FIXME(sil-serialize-all)
   public func filter(
     _ isIncluded: @escaping (Elements.Element) -> Bool
-  ) -> LazyFilter${collectionForTraversal(Traversal)}<Self.Elements> {
-    return LazyFilter${collectionForTraversal(Traversal)}(
-      _base: self.elements, isIncluded)
+  ) -> LazyFilterCollection<Self.Elements> {
+    return LazyFilterCollection(_base: self.elements, isIncluded)
   }
 }
 
-% end
-
-// ${'Local Variables'}:
-// eval: (read-only-mode 1)
-// End:
+@available(*, deprecated, renamed: "LazyFilterCollection")
+public typealias LazyFilterBidirectionalCollection<T> = LazyFilterCollection<T> where T : BidirectionalCollection

stdlib/public/core/FlatMap.swift

@@ -129,7 +129,7 @@ extension LazyCollectionProtocol
   public func flatMap<ElementOfResult>(
     _ transform: @escaping (Elements.Element) -> ElementOfResult?
   ) -> LazyMapBidirectionalCollection<
-    LazyFilterBidirectionalCollection<
+    LazyFilterCollection<
       LazyMapBidirectionalCollection<Elements, ElementOfResult?>>,
     ElementOfResult
   > {

stdlib/public/core/Reverse.swift

@@ -312,7 +312,7 @@ extension LazyCollectionProtocol
   ///
   /// - Complexity: O(1)
   @_inlineable
-  public func reversed() -> LazyBidirectionalCollection<
+  public func reversed() -> LazyCollection<
     ReversedCollection<Elements>
   > {
     return ReversedCollection(_base: elements).lazy

validation-test/stdlib/Lazy.swift.gyb

@@ -1167,11 +1167,11 @@ tests.test("LazyFilterCollection/AssociatedTypes") {
 
 tests.test("LazyFilterBidirectionalCollection/AssociatedTypes") {
   typealias Base = MinimalBidirectionalCollection<OpaqueValue<Int>>
-  typealias Subject = LazyFilterBidirectionalCollection<Base>
+  typealias Subject = LazyFilterCollection<Base>
   expectBidirectionalCollectionAssociatedTypes(
     collectionType: Subject.self,
     iteratorType: LazyFilterIterator<Base.Iterator>.self,
-    subSequenceType: LazyFilterBidirectionalCollection<Base.SubSequence>.self,
+    subSequenceType: LazyFilterCollection<Base.SubSequence>.self,
     indexType: LazyFilterIndex<Base>.self,
     indicesType: DefaultBidirectionalIndices<Subject>.self)
 }
@@ -1196,7 +1196,7 @@ tests.test("lazy.filter/TypeInference") {
     var filtered = MinimalBidirectionalCollection(elements: baseArray)
       .lazy.filter { _ in true }
     expectType(
-      LazyFilterBidirectionalCollection<
+      LazyFilterCollection<
         MinimalBidirectionalCollection<OpaqueValue<Int>>
       >.self,
       &filtered)
@@ -1205,7 +1205,7 @@ tests.test("lazy.filter/TypeInference") {
     var filtered = MinimalRandomAccessCollection(elements: baseArray)
       .lazy.filter { _ in true }
     expectType(
-      LazyFilterBidirectionalCollection<
+      LazyFilterCollection<
         MinimalRandomAccessCollection<OpaqueValue<Int>>
       >.self,
       &filtered)