[stdlib] filter(x) never creates a Collection

It's both more rigorously correct and should prevent surprise when
constructing an Array from a filtered sequence.  See the comments
in-code for details.

Swift SVN r19304

Author: Dave Abrahams

stdlib/core/Filter.swift

@@ -68,11 +68,29 @@
   return lhs._pos == rhs._pos
 }
 
-/// The lazy `Collection` returned by `filter(c)` where `c` is a
-/// `Collection`
+/// A lazy `Collection` wrapper that includes the elements of an
+/// underlying collection that satisfy a predicate.  Not
+/// automatically returned by `filter(x)` for two reasons:
+///
+/// * The O(1) guarantee of our `IndexType` would be iffy at best, since
+///   it advances an underlying `Index` until the predicate is
+///   satisfied.  Be aware that a `FilterCollectionView` may not offer
+///   the expected efficiency for this reason.
+///
+/// * Constructing an `Array` from a `Collection` measures the length
+///   of the collection before traversing it to read the elements.
+///   This causes the filter predicate to be called twice for each
+///   element of the underlying collection, which is surprising.
 @public struct FilterCollectionView<Base: Collection> : Collection {
 
   @public typealias IndexType = FilterCollectionViewIndex<Base>
+
+  @public
+  init(_ base: Base, includeElement: (Base.GeneratorType.Element)->Bool) {
+    self._base = base
+    self._include = includeElement
+  }
+
   @public var startIndex: IndexType {
     var first = _base.startIndex
     while first != _base.endIndex {
@@ -111,10 +129,15 @@
   return FilterSequenceView(_base: source, _include: includeElement)
 }
 
+/*
+// No overload for collections; see the comment on
+// FilterCollectionView for an explanation.
+
 /// Return a lazy Collection containing the elements `x` of `source` for
 /// which `includeElement(x)` is `true`
 @public func filter<C:Collection>(
   source: C, includeElement: (C.GeneratorType.Element)->Bool
 ) -> FilterCollectionView<C> {
   return FilterCollectionView(_base: source, _include: includeElement)
 }
+*/

test/stdlib/Filter.swift

@@ -32,7 +32,7 @@ func printlnByIndexing<C: Collection>(c: C) {
 
 // Test filtering Collections
 if true {
-  let f0 = filter(0..<30) { $0 % 7 == 0 }
+  let f0 = FilterCollectionView(0..<30) { $0 % 7 == 0 }
 
   // CHECK-NEXT: <0, 7, 14, 21, 28>
   printlnByGenerating(f0)
@@ -41,7 +41,7 @@ if true {
 
   // Also try when the first element of the underlying sequence
   // doesn't pass the filter
-  let f1 = filter(1..<30) { $0 % 7 == 0 }
+  let f1 = FilterCollectionView(1..<30) { $0 % 7 == 0 }
 
   // CHECK-NEXT: <7, 14, 21, 28>
   printlnByGenerating(f1)