reverse() => reversed()

Author: Max Moiseev

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -105,7 +105,7 @@ public struct SourceLocStack {
 func _printStackTrace(stackTrace: SourceLocStack?) {
   guard let s = stackTrace where !s.locs.isEmpty else { return }
   print("stacktrace:")
-  for (i, loc) in s.locs.reverse().enumerated {
+  for (i, loc) in s.locs.reversed().enumerated {
     let comment = (loc.comment != nil) ? " ; \(loc.comment!)" : ""
     print("  #\(i): \(loc.file):\(loc.line)\(comment)")
   }

stdlib/public/core/Reverse.swift

@@ -123,17 +123,17 @@ extension _ReverseCollection
 /// A Collection that presents the elements of its `Base` collection
 /// in reverse order.
 ///
-/// - Note: This type is the result of `x.reverse()` where `x` is a
+/// - Note: This type is the result of `x.reversed()` where `x` is a
 ///   collection having bidirectional indices.
 ///
-/// The `reverse()` method is always lazy when applied to a collection
+/// The `reversed()` method is always lazy when applied to a collection
 /// with bidirectional indices, but does not implicitly confer
 /// laziness on algorithms applied to its result.  In other words, for
 /// ordinary collections `c` having bidirectional indices:
 ///
-/// * `c.reverse()` does not create new storage
-/// * `c.reverse().map(f)` maps eagerly and returns a new array
-/// * `c.lazy.reverse().map(f)` maps lazily and returns a `LazyMapCollection`
+/// * `c.reversed()` does not create new storage
+/// * `c.reversed().map(f)` maps eagerly and returns a new array
+/// * `c.lazy.reversed().map(f)` maps lazily and returns a `LazyMapCollection`
 ///
 /// - See also: `ReverseRandomAccessCollection`
 public struct ReverseCollection<
@@ -163,7 +163,7 @@ public struct ReverseCollection<
 /// A Collection that presents the elements of its `Base` collection
 /// in reverse order.
 ///
-/// - Note: This type is the result of `x.reverse()` where `x` is a
+/// - Note: This type is the result of `x.reversed()` where `x` is a
 ///   collection having random access indices.
 /// - See also: `ReverseCollection`
 public struct ReverseRandomAccessCollection<
@@ -197,7 +197,7 @@ extension Collection where Index : BidirectionalIndex {
   ///
   /// - Complexity: O(1)
   @warn_unused_result
-  public func reverse() -> ReverseCollection<Self> {
+  public func reversed() -> ReverseCollection<Self> {
     return ReverseCollection(self)
   }
 }
@@ -207,7 +207,7 @@ extension Collection where Index : RandomAccessIndex {
   ///
   /// - Complexity: O(1)
   @warn_unused_result
-  public func reverse() -> ReverseRandomAccessCollection<Self> {
+  public func reversed() -> ReverseRandomAccessCollection<Self> {
     return ReverseRandomAccessCollection(self)
   }
 }
@@ -218,7 +218,7 @@ where Index : BidirectionalIndex, Elements.Index : BidirectionalIndex {
   ///
   /// - Complexity: O(1)
   @warn_unused_result
-  public func reverse() -> LazyCollection<
+  public func reversed() -> LazyCollection<
     ReverseCollection<Elements>
   > {
     return ReverseCollection(elements).lazy
@@ -231,7 +231,7 @@ where Index : RandomAccessIndex, Elements.Index : RandomAccessIndex {
   ///
   /// - Complexity: O(1)
   @warn_unused_result
-  public func reverse() -> LazyCollection<
+  public func reversed() -> LazyCollection<
     ReverseRandomAccessCollection<Elements>
   > {
     return ReverseRandomAccessCollection(elements).lazy

stdlib/public/core/SequenceAlgorithms.swift.gyb

@@ -355,7 +355,7 @@ extension Sequence {
 }
 
 //===----------------------------------------------------------------------===//
-// reverse()
+// reversed()
 //===----------------------------------------------------------------------===//
 
 extension Sequence {
@@ -364,7 +364,7 @@ extension Sequence {
   ///
   /// Complexity: O(`self.length`).
   @warn_unused_result
-  public func reverse() -> [${GElement}] {
+  public func reversed() -> [${GElement}] {
     // FIXME(performance): optimize to 1 pass?  But Array(self) can be
     // optimized to a memcpy() sometimes.  Those cases are usually collections,
     // though.

test/1_stdlib/Collection.swift

@@ -65,7 +65,7 @@ print("")
 // <rdar://problem/15772601> Type checking failure
 // CHECK: raboof
 let i = foobar.indices
-let r = i.lazy.reverse()
+let r = i.lazy.reversed()
 for a in PermutationGenerator(elements: foobar, indices: r) {
 
   print(a, terminator: "")
@@ -82,7 +82,7 @@ func isPalindrome0<
 
   var a = seq.indices
   var i = seq.indices
-  var ir = i.lazy.reverse()
+  var ir = i.lazy.reversed()
   var b = ir.iterator()
   for i in a {
     if seq[i] != seq[b.next()!] {
@@ -105,7 +105,7 @@ func isPalindrome1<
 >(seq: S) -> Bool {
 
   var a = PermutationGenerator(elements: seq, indices: seq.indices)
-  var b = seq.lazy.reverse().iterator()
+  var b = seq.lazy.reversed().iterator()
   for nextChar in a {
     if nextChar != b.next()! {
       return false
@@ -122,7 +122,7 @@ func isPalindrome1_5<
   S.Iterator.Element: Equatable
 >(seq: S) -> Bool {
 
-  var b = seq.lazy.reverse().iterator()
+  var b = seq.lazy.reversed().iterator()
   for nextChar in seq {
     if nextChar != b.next()! {
       return false
@@ -187,7 +187,7 @@ func isPalindrome4<
   // FIXME: separate ri from the expression below pending
   // <rdar://problem/15772601> Type checking failure
   var i = seq.indices
-  let ri = i.lazy.reverse()
+  let ri = i.lazy.reversed()
   var b = PermutationGenerator(elements: seq, indices: ri)
   for nextChar in a {
     if nextChar != b.next()! {

test/1_stdlib/ExistentialCollection.swift

@@ -211,20 +211,20 @@ tests.test("ForwardCollection") {
 
 tests.test("BidirectionalCollection") {
   let a0: ContiguousArray = [1, 2, 3, 5, 8, 13, 21]
-  let fc0 = AnyForwardCollection(a0.lazy.reverse())
+  let fc0 = AnyForwardCollection(a0.lazy.reversed())
 
   let bc0_ = AnyBidirectionalCollection(fc0)         // upgrade!
   expectNotEmpty(bc0_)
   let bc0 = bc0_!
   expectTrue(fc0 === bc0)
 
-  let fc1 = AnyForwardCollection(a0.lazy.reverse()) // new collection
+  let fc1 = AnyForwardCollection(a0.lazy.reversed()) // new collection
   expectFalse(fc1 === fc0)
 
   let fc2 = AnyForwardCollection(bc0)                // downgrade
   expectTrue(fc2 === bc0)
 
-  let a1 = ContiguousArray(bc0.lazy.reverse())
+  let a1 = ContiguousArray(bc0.lazy.reversed())
   expectEqual(a0, a1)
   for e in a0 {
     let i = bc0.indexOf(e)
@@ -247,7 +247,7 @@ tests.test("BidirectionalCollection") {
 
 tests.test("RandomAccessCollection") {
   let a0: ContiguousArray = [1, 2, 3, 5, 8, 13, 21]
-  let fc0 = AnyForwardCollection(a0.lazy.reverse())
+  let fc0 = AnyForwardCollection(a0.lazy.reversed())
   let rc0_ = AnyRandomAccessCollection(fc0)         // upgrade!
   expectNotEmpty(rc0_)
   let rc0 = rc0_!
@@ -259,7 +259,7 @@ tests.test("RandomAccessCollection") {
   let fc1 = AnyBidirectionalCollection(rc0)         // downgrade
   expectTrue(fc1 === rc0)
 
-  let a1 = ContiguousArray(rc0.lazy.reverse())
+  let a1 = ContiguousArray(rc0.lazy.reversed())
   expectEqual(a0, a1)
   for e in a0 {
     let i = rc0.indexOf(e)

test/1_stdlib/Lazy.swift.gyb

@@ -287,12 +287,12 @@ LazyTestSuite.test("LazyCollection.array") {
 }
 
 %  if ReversedType is not None:
-LazyTestSuite.test("LazyCollection.reverse") {
+LazyTestSuite.test("LazyCollection.reversed") {
   let base = Minimal${traversal}Collection(
     elements: [ 0, 30, 10, 90 ].map(OpaqueValue.init),
     underestimatedLength: .Value(42))
   let lazyCollection = base.lazy
-  var reversed = lazyCollection.reverse()
+  var reversed = lazyCollection.reversed()
   expectType(
     LazyCollection<${ReversedType}<Minimal${traversal}Collection<OpaqueValue<Int>>>>.self,
     &reversed)
@@ -301,7 +301,7 @@ LazyTestSuite.test("LazyCollection.reverse") {
     [ 90, 10, 30, 0 ].map(OpaqueValue.init) as [OpaqueValue<Int>],
     reversed) { $0.value == $1.value }
 
-  var reversedTwice = reversed.reverse()
+  var reversedTwice = reversed.reversed()
   expectType(
     LazyCollection<${ReversedType}<${ReversedType}<Minimal${traversal}Collection<OpaqueValue<Int>>>>>.self,
     &reversedTwice)
@@ -592,23 +592,23 @@ tests.test("ReverseCollection") {
   let r = 0..<12
   checkRandomAccessCollection(
     expected,
-    r.reverse())
+    r.reversed())
 
   // Check that the reverse collection is still eager
   do {
     var calls = 0
-    _ = r.reverse().map { _ in ++calls }
+    _ = r.reversed().map { _ in ++calls }
     expectEqual(r.length, calls)
   }
 
   checkBidirectionalCollection(
     "raboof".characters,
-    "foobar".characters.reverse())
+    "foobar".characters.reversed())
 
   // Check that the reverse collection is still eager
   do {
     var calls = 0
-    _ = "foobar".characters.reverse().map { _ in ++calls }
+    _ = "foobar".characters.reversed().map { _ in ++calls }
     expectEqual("foobar".characters.length, calls)
   }
 }
@@ -633,7 +633,7 @@ tests.test("ReverseCollection/Lazy") {
     typealias LazyReversedBase = LazyCollection<
       ReverseRandomAccessCollection<Base>>
 
-    let reversed = base.reverse()
+    let reversed = base.reversed()
     ExpectType<LazyReversedBase>.test(reversed)
 
     var calls = 0
@@ -655,7 +655,7 @@ tests.test("ReverseCollection/Lazy") {
     typealias LazyReversedBase = LazyCollection<
       ReverseCollection<Base>>
 
-    let reversed = base.reverse()
+    let reversed = base.reversed()
     ExpectType<LazyReversedBase>.test(reversed)
 
     var calls = 0

test/1_stdlib/NSStringAPI.swift

@@ -2051,8 +2051,8 @@ func checkHasPrefixHasSuffix(
   let expectHasPrefix = lhsNFDGraphemeClusters.startsWith(
     rhsNFDGraphemeClusters, isEquivalent: (==))
   let expectHasSuffix =
-    lhsNFDGraphemeClusters.lazy.reverse().startsWith(
-      rhsNFDGraphemeClusters.lazy.reverse(), isEquivalent: (==))
+    lhsNFDGraphemeClusters.lazy.reversed().startsWith(
+      rhsNFDGraphemeClusters.lazy.reversed(), isEquivalent: (==))
 
   expectEqual(expectHasPrefix, lhs.hasPrefix(rhs), stackTrace: stackTrace)
   expectEqual(

test/1_stdlib/Range.swift

@@ -33,7 +33,7 @@ var RangeTestSuite = TestSuite("Range")
 RangeTestSuite.test("ReverseRange") {
   // We no longer have a ReverseRange, but we can still make sure that
   // lazy reversal works correctly.
-  expectEqualSequence((0..<10).lazy.reverse(), [9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
+  expectEqualSequence((0..<10).lazy.reversed(), [9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
 }
 
 func isEquatable<E : Equatable>(e: E) {}

test/Constraints/generics.swift

@@ -143,9 +143,9 @@ func f1<
   S: Collection 
   where S.Index: BidirectionalIndex
 >(seq: S) {
-  let x = (seq.indices).lazy.reverse()
+  let x = (seq.indices).lazy.reversed()
   SomeIterator(elements: seq, indices: x) // expected-warning{{unused}}
-  SomeIterator(elements: seq, indices: seq.indices.reverse()) // expected-warning{{unused}}
+  SomeIterator(elements: seq, indices: seq.indices.reversed()) // expected-warning{{unused}}
 }
 
 // <rdar://problem/16078944>

test/IDE/complete_from_stdlib.swift

@@ -146,8 +146,8 @@ func testArchetypeReplacement2<BAR : Equatable>(a: [BAR]) {
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         min({#(isOrderedBefore): (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         max({#(isOrderedBefore): (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reduce({#(initial): T#}, {#combine: (T, Equatable) throws -> T##(T, Equatable) throws -> T#})[' rethrows'][#T#]{{; name=.+}}
-// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reverse()[#ReverseCollection<[Equatable]>#]{{; name=.+}}
-// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reverse()[#ReverseRandomAccessCollection<[Equatable]>#]{{; name=.+}}
+// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reversed()[#ReverseCollection<[Equatable]>#]{{; name=.+}}
+// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         reversed()[#ReverseRandomAccessCollection<[Equatable]>#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         flatMap({#(transform): (Equatable) throws -> Sequence##(Equatable) throws -> Sequence#})[' rethrows'][#[S.Iterator.Element]#]{{; name=.+}}
 
 func testArchetypeReplacement3 (a : [Int]) {

test/Interpreter/SDK/Accelerate.swift

@@ -28,7 +28,7 @@ extension vU1024: IntegerLiteralConvertible, CustomStringConvertible, Equatable
       (intermediate, digit) = quorem(intermediate, 10)
       digits.append(Character(UnicodeScalar(Int(digit) + 48)))
     } while intermediate != 0
-    return String(digits.reverse())
+    return String(digits.reversed())
   }
 }
 

test/Interpreter/algorithms.swift

@@ -19,7 +19,7 @@ fib()
 
 // From: <rdar://problem/17796401>
 // FIXME: <rdar://problem/21993692> type checker too slow
-let two_oneA = [1, 2, 3, 4].lazy.reverse()
+let two_oneA = [1, 2, 3, 4].lazy.reversed()
 let two_one = Array(two_oneA.filter { $0 % 2 == 0 }.map { $0 / 2 })
 print(two_one)
 // CHECK: [2, 1]

validation-test/compiler_crashers_2_fixed/0019-rdar21511651.swift

@@ -416,7 +416,7 @@ extension Collection
 
 
 
-/// The lazy `Collection` returned by `reverse(c)` where `c` is a
+/// The lazy `Collection` returned by `c.reversed()` where `c` is a
 /// `Collection` with an `Index` conforming to `${IndexProtocol}`.
 public struct _prext_ReverseCollection<Base : Collection>
   : Collection, __prext_ReverseCollection {

validation-test/stdlib/ArrayNew.swift.gyb

@@ -335,7 +335,7 @@ ArrayTestSuite.test("${Kind}/popLast") {
     while let element = a.popLast() {
       popped.append(element)
     }
-    expectEqualSequence([1010, 2020, 3030], popped.reverse())
+    expectEqualSequence([1010, 2020, 3030], popped.reversed())
     expectTrue(a.isEmpty)
   }
 }

validation-test/stdlib/Concatenate.swift

@@ -47,8 +47,8 @@ for (expected, source) in samples {
   ConcatenateTests.test("reverse-\(source)") {
     // FIXME: separate 'expected' and 'reversed' variables are a workaround
     // for: <rdar://problem/20789500>
-    let expected = ContiguousArray(expected.lazy.reverse())
-    let reversed = source.flatten().reverse()
+    let expected = ContiguousArray(expected.lazy.reversed())
+    let reversed = source.flatten().reversed()
     checkBidirectionalCollection(expected, reversed)
   }
 

validation-test/stdlib/SequenceType.swift.gyb

@@ -639,14 +639,14 @@ SequenceTypeTests.test("reduce") {
 }
 
 //===----------------------------------------------------------------------===//
-// reverse()
+// reversed()
 //===----------------------------------------------------------------------===//
 
 SequenceTypeTests.test("reverse/Sequence") {
   for test in reverseTests {
     let s = MinimalSequence<OpaqueValue<Int>>(
       elements: test.sequence.map(OpaqueValue.init))
-    var result = s.reverse()
+    var result = s.reversed()
     expectType([OpaqueValue<Int>].self, &result)
     expectEqual(
       test.expected, result.map { $0.value },
@@ -659,7 +659,7 @@ SequenceTypeTests.test("reverse/WhereIndexIsBidirectional,BidirectionalReverseVi
   for test in reverseTests {
     let s = MinimalBidirectionalCollection<OpaqueValue<Int>>(
       elements: test.sequence.map(OpaqueValue.init))
-    var result = s.reverse()
+    var result = s.reversed()
     expectType(
       ReverseCollection<MinimalBidirectionalCollection<OpaqueValue<Int>>>.self,
       &result)
@@ -678,7 +678,7 @@ SequenceTypeTests.test("reverse/WhereIndexIsRandomAccess,RandomAccessReverseView
   for test in reverseTests {
     let s = MinimalRandomAccessCollection<OpaqueValue<Int>>(
       elements: test.sequence.map(OpaqueValue.init))
-    var result = s.reverse()
+    var result = s.reversed()
     expectType(
       ReverseRandomAccessCollection<MinimalRandomAccessCollection<OpaqueValue<Int>>>.self,
       &result)