add count(where:) and tests

Author: khanlou

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -140,6 +140,25 @@ public struct FilterTest {
   }
 }
 
+public struct PredicateCountTest {
+  public let expected: Int
+  public let sequence: [Int]
+  public let includeElement: (Int) -> Bool
+  public let loc: SourceLoc
+
+  public init(
+    _ expected: Int,
+    _ sequence: [Int],
+    _ includeElement: @escaping (Int) -> Bool,
+    file: String = #file, line: UInt = #line
+  ) {
+    self.expected = expected
+    self.sequence = sequence
+    self.includeElement = includeElement
+    self.loc = SourceLoc(file, line, comment: "test data")
+  }
+}
+
 public struct FindTest {
   public let expected: Int?
   public let element: MinimalEquatableValue
@@ -522,6 +541,21 @@ public let filterTests = [
   ),
 ]
 
+public let predicateCountTests = [
+  PredicateCountTest(
+    0, [],
+    { _ -> Bool in expectUnreachable(); return true }),
+
+  PredicateCountTest(0, [ 0, 30, 10, 90 ], { _ -> Bool in false }),
+  PredicateCountTest(
+    4, [ 0, 30, 10, 90 ], { _ -> Bool in true }
+  ),
+  PredicateCountTest(
+    3, [ 0, 30, 10, 90 ], { (x: Int) -> Bool in x % 3 == 0 }
+  ),
+]
+
+
 public let findTests = [
   FindTest(
     expected: nil,

stdlib/public/core/SequenceAlgorithms.swift

@@ -516,6 +516,52 @@ extension Sequence where Element : Equatable {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// count(where:)
+//===----------------------------------------------------------------------===//
+
+extension Sequence {
+  /// Returns a Int value indicating how many elements in the sequence
+  /// satisfy the given predicate.
+  ///
+  /// You can use the predicate to check for an element of a type that
+  /// doesn't conform to the `Equatable` protocol, such as the
+  /// `HTTPResponse` enumeration in this example.
+  ///
+  ///     enum HTTPResponse {
+  ///         case ok
+  ///         case error(Int)
+  ///     }
+  ///
+  ///     let responses: [HTTPResponse] = [.ok, .error(500), .error(404)]
+  ///     let numberOfErrors = responses.count { element in
+  ///         if case .error = element {
+  ///             return true
+  ///         } else {
+  ///             return false
+  ///         }
+  ///     }
+  ///     // 'numberOfErrors' == 2
+  ///
+  /// - Parameter predicate: A closure that takes an element of the sequence
+  ///   as its argument and returns a Boolean value that indicates whether
+  ///   the passed element should be included in the count.
+  /// - Returns: a value indicating how many elements in the sequence
+  ///   satisfy the given predicate.
+  @inlinable
+  public func count(
+    where predicate: (Element) throws -> Bool
+  ) rethrows -> Int {
+    var count = 0
+    for e in self {
+      if try predicate(e) {
+        count += 1
+      }
+    }
+    return count
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // reduce()
 //===----------------------------------------------------------------------===//

validation-test/stdlib/SequenceType.swift.gyb

@@ -614,6 +614,21 @@ SequenceTypeTests.test("contains/Predicate") {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// count(where:)
+//===----------------------------------------------------------------------===//
+
+SequenceTypeTests.test("count/Predicate") {
+  for test in predicateCountTests {
+    let s = MinimalSequence<OpaqueValue<Int>>(
+      elements: test.sequence.map { OpaqueValue($0) })
+    expectEqual(
+      test.expected,
+      s.count(where: { test.includeElement($0.value) }),
+      stackTrace: SourceLocStack().with(test.loc))
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // reduce()
 //===----------------------------------------------------------------------===//