Rename pairwise to zipWithNext, KEEP-11

libraries/stdlib/src/generated/_Collections.kt

@@ -1877,38 +1877,16 @@ public inline fun <T> Iterable<T>.minusElement(element: T): List<T> {
     return minus(element)
 }
 
-/**
- * Returns a list of pairs of each two adjacent elements in this collection.
- * 
- * The returned list is empty if this collection contains less than two elements.
- * 
- * @sample samples.collections.Collections.Transformations.pairwise
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext()"))
 @SinceKotlin("1.2")
 public fun <T> Iterable<T>.pairwise(): List<Pair<T, T>> {
-    return pairwise { a, b -> a to b }
+    return zipWithNext { a, b -> a to b }
 }
 
-/**
- * Returns a list containing the results of applying the given [transform] function
- * to an each pair of two adjacent elements in this collection.
- * 
- * The returned list is empty if this collection contains less than two elements.
- * 
- * @sample samples.collections.Collections.Transformations.pairwiseToFindDeltas
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext(transform)"))
 @SinceKotlin("1.2")
 public inline fun <T, R> Iterable<T>.pairwise(transform: (a: T, b: T) -> R): List<R> {
-    val iterator = iterator()
-    if (!iterator.hasNext()) return emptyList()
-    val result = mutableListOf<R>()
-    var current = iterator.next()
-    while (iterator.hasNext()) {
-        val next = iterator.next()
-        result.add(transform(current, next))
-        current = next
-    }
-    return result
+    return zipWithNext(transform)
 }
 
 /**
@@ -2145,6 +2123,40 @@ public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T
     return list
 }
 
+/**
+ * Returns a list of pairs of each two adjacent elements in this collection.
+ * 
+ * The returned list is empty if this collection contains less than two elements.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNext
+ */
+@SinceKotlin("1.2")
+public fun <T> Iterable<T>.zipWithNext(): List<Pair<T, T>> {
+    return zipWithNext { a, b -> a to b }
+}
+
+/**
+ * Returns a list containing the results of applying the given [transform] function
+ * to an each pair of two adjacent elements in this collection.
+ * 
+ * The returned list is empty if this collection contains less than two elements.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNextToFindDeltas
+ */
+@SinceKotlin("1.2")
+public inline fun <T, R> Iterable<T>.zipWithNext(transform: (a: T, b: T) -> R): List<R> {
+    val iterator = iterator()
+    if (!iterator.hasNext()) return emptyList()
+    val result = mutableListOf<R>()
+    var current = iterator.next()
+    while (iterator.hasNext()) {
+        val next = iterator.next()
+        result.add(transform(current, next))
+        current = next
+    }
+    return result
+}
+
 /**
  * Appends the string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
  * 

libraries/stdlib/src/generated/_Sequences.kt

@@ -1450,42 +1450,16 @@ public inline fun <T> Sequence<T>.minusElement(element: T): Sequence<T> {
     return minus(element)
 }
 
-/**
- * Returns a sequence of pairs of each two adjacent elements in this sequence.
- * 
- * The returned sequence is empty if this sequence contains less than two elements.
- * 
- * @sample samples.collections.Collections.Transformations.pairwise
- *
- * The operation is _intermediate_ and _stateless_.
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext()"))
 @SinceKotlin("1.2")
 public fun <T> Sequence<T>.pairwise(): Sequence<Pair<T, T>> {
-    return pairwise { a, b -> a to b }
+    return zipWithNext { a, b -> a to b }
 }
 
-/**
- * Returns a sequence containing the results of applying the given [transform] function
- * to an each pair of two adjacent elements in this sequence.
- * 
- * The returned sequence is empty if this sequence contains less than two elements.
- * 
- * @sample samples.collections.Collections.Transformations.pairwiseToFindDeltas
- *
- * The operation is _intermediate_ and _stateless_.
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext(transform)"))
 @SinceKotlin("1.2")
 public fun <T, R> Sequence<T>.pairwise(transform: (a: T, b: T) -> R): Sequence<R> {
-    return buildSequence result@ {
-        val iterator = iterator()
-        if (!iterator.hasNext()) return@result
-        var current = iterator.next()
-        while (iterator.hasNext()) {
-            val next = iterator.next()
-            yield(transform(current, next))
-            current = next
-        }
-    }
+    return zipWithNext(transform)
 }
 
 /**
@@ -1620,6 +1594,44 @@ public fun <T, R, V> Sequence<T>.zip(other: Sequence<R>, transform: (a: T, b: R)
     return MergingSequence(this, other, transform)
 }
 
+/**
+ * Returns a sequence of pairs of each two adjacent elements in this sequence.
+ * 
+ * The returned sequence is empty if this sequence contains less than two elements.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNext
+ *
+ * The operation is _intermediate_ and _stateless_.
+ */
+@SinceKotlin("1.2")
+public fun <T> Sequence<T>.zipWithNext(): Sequence<Pair<T, T>> {
+    return zipWithNext { a, b -> a to b }
+}
+
+/**
+ * Returns a sequence containing the results of applying the given [transform] function
+ * to an each pair of two adjacent elements in this sequence.
+ * 
+ * The returned sequence is empty if this sequence contains less than two elements.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNextToFindDeltas
+ *
+ * The operation is _intermediate_ and _stateless_.
+ */
+@SinceKotlin("1.2")
+public fun <T, R> Sequence<T>.zipWithNext(transform: (a: T, b: T) -> R): Sequence<R> {
+    return buildSequence result@ {
+        val iterator = iterator()
+        if (!iterator.hasNext()) return@result
+        var current = iterator.next()
+        while (iterator.hasNext()) {
+            val next = iterator.next()
+            yield(transform(current, next))
+            current = next
+        }
+    }
+}
+
 /**
  * Appends the string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
  * 

libraries/stdlib/src/generated/_Strings.kt

@@ -1176,35 +1176,16 @@ public fun <R> CharSequence.chunkedSequence(size: Int, transform: (CharSequence)
     return windowedSequence(size, size, transform)
 }
 
-/**
- * Returns a list of pairs of each two adjacent characters in this char sequence.
- * 
- * The returned list is empty if this char sequence contains less than two characters.
- * 
- * @sample samples.collections.Collections.Transformations.pairwise
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext()"))
 @SinceKotlin("1.2")
 public fun CharSequence.pairwise(): List<Pair<Char, Char>> {
-    return pairwise { a, b -> a to b }
+    return zipWithNext { a, b -> a to b }
 }
 
-/**
- * Returns a list containing the results of applying the given [transform] function
- * to an each pair of two adjacent characters in this char sequence.
- * 
- * The returned list is empty if this char sequence contains less than two characters.
- * 
- * @sample samples.collections.Collections.Transformations.pairwiseToFindDeltas
- */
+@Deprecated("Use zipWithNext instead", ReplaceWith("zipWithNext(transform)"))
 @SinceKotlin("1.2")
 public inline fun <R> CharSequence.pairwise(transform: (a: Char, b: Char) -> R): List<R> {
-    val size = length - 1
-    if (size < 1) return emptyList()
-    val result = ArrayList<R>(size)
-    for (index in 0..size - 1) {
-        result.add(transform(this[index], this[index + 1]))
-    }
-    return result
+    return zipWithNext(transform)
 }
 
 /**
@@ -1347,6 +1328,37 @@ public inline fun <V> CharSequence.zip(other: CharSequence, transform: (a: Char,
     return list
 }
 
+/**
+ * Returns a list of pairs of each two adjacent characters in this char sequence.
+ * 
+ * The returned list is empty if this char sequence contains less than two characters.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNext
+ */
+@SinceKotlin("1.2")
+public fun CharSequence.zipWithNext(): List<Pair<Char, Char>> {
+    return zipWithNext { a, b -> a to b }
+}
+
+/**
+ * Returns a list containing the results of applying the given [transform] function
+ * to an each pair of two adjacent characters in this char sequence.
+ * 
+ * The returned list is empty if this char sequence contains less than two characters.
+ * 
+ * @sample samples.collections.Collections.Transformations.zipWithNextToFindDeltas
+ */
+@SinceKotlin("1.2")
+public inline fun <R> CharSequence.zipWithNext(transform: (a: Char, b: Char) -> R): List<R> {
+    val size = length - 1
+    if (size < 1) return emptyList()
+    val result = ArrayList<R>(size)
+    for (index in 0..size - 1) {
+        result.add(transform(this[index], this[index + 1]))
+    }
+    return result
+}
+
 /**
  * Creates an [Iterable] instance that wraps the original char sequence returning its characters when being iterated.
  */