[WIP][stdlib] Minor Sequence Optimizations

stdlib/public/core/Sequence.swift

@@ -800,6 +800,18 @@ extension Sequence where Element : Equatable {
   }
 }
 
+extension ContiguousArray {
+  /// Rotates array in place to the left by specified distance.
+  @usableFromInline
+  mutating func _rotate(left distance: Int) {
+    guard distance > 0 else { return }
+    let i = index(startIndex, offsetBy: distance)
+    self[startIndex..<i].reverse()
+    self[i..<endIndex].reverse()
+    self.reverse()
+  }
+}
+
 extension Sequence {
 
   /// Returns the longest possible subsequences of the sequence, in order, that
@@ -889,10 +901,9 @@ extension Sequence {
 
     // FIXME: <rdar://problem/21885650> Create reusable RingBuffer<T>
     // Put incoming elements into a ring buffer to save space. Once all
-    // elements are consumed, reorder the ring buffer into an `Array`
-    // and return it. This saves memory for sequences particularly longer
-    // than `maxLength`.
-    var ringBuffer: [Element] = []
+    // elements are consumed, reorder the ring buffer and return it.
+    // This saves memory for sequences particularly longer than `maxLength`.
+    var ringBuffer = ContiguousArray<Element>()
     ringBuffer.reserveCapacity(Swift.min(maxLength, underestimatedCount))
 
     var i = 0
@@ -902,20 +913,12 @@ extension Sequence {
         ringBuffer.append(element)
       } else {
         ringBuffer[i] = element
-        i += 1
-        i %= maxLength
+        i = (i + 1) % maxLength
       }
     }
 
-    if i != ringBuffer.startIndex {
-      var rotated: [Element] = []
-      rotated.reserveCapacity(ringBuffer.count)
-      rotated += ringBuffer[i..<ringBuffer.endIndex]
-      rotated += ringBuffer[0..<i]
-      return rotated
-    } else {      
-      return ringBuffer
-    }
+    ringBuffer._rotate(left: i)
+    return Array(ringBuffer)
   }
 
   /// Returns a sequence containing all but the given number of initial
@@ -972,8 +975,8 @@ extension Sequence {
     // holding tank into the result, an `Array`. This saves
     // `k` * sizeof(Element) of memory, because slices keep the entire
     // memory of an `Array` alive.
-    var result: [Element] = []
-    var ringBuffer: [Element] = []
+    var result = ContiguousArray<Element>()
+    var ringBuffer = ContiguousArray<Element>()
     var i = ringBuffer.startIndex
 
     for element in self {
@@ -982,11 +985,10 @@ extension Sequence {
       } else {
         result.append(ringBuffer[i])
         ringBuffer[i] = element
-        i += 1
-        i %= k
+        i = (i + 1) % k
       }
     }
-    return result
+    return Array(result)
   }
 
   /// Returns a sequence by skipping the initial, consecutive elements that
@@ -1068,15 +1070,15 @@ extension Sequence {
   public __consuming func prefix(
     while predicate: (Element) throws -> Bool
   ) rethrows -> [Element] {
-    var result: [Element] = []
+    var result = ContiguousArray<Element>()
 
     for element in self {
       guard try predicate(element) else {
         break
       }
       result.append(element)
     }
-    return result
+    return Array(result)
   }
 }