isEquivalent: => comparingBy areEquivalent:

fixup! isEquivalent: => testingEquivalenceWith predicate:

Author: Dave Abrahams

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2191,7 +2191,7 @@ public func expectEqualSequence<
 ) where
   Expected.Iterator.Element == Actual.Iterator.Element {
 
-  if !expected.elementsEqual(actual, isEquivalent: sameValue) {
+  if !expected.elementsEqual(actual, comparingBy: sameValue) {
     expectationFailure("expected elements: \"\(expected)\"\n"
       + "actual: \"\(actual)\" (of type \(String(reflecting: actual.dynamicType)))",
       trace: ${trace})

stdlib/public/core/SequenceAlgorithms.swift.gyb

@@ -36,10 +36,10 @@ equivalenceExplanation = """\
   /// is, for any elements `a`, `b`, and `c`, the following conditions must
   /// hold:
   ///
-  /// - `isEquivalent(a, a)` is always `true`. (Reflexivity)
-  /// - `isEquivalent(a, b)` implies `isEquivalent(b, a)`. (Symmetry)
-  /// - If `isEquivalent(a, b)` and `isEquivalent(b, c)` are both `true`, then
-  ///   `isEquivalent(a, c)` is also `true`. (Transitivity)
+  /// - `areEquivalent(a, a)` is always `true`. (Reflexivity)
+  /// - `areEquivalent(a, b)` implies `areEquivalent(b, a)`. (Symmetry)
+  /// - If `areEquivalent(a, b)` and `areEquivalent(b, c)` are both `true`, then
+  ///   `areEquivalent(a, c)` is also `true`. (Transitivity)
   ///"""
 
 }%
@@ -209,7 +209,7 @@ extension Sequence ${"" if preds else "where Iterator.Element : Equatable"} {
 ${equivalenceExplanation}
   /// - Parameters:
   ///   - possiblePrefix: A sequence to compare to this sequence.
-  ///   - isEquivalent: A predicate that returns `true` if its two arguments
+  ///   - areEquivalent: A predicate that returns `true` if its two arguments
   ///     are equivalent; otherwise, `false`.
   /// - Returns: `true` if the initial elements of the sequence are equivalent
   ///   to the elements of `possiblePrefix`; otherwise, `false`. Returns
@@ -235,12 +235,12 @@ ${equivalenceExplanation}
   ///   the elements of `possiblePrefix`; otherwise, `false`. Returns `true`
   ///   if `possiblePrefix` has no elements.
   ///
-  /// - SeeAlso: `starts(with:isEquivalent:)`
+  /// - SeeAlso: `starts(with:comparingBy:)`
 %   end
   public func starts<PossiblePrefix>(
     with possiblePrefix: PossiblePrefix${"," if preds else ""}
 %   if preds:
-    isEquivalent: @noescape (${GElement}, ${GElement}) throws -> Bool
+    comparingBy areEquivalent: @noescape (${GElement}, ${GElement}) throws -> Bool
 %   end
   ) ${rethrows_}-> Bool
     where
@@ -250,7 +250,7 @@ ${equivalenceExplanation}
     var possiblePrefixIterator = possiblePrefix.makeIterator()
     for e0 in self {
       if let e1 = possiblePrefixIterator.next() {
-        if ${"try !isEquivalent(e0, e1)" if preds else "e0 != e1"} {
+        if ${"try !areEquivalent(e0, e1)" if preds else "e0 != e1"} {
           return false
         }
       }
@@ -285,10 +285,10 @@ extension Sequence ${"" if preds else "where Iterator.Element : Equatable"} {
 ${equivalenceExplanation}
   /// - Parameters:
   ///   - other: A sequence to compare to this sequence.
-  ///   - isEquivalent: A predicate that returns `true` if its two arguments
+  ///   - areEquivalent: A predicate that returns `true` if its two arguments
   ///     are equivalent; otherwise, `false`.
   /// - Returns: `true` if this sequence and `other` contain equivalent items,
-  ///   using `isEquivalent` as the equivalence test; otherwise, `false.`
+  ///   using `areEquivalent` as the equivalence test; otherwise, `false.`
   ///
   /// - SeeAlso: `elementsEqual(_:)`
 %   else:
@@ -311,12 +311,12 @@ ${equivalenceExplanation}
   /// - Returns: `true` if this sequence and `other` contain the same elements
   ///   in the same order.
   ///
-  /// - SeeAlso: `elementsEqual(_:isEquivalent:)`
+  /// - SeeAlso: `elementsEqual(_:comparingBy:)`
 %   end
   public func elementsEqual<OtherSequence>(
     _ other: OtherSequence${"," if preds else ""}
 %   if preds:
-    isEquivalent: @noescape (${GElement}, ${GElement}) throws -> Bool
+    comparingBy areEquivalent: @noescape (${GElement}, ${GElement}) throws -> Bool
 %   end
   ) ${rethrows_}-> Bool
     where
@@ -328,7 +328,7 @@ ${equivalenceExplanation}
     while true {
       switch (iter1.next(), iter2.next()) {
       case let (e1?, e2?):
-        if ${'try !isEquivalent(e1, e2)' if preds else 'e1 != e2'} {
+        if ${'try !areEquivalent(e1, e2)' if preds else 'e1 != e2'} {
           return false
         }
       case (_?, nil),
@@ -692,9 +692,9 @@ extension Sequence {
     Builtin.unreachable()
   }
 
-  @available(*, unavailable, renamed: "starts")
+  @available(*, unavailable, renamed: "starts(with:comparingBy:)")
   public func startsWith<PossiblePrefix>(
-    with possiblePrefix: PossiblePrefix,
+    _ possiblePrefix: PossiblePrefix,
     isEquivalent: @noescape (Iterator.Element, Iterator.Element) throws -> Bool
   ) rethrows-> Bool
     where
@@ -728,9 +728,9 @@ extension Sequence where Iterator.Element : Comparable {
     Builtin.unreachable()
   }
 
-  @available(*, unavailable, renamed: "starts")
+  @available(*, unavailable, renamed: "starts(with:)")
   public func startsWith<PossiblePrefix>(
-    with possiblePrefix: PossiblePrefix
+    _ possiblePrefix: PossiblePrefix
   ) -> Bool
     where
     PossiblePrefix : Sequence,

test/1_stdlib/StringAPI.swift

@@ -240,10 +240,10 @@ func checkHasPrefixHasSuffix(
       Array(String($0).unicodeScalars)
     }
   let expectHasPrefix = lhsNFDGraphemeClusters.starts(
-    with: rhsNFDGraphemeClusters, isEquivalent: (==))
+    with: rhsNFDGraphemeClusters, comparingBy: (==))
 
   let expectHasSuffix = lhsNFDGraphemeClusters.lazy.reversed()
-    .starts(with: rhsNFDGraphemeClusters.lazy.reversed(), isEquivalent: (==))
+    .starts(with: rhsNFDGraphemeClusters.lazy.reversed(), comparingBy: (==))
 
   expectEqual(expectHasPrefix, lhs.hasPrefix(rhs), stackTrace: stackTrace)
   expectEqual(
@@ -411,7 +411,7 @@ CStringTests.test("String(cString:)") {
 CStringTests.test("String.decodeCString") {
   do {
     let s = getNullCString()
-    let result = String.decodeCString(UnsafePointer(s), `as`: UTF8.self)
+    let result = String.decodeCString(UnsafePointer(s), as: UTF8.self)
     expectEmpty(result)
   }
   do { // repairing

test/IDE/complete_from_stdlib.swift

@@ -166,7 +166,7 @@ func testArchetypeReplacement3 (_ a : [Int]) {
 // PRIVATE_NOMINAL_MEMBERS_7-DAG: Decl[InstanceMethod]/Super:         dropLast({#(n): Int#})[#ArraySlice<Int>#]
 // PRIVATE_NOMINAL_MEMBERS_7-DAG: Decl[InstanceMethod]/Super:         dropFirst({#(n): Int#})[#AnySequence<Int>#]
 // PRIVATE_NOMINAL_MEMBERS_7-DAG: Decl[InstanceMethod]/Super:         prefix({#(maxLength): Int#})[#AnySequence<Int>#]
-// PRIVATE_NOMINAL_MEMBERS_7-DAG: Decl[InstanceMethod]/Super:         elementsEqual({#(other): Sequence#}, {#isEquivalent: (Int, Int) throws -> Bool##(Int, Int) throws -> Bool#})[' rethrows'][#Bool#]
+// PRIVATE_NOMINAL_MEMBERS_7-DAG: Decl[InstanceMethod]/Super:         elementsEqual({#(other): Sequence#}, {#comparingBy: (Int, Int) throws -> Bool##(Int, Int) throws -> Bool#})[' rethrows'][#Bool#]
 
 
 protocol P2 {