From a1fb6f1278c9b874b08335a28113ce251e02fadd Mon Sep 17 00:00:00 2001
From: Pavol Vaskovic <pali@pali.sk>
Date: Sat, 5 Jan 2019 14:27:03 +0100
Subject: [PATCH 1/2] [stdlib] Gardening: ringBuffer position index

---
 stdlib/public/core/Sequence.swift | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/stdlib/public/core/Sequence.swift b/stdlib/public/core/Sequence.swift
index f4d9125370d48..95d532124e50c 100644
--- a/stdlib/public/core/Sequence.swift
+++ b/stdlib/public/core/Sequence.swift
@@ -906,8 +906,7 @@ extension Sequence {
         ringBuffer.append(element)
       } else {
         ringBuffer[i] = element
-        i += 1
-        i %= maxLength
+        i = (i + 1) % maxLength
       }
     }
 
@@ -986,8 +985,7 @@ extension Sequence {
       } else {
         result.append(ringBuffer[i])
         ringBuffer[i] = element
-        i += 1
-        i %= k
+        i = (i + 1) % k
       }
     }
     return result

From c887116862f734985562ff4836b400536bb5548e Mon Sep 17 00:00:00 2001
From: Pavol Vaskovic <pali@pali.sk>
Date: Sat, 5 Jan 2019 14:28:37 +0100
Subject: [PATCH 2/2] [stdlib] dropLast, prefix, suffix: ContiguousArray

Nano-optimization:
Following the template used in methods `map` and `_filter`, internally use ContiguousArray before converting to an Array on return.
---
 stdlib/public/core/Sequence.swift | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/stdlib/public/core/Sequence.swift b/stdlib/public/core/Sequence.swift
index 95d532124e50c..8e72742ed2bea 100644
--- a/stdlib/public/core/Sequence.swift
+++ b/stdlib/public/core/Sequence.swift
@@ -893,10 +893,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 into a copy 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
@@ -911,13 +910,13 @@ extension Sequence {
     }
 
     if i != ringBuffer.startIndex {
-      var rotated: [Element] = []
+      var rotated = ContiguousArray<Element>()
       rotated.reserveCapacity(ringBuffer.count)
       rotated += ringBuffer[i..<ringBuffer.endIndex]
       rotated += ringBuffer[0..<i]
-      return rotated
-    } else {      
-      return ringBuffer
+      return Array(rotated)
+    } else {
+      return Array(ringBuffer)
     }
   }
 
@@ -975,8 +974,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 {
@@ -988,7 +987,7 @@ extension Sequence {
         i = (i + 1) % k
       }
     }
-    return result
+    return Array(result)
   }
 
   /// Returns a sequence by skipping the initial, consecutive elements that
@@ -1070,7 +1069,7 @@ 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 {
@@ -1078,7 +1077,7 @@ extension Sequence {
       }
       result.append(element)
     }
-    return result
+    return Array(result)
   }
 }