Rename pairwise to zipWithNext, KEEP-11

libraries/stdlib/test/collections/IterableTests.kt

@@ -119,21 +119,21 @@ abstract class OrderedIterableTests<T : Iterable<String>>(createFrom: (Array<out
 
 
     @Test
-    fun pairwise() {
+    fun zipWithNext() {
         val data = createFrom("", "a", "xyz")
-        val lengthDeltas = data.pairwise { a, b -> b.length - a.length }
+        val lengthDeltas = data.zipWithNext { a: String, b: String -> b.length - a.length }
         assertEquals(listOf(1, 2), lengthDeltas)
 
-        assertTrue(empty.pairwise { a, b -> a + b }.isEmpty())
-        assertTrue(createFrom("foo").pairwise { a, b -> a + b }.isEmpty())
+        assertTrue(empty.zipWithNext { a: String, b: String -> a + b }.isEmpty())
+        assertTrue(createFrom("foo").zipWithNext { a: String, b: String -> a + b }.isEmpty())
     }
 
     @Test
-    fun pairwisePairs() {
-        assertTrue(empty.pairwise().isEmpty())
-        assertTrue(createFrom("foo").pairwise().isEmpty())
-        assertEquals(listOf("a" to "b"), createFrom("a", "b").pairwise())
-        assertEquals(listOf("a" to "b", "b" to "c"), createFrom("a", "b", "c").pairwise())
+    fun zipWithNextPairs() {
+        assertTrue(empty.zipWithNext().isEmpty())
+        assertTrue(createFrom("foo").zipWithNext().isEmpty())
+        assertEquals(listOf("a" to "b"), createFrom("a", "b").zipWithNext())
+        assertEquals(listOf("a" to "b", "b" to "c"), createFrom("a", "b", "c").zipWithNext())
     }
 
     @Test

libraries/stdlib/test/collections/SequenceTest.kt

@@ -197,23 +197,23 @@ public class SequenceTest {
         assertEquals("", sequenceOf(1).dropWhile { it < 200 }.joinToString(limit = 10))
     }
 
-    @Test fun pairwise() {
-        val deltas = fibonacci().pairwise { a, b -> b - a }
+    @Test fun zipWithNext() {
+        val deltas = fibonacci().zipWithNext { a: Int, b: Int -> b - a }
         // deltas of 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, ...
         // is the same sequence prepended by 1
         assertEquals(listOf(1) + fibonacci().take(9), deltas.take(10).toList())
 
-        ensureIsIntermediate(source = sequenceOf(1, 2)) { it.pairwise { a, b -> b - a } }
+        ensureIsIntermediate(source = sequenceOf(1, 2)) { it.zipWithNext { a: Int, b: Int -> b - a } }
     }
 
-    @Test fun pairwisePairs() {
-        val pairs: Sequence<Pair<String, String>> = sequenceOf("a", "b", "c", "d").pairwise()
+    @Test fun zipWithNextPairs() {
+        val pairs: Sequence<Pair<String, String>> = sequenceOf("a", "b", "c", "d").zipWithNext()
         assertEquals(listOf("a" to "b", "b" to "c", "c" to "d"), pairs.toList())
 
-        assertTrue(emptySequence<String>().pairwise().toList().isEmpty())
-        assertTrue(sequenceOf(1).pairwise().toList().isEmpty())
+        assertTrue(emptySequence<String>().zipWithNext().toList().isEmpty())
+        assertTrue(sequenceOf(1).zipWithNext().toList().isEmpty())
 
-        ensureIsIntermediate(source = sequenceOf(1, 2)) { it.pairwise() }
+        ensureIsIntermediate(source = sequenceOf(1, 2)) { it.zipWithNext() }
     }
 
     @Test

libraries/stdlib/test/text/StringTest.kt

@@ -839,16 +839,16 @@ class StringTest {
         assertContentEquals("abc", pair.second, "pair.second")
     }
 
-    @Test fun pairwise() = withOneCharSequenceArg { arg1 ->
-        assertEquals(listOf("ab", "bc"), arg1("abc").pairwise { a, b -> a.toString() + b })
-        assertTrue(arg1("").pairwise { a, b -> a.toString() + b }.isEmpty())
-        assertTrue(arg1("a").pairwise { a, b -> a.toString() + b }.isEmpty())
+    @Test fun zipWithNext() = withOneCharSequenceArg { arg1 ->
+        assertEquals(listOf("ab", "bc"), arg1("abc").zipWithNext { a: Char, b: Char -> a.toString() + b })
+        assertTrue(arg1("").zipWithNext { a: Char, b: Char -> a.toString() + b }.isEmpty())
+        assertTrue(arg1("a").zipWithNext { a: Char, b: Char -> a.toString() + b }.isEmpty())
     }
 
-    @Test fun pairwisePairs() = withOneCharSequenceArg { arg1 ->
-        assertEquals(listOf('a' to 'b', 'b' to 'c'), arg1("abc").pairwise())
-        assertTrue(arg1("").pairwise().isEmpty())
-        assertTrue(arg1("a").pairwise().isEmpty())
+    @Test fun zipWithNextPairs() = withOneCharSequenceArg { arg1 ->
+        assertEquals(listOf('a' to 'b', 'b' to 'c'), arg1("abc").zipWithNext())
+        assertTrue(arg1("").zipWithNext().isEmpty())
+        assertTrue(arg1("a").zipWithNext().isEmpty())
     }