diff --git a/libraries/stdlib/src/generated/_Arrays.kt b/libraries/stdlib/src/generated/_Arrays.kt
index 8d13a517be9..e7be3162e5a 100644
--- a/libraries/stdlib/src/generated/_Arrays.kt
+++ b/libraries/stdlib/src/generated/_Arrays.kt
@@ -5633,93 +5633,93 @@ public fun ShortArray.toArrayList(): ArrayList<Short> {
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(collection: C): C {
+public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Char>> CharArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Char>> CharArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Float>> FloatArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Float>> FloatArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Int>> IntArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Int>> IntArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Long>> LongArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Long>> LongArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Short>> ShortArray.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Short>> ShortArray.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
@@ -6497,74 +6497,74 @@ public inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(destinat
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <T, K> Array<out T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
-    return groupByTo(LinkedHashMap<K, MutableList<T>>(), toKey)
+public inline fun <T, K> Array<out T>.groupBy(selector: (T) -> K): Map<K, List<T>> {
+    return groupByTo(LinkedHashMap<K, MutableList<T>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> BooleanArray.groupBy(toKey: (Boolean) -> K): Map<K, List<Boolean>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Boolean>>(), toKey)
+public inline fun <K> BooleanArray.groupBy(selector: (Boolean) -> K): Map<K, List<Boolean>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Boolean>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> ByteArray.groupBy(toKey: (Byte) -> K): Map<K, List<Byte>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Byte>>(), toKey)
+public inline fun <K> ByteArray.groupBy(selector: (Byte) -> K): Map<K, List<Byte>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Byte>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> CharArray.groupBy(toKey: (Char) -> K): Map<K, List<Char>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), toKey)
+public inline fun <K> CharArray.groupBy(selector: (Char) -> K): Map<K, List<Char>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> DoubleArray.groupBy(toKey: (Double) -> K): Map<K, List<Double>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Double>>(), toKey)
+public inline fun <K> DoubleArray.groupBy(selector: (Double) -> K): Map<K, List<Double>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Double>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> FloatArray.groupBy(toKey: (Float) -> K): Map<K, List<Float>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Float>>(), toKey)
+public inline fun <K> FloatArray.groupBy(selector: (Float) -> K): Map<K, List<Float>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Float>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> IntArray.groupBy(toKey: (Int) -> K): Map<K, List<Int>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Int>>(), toKey)
+public inline fun <K> IntArray.groupBy(selector: (Int) -> K): Map<K, List<Int>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Int>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> LongArray.groupBy(toKey: (Long) -> K): Map<K, List<Long>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Long>>(), toKey)
+public inline fun <K> LongArray.groupBy(selector: (Long) -> K): Map<K, List<Long>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Long>>(), selector)
 }
 
 /**
- * Returns a map of the elements in original array grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original array grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> ShortArray.groupBy(toKey: (Short) -> K): Map<K, List<Short>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Short>>(), toKey)
+public inline fun <K> ShortArray.groupBy(selector: (Short) -> K): Map<K, List<Short>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Short>>(), selector)
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <T, K> Array<out T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
+public inline fun <T, K> Array<out T>.groupByTo(map: MutableMap<K, MutableList<T>>, selector: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
@@ -6572,11 +6572,11 @@ public inline fun <T, K> Array<out T>.groupByTo(map: MutableMap<K, MutableList<T
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> BooleanArray.groupByTo(map: MutableMap<K, MutableList<Boolean>>, toKey: (Boolean) -> K): Map<K, MutableList<Boolean>> {
+public inline fun <K> BooleanArray.groupByTo(map: MutableMap<K, MutableList<Boolean>>, selector: (Boolean) -> K): Map<K, MutableList<Boolean>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Boolean>() }
         list.add(element)
     }
@@ -6584,11 +6584,11 @@ public inline fun <K> BooleanArray.groupByTo(map: MutableMap<K, MutableList<Bool
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> ByteArray.groupByTo(map: MutableMap<K, MutableList<Byte>>, toKey: (Byte) -> K): Map<K, MutableList<Byte>> {
+public inline fun <K> ByteArray.groupByTo(map: MutableMap<K, MutableList<Byte>>, selector: (Byte) -> K): Map<K, MutableList<Byte>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Byte>() }
         list.add(element)
     }
@@ -6596,11 +6596,11 @@ public inline fun <K> ByteArray.groupByTo(map: MutableMap<K, MutableList<Byte>>,
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> CharArray.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K): Map<K, MutableList<Char>> {
+public inline fun <K> CharArray.groupByTo(map: MutableMap<K, MutableList<Char>>, selector: (Char) -> K): Map<K, MutableList<Char>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Char>() }
         list.add(element)
     }
@@ -6608,11 +6608,11 @@ public inline fun <K> CharArray.groupByTo(map: MutableMap<K, MutableList<Char>>,
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> DoubleArray.groupByTo(map: MutableMap<K, MutableList<Double>>, toKey: (Double) -> K): Map<K, MutableList<Double>> {
+public inline fun <K> DoubleArray.groupByTo(map: MutableMap<K, MutableList<Double>>, selector: (Double) -> K): Map<K, MutableList<Double>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Double>() }
         list.add(element)
     }
@@ -6620,11 +6620,11 @@ public inline fun <K> DoubleArray.groupByTo(map: MutableMap<K, MutableList<Doubl
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> FloatArray.groupByTo(map: MutableMap<K, MutableList<Float>>, toKey: (Float) -> K): Map<K, MutableList<Float>> {
+public inline fun <K> FloatArray.groupByTo(map: MutableMap<K, MutableList<Float>>, selector: (Float) -> K): Map<K, MutableList<Float>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Float>() }
         list.add(element)
     }
@@ -6632,11 +6632,11 @@ public inline fun <K> FloatArray.groupByTo(map: MutableMap<K, MutableList<Float>
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> IntArray.groupByTo(map: MutableMap<K, MutableList<Int>>, toKey: (Int) -> K): Map<K, MutableList<Int>> {
+public inline fun <K> IntArray.groupByTo(map: MutableMap<K, MutableList<Int>>, selector: (Int) -> K): Map<K, MutableList<Int>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Int>() }
         list.add(element)
     }
@@ -6644,11 +6644,11 @@ public inline fun <K> IntArray.groupByTo(map: MutableMap<K, MutableList<Int>>, t
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> LongArray.groupByTo(map: MutableMap<K, MutableList<Long>>, toKey: (Long) -> K): Map<K, MutableList<Long>> {
+public inline fun <K> LongArray.groupByTo(map: MutableMap<K, MutableList<Long>>, selector: (Long) -> K): Map<K, MutableList<Long>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Long>() }
         list.add(element)
     }
@@ -6656,11 +6656,11 @@ public inline fun <K> LongArray.groupByTo(map: MutableMap<K, MutableList<Long>>,
 }
 
 /**
- * Appends elements from original array grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original array grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> ShortArray.groupByTo(map: MutableMap<K, MutableList<Short>>, toKey: (Short) -> K): Map<K, MutableList<Short>> {
+public inline fun <K> ShortArray.groupByTo(map: MutableMap<K, MutableList<Short>>, selector: (Short) -> K): Map<K, MutableList<Short>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Short>() }
         list.add(element)
     }
@@ -7170,14 +7170,15 @@ public fun ShortArray.distinct(): List<Short> {
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <T, K> Array<out T>.distinctBy(keySelector: (T) -> K): List<T> {
+public inline fun <T, K> Array<out T>.distinctBy(selector: (T) -> K): List<T> {
     val set = HashSet<K>()
     val list = ArrayList<T>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7185,14 +7186,15 @@ public inline fun <T, K> Array<out T>.distinctBy(keySelector: (T) -> K): List<T>
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> BooleanArray.distinctBy(keySelector: (Boolean) -> K): List<Boolean> {
+public inline fun <K> BooleanArray.distinctBy(selector: (Boolean) -> K): List<Boolean> {
     val set = HashSet<K>()
     val list = ArrayList<Boolean>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7200,14 +7202,15 @@ public inline fun <K> BooleanArray.distinctBy(keySelector: (Boolean) -> K): List
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> ByteArray.distinctBy(keySelector: (Byte) -> K): List<Byte> {
+public inline fun <K> ByteArray.distinctBy(selector: (Byte) -> K): List<Byte> {
     val set = HashSet<K>()
     val list = ArrayList<Byte>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7215,14 +7218,15 @@ public inline fun <K> ByteArray.distinctBy(keySelector: (Byte) -> K): List<Byte>
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> CharArray.distinctBy(keySelector: (Char) -> K): List<Char> {
+public inline fun <K> CharArray.distinctBy(selector: (Char) -> K): List<Char> {
     val set = HashSet<K>()
     val list = ArrayList<Char>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7230,14 +7234,15 @@ public inline fun <K> CharArray.distinctBy(keySelector: (Char) -> K): List<Char>
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> DoubleArray.distinctBy(keySelector: (Double) -> K): List<Double> {
+public inline fun <K> DoubleArray.distinctBy(selector: (Double) -> K): List<Double> {
     val set = HashSet<K>()
     val list = ArrayList<Double>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7245,14 +7250,15 @@ public inline fun <K> DoubleArray.distinctBy(keySelector: (Double) -> K): List<D
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> FloatArray.distinctBy(keySelector: (Float) -> K): List<Float> {
+public inline fun <K> FloatArray.distinctBy(selector: (Float) -> K): List<Float> {
     val set = HashSet<K>()
     val list = ArrayList<Float>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7260,14 +7266,15 @@ public inline fun <K> FloatArray.distinctBy(keySelector: (Float) -> K): List<Flo
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> IntArray.distinctBy(keySelector: (Int) -> K): List<Int> {
+public inline fun <K> IntArray.distinctBy(selector: (Int) -> K): List<Int> {
     val set = HashSet<K>()
     val list = ArrayList<Int>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7275,14 +7282,15 @@ public inline fun <K> IntArray.distinctBy(keySelector: (Int) -> K): List<Int> {
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> LongArray.distinctBy(keySelector: (Long) -> K): List<Long> {
+public inline fun <K> LongArray.distinctBy(selector: (Long) -> K): List<Long> {
     val set = HashSet<K>()
     val list = ArrayList<Long>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -7290,14 +7298,15 @@ public inline fun <K> LongArray.distinctBy(keySelector: (Long) -> K): List<Long>
 }
 
 /**
- * Returns a list containing only distinct elements from the given array according to the [keySelector].
+ * Returns a list containing only elements from the given array
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source array.
  */
-public inline fun <K> ShortArray.distinctBy(keySelector: (Short) -> K): List<Short> {
+public inline fun <K> ShortArray.distinctBy(selector: (Short) -> K): List<Short> {
     val set = HashSet<K>()
     val list = ArrayList<Short>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -8178,138 +8187,138 @@ public inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, R) ->
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun <T> Array<out T>.forEach(operation: (T) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun BooleanArray.forEach(operation: (Boolean) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun BooleanArray.forEach(action: (Boolean) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun ByteArray.forEach(operation: (Byte) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun ByteArray.forEach(action: (Byte) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun CharArray.forEach(operation: (Char) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun CharArray.forEach(action: (Char) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun DoubleArray.forEach(operation: (Double) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun DoubleArray.forEach(action: (Double) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun FloatArray.forEach(operation: (Float) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun FloatArray.forEach(action: (Float) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun IntArray.forEach(operation: (Int) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun IntArray.forEach(action: (Int) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun LongArray.forEach(operation: (Long) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun LongArray.forEach(action: (Long) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun ShortArray.forEach(operation: (Short) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun ShortArray.forEach(action: (Short) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun <T> Array<out T>.forEachIndexed(operation: (Int, T) -> Unit): Unit {
+public inline fun <T> Array<out T>.forEachIndexed(action: (Int, T) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun BooleanArray.forEachIndexed(operation: (Int, Boolean) -> Unit): Unit {
+public inline fun BooleanArray.forEachIndexed(action: (Int, Boolean) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun ByteArray.forEachIndexed(operation: (Int, Byte) -> Unit): Unit {
+public inline fun ByteArray.forEachIndexed(action: (Int, Byte) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun CharArray.forEachIndexed(operation: (Int, Char) -> Unit): Unit {
+public inline fun CharArray.forEachIndexed(action: (Int, Char) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun DoubleArray.forEachIndexed(operation: (Int, Double) -> Unit): Unit {
+public inline fun DoubleArray.forEachIndexed(action: (Int, Double) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun FloatArray.forEachIndexed(operation: (Int, Float) -> Unit): Unit {
+public inline fun FloatArray.forEachIndexed(action: (Int, Float) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun IntArray.forEachIndexed(operation: (Int, Int) -> Unit): Unit {
+public inline fun IntArray.forEachIndexed(action: (Int, Int) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun LongArray.forEachIndexed(operation: (Int, Long) -> Unit): Unit {
+public inline fun LongArray.forEachIndexed(action: (Int, Long) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun ShortArray.forEachIndexed(operation: (Int, Short) -> Unit): Unit {
+public inline fun ShortArray.forEachIndexed(action: (Int, Short) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
@@ -8419,13 +8428,13 @@ public fun ShortArray.max(): Short? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Array<out T>.maxBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Array<out T>.maxBy(selector: (T) -> R): T? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8437,13 +8446,13 @@ public inline fun <R : Comparable<R>, T : Any> Array<out T>.maxBy(f: (T) -> R):
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> BooleanArray.maxBy(f: (Boolean) -> R): Boolean? {
+public inline fun <R : Comparable<R>> BooleanArray.maxBy(selector: (Boolean) -> R): Boolean? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8455,13 +8464,13 @@ public inline fun <R : Comparable<R>> BooleanArray.maxBy(f: (Boolean) -> R): Boo
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> ByteArray.maxBy(f: (Byte) -> R): Byte? {
+public inline fun <R : Comparable<R>> ByteArray.maxBy(selector: (Byte) -> R): Byte? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8473,13 +8482,13 @@ public inline fun <R : Comparable<R>> ByteArray.maxBy(f: (Byte) -> R): Byte? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> CharArray.maxBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> CharArray.maxBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8491,13 +8500,13 @@ public inline fun <R : Comparable<R>> CharArray.maxBy(f: (Char) -> R): Char? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> DoubleArray.maxBy(f: (Double) -> R): Double? {
+public inline fun <R : Comparable<R>> DoubleArray.maxBy(selector: (Double) -> R): Double? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8509,13 +8518,13 @@ public inline fun <R : Comparable<R>> DoubleArray.maxBy(f: (Double) -> R): Doubl
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> FloatArray.maxBy(f: (Float) -> R): Float? {
+public inline fun <R : Comparable<R>> FloatArray.maxBy(selector: (Float) -> R): Float? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8527,13 +8536,13 @@ public inline fun <R : Comparable<R>> FloatArray.maxBy(f: (Float) -> R): Float?
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> IntArray.maxBy(f: (Int) -> R): Int? {
+public inline fun <R : Comparable<R>> IntArray.maxBy(selector: (Int) -> R): Int? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8545,13 +8554,13 @@ public inline fun <R : Comparable<R>> IntArray.maxBy(f: (Int) -> R): Int? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> LongArray.maxBy(f: (Long) -> R): Long? {
+public inline fun <R : Comparable<R>> LongArray.maxBy(selector: (Long) -> R): Long? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8563,13 +8572,13 @@ public inline fun <R : Comparable<R>> LongArray.maxBy(f: (Long) -> R): Long? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> ShortArray.maxBy(f: (Short) -> R): Short? {
+public inline fun <R : Comparable<R>> ShortArray.maxBy(selector: (Short) -> R): Short? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -8685,13 +8694,13 @@ public fun ShortArray.min(): Short? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Array<out T>.minBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Array<out T>.minBy(selector: (T) -> R): T? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8703,13 +8712,13 @@ public inline fun <R : Comparable<R>, T : Any> Array<out T>.minBy(f: (T) -> R):
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> BooleanArray.minBy(f: (Boolean) -> R): Boolean? {
+public inline fun <R : Comparable<R>> BooleanArray.minBy(selector: (Boolean) -> R): Boolean? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8721,13 +8730,13 @@ public inline fun <R : Comparable<R>> BooleanArray.minBy(f: (Boolean) -> R): Boo
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> ByteArray.minBy(f: (Byte) -> R): Byte? {
+public inline fun <R : Comparable<R>> ByteArray.minBy(selector: (Byte) -> R): Byte? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8739,13 +8748,13 @@ public inline fun <R : Comparable<R>> ByteArray.minBy(f: (Byte) -> R): Byte? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> CharArray.minBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> CharArray.minBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8757,13 +8766,13 @@ public inline fun <R : Comparable<R>> CharArray.minBy(f: (Char) -> R): Char? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> DoubleArray.minBy(f: (Double) -> R): Double? {
+public inline fun <R : Comparable<R>> DoubleArray.minBy(selector: (Double) -> R): Double? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8775,13 +8784,13 @@ public inline fun <R : Comparable<R>> DoubleArray.minBy(f: (Double) -> R): Doubl
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> FloatArray.minBy(f: (Float) -> R): Float? {
+public inline fun <R : Comparable<R>> FloatArray.minBy(selector: (Float) -> R): Float? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8793,13 +8802,13 @@ public inline fun <R : Comparable<R>> FloatArray.minBy(f: (Float) -> R): Float?
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> IntArray.minBy(f: (Int) -> R): Int? {
+public inline fun <R : Comparable<R>> IntArray.minBy(selector: (Int) -> R): Int? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8811,13 +8820,13 @@ public inline fun <R : Comparable<R>> IntArray.minBy(f: (Int) -> R): Int? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> LongArray.minBy(f: (Long) -> R): Long? {
+public inline fun <R : Comparable<R>> LongArray.minBy(selector: (Long) -> R): Long? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -8829,13 +8838,13 @@ public inline fun <R : Comparable<R>> LongArray.minBy(f: (Long) -> R): Long? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>> ShortArray.minBy(f: (Short) -> R): Short? {
+public inline fun <R : Comparable<R>> ShortArray.minBy(selector: (Short) -> R): Short? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -9223,199 +9232,199 @@ public inline fun ShortArray.reduceRight(operation: (Short, Short) -> Short): Sh
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun <T> Array<out T>.sumBy(transform: (T) -> Int): Int {
+public inline fun <T> Array<out T>.sumBy(selector: (T) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun BooleanArray.sumBy(transform: (Boolean) -> Int): Int {
+public inline fun BooleanArray.sumBy(selector: (Boolean) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun ByteArray.sumBy(transform: (Byte) -> Int): Int {
+public inline fun ByteArray.sumBy(selector: (Byte) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun CharArray.sumBy(transform: (Char) -> Int): Int {
+public inline fun CharArray.sumBy(selector: (Char) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun DoubleArray.sumBy(transform: (Double) -> Int): Int {
+public inline fun DoubleArray.sumBy(selector: (Double) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun FloatArray.sumBy(transform: (Float) -> Int): Int {
+public inline fun FloatArray.sumBy(selector: (Float) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun IntArray.sumBy(transform: (Int) -> Int): Int {
+public inline fun IntArray.sumBy(selector: (Int) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun LongArray.sumBy(transform: (Long) -> Int): Int {
+public inline fun LongArray.sumBy(selector: (Long) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun ShortArray.sumBy(transform: (Short) -> Int): Int {
+public inline fun ShortArray.sumBy(selector: (Short) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun <T> Array<out T>.sumByDouble(transform: (T) -> Double): Double {
+public inline fun <T> Array<out T>.sumByDouble(selector: (T) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun BooleanArray.sumByDouble(transform: (Boolean) -> Double): Double {
+public inline fun BooleanArray.sumByDouble(selector: (Boolean) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun ByteArray.sumByDouble(transform: (Byte) -> Double): Double {
+public inline fun ByteArray.sumByDouble(selector: (Byte) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun CharArray.sumByDouble(transform: (Char) -> Double): Double {
+public inline fun CharArray.sumByDouble(selector: (Char) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun DoubleArray.sumByDouble(transform: (Double) -> Double): Double {
+public inline fun DoubleArray.sumByDouble(selector: (Double) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun FloatArray.sumByDouble(transform: (Float) -> Double): Double {
+public inline fun FloatArray.sumByDouble(selector: (Float) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun IntArray.sumByDouble(transform: (Int) -> Double): Double {
+public inline fun IntArray.sumByDouble(selector: (Int) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun LongArray.sumByDouble(transform: (Long) -> Double): Double {
+public inline fun LongArray.sumByDouble(selector: (Long) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the array.
+ * Returns the sum of all values produced by [selector] function applied to each element in the array.
  */
-public inline fun ShortArray.sumByDouble(transform: (Short) -> Double): Double {
+public inline fun ShortArray.sumByDouble(selector: (Short) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
@@ -9597,74 +9606,74 @@ public inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <T, R> Array<out T>.zip(array: Array<out R>): List<Pair<T, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <T, R> Array<out T>.zip(other: Array<out R>): List<Pair<T, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> BooleanArray.zip(array: Array<out R>): List<Pair<Boolean, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> BooleanArray.zip(other: Array<out R>): List<Pair<Boolean, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> ByteArray.zip(array: Array<out R>): List<Pair<Byte, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> ByteArray.zip(other: Array<out R>): List<Pair<Byte, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> CharArray.zip(array: Array<out R>): List<Pair<Char, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> CharArray.zip(other: Array<out R>): List<Pair<Char, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> DoubleArray.zip(array: Array<out R>): List<Pair<Double, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> DoubleArray.zip(other: Array<out R>): List<Pair<Double, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> FloatArray.zip(array: Array<out R>): List<Pair<Float, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> FloatArray.zip(other: Array<out R>): List<Pair<Float, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> IntArray.zip(array: Array<out R>): List<Pair<Int, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> IntArray.zip(other: Array<out R>): List<Pair<Int, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> LongArray.zip(array: Array<out R>): List<Pair<Long, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> LongArray.zip(other: Array<out R>): List<Pair<Long, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <R> ShortArray.zip(array: Array<out R>): List<Pair<Short, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <R> ShortArray.zip(other: Array<out R>): List<Pair<Short, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <T, R, V> Array<out T>.zip(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (T, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9672,11 +9681,11 @@ public inline fun <T, R, V> Array<out T>.zip(array: Array<out R>, transform: (T,
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> BooleanArray.zip(array: Array<out R>, transform: (Boolean, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (Boolean, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9684,11 +9693,11 @@ public inline fun <R, V> BooleanArray.zip(array: Array<out R>, transform: (Boole
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> ByteArray.zip(array: Array<out R>, transform: (Byte, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (Byte, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9696,11 +9705,11 @@ public inline fun <R, V> ByteArray.zip(array: Array<out R>, transform: (Byte, R)
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> CharArray.zip(array: Array<out R>, transform: (Char, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (Char, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9708,11 +9717,11 @@ public inline fun <R, V> CharArray.zip(array: Array<out R>, transform: (Char, R)
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> DoubleArray.zip(array: Array<out R>, transform: (Double, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (Double, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9720,11 +9729,11 @@ public inline fun <R, V> DoubleArray.zip(array: Array<out R>, transform: (Double
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> FloatArray.zip(array: Array<out R>, transform: (Float, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (Float, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9732,11 +9741,11 @@ public inline fun <R, V> FloatArray.zip(array: Array<out R>, transform: (Float,
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> IntArray.zip(array: Array<out R>, transform: (Int, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (Int, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9744,11 +9753,11 @@ public inline fun <R, V> IntArray.zip(array: Array<out R>, transform: (Int, R) -
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> LongArray.zip(array: Array<out R>, transform: (Long, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (Long, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -9756,163 +9765,11 @@ public inline fun <R, V> LongArray.zip(array: Array<out R>, transform: (Long, R)
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <R, V> ShortArray.zip(array: Array<out R>, transform: (Short, R) -> V): List<V> {
-    val size = Math.min(size, array.size)
+public inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (Short, R) -> V): List<V> {
+    val size = Math.min(size, other.size)
     val list = ArrayList<V>(size)
     for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun BooleanArray.zip(array: BooleanArray): List<Pair<Boolean, Boolean>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun ByteArray.zip(array: ByteArray): List<Pair<Byte, Byte>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun CharArray.zip(array: CharArray): List<Pair<Char, Char>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun DoubleArray.zip(array: DoubleArray): List<Pair<Double, Double>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun FloatArray.zip(array: FloatArray): List<Pair<Float, Float>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun IntArray.zip(array: IntArray): List<Pair<Int, Int>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun LongArray.zip(array: LongArray): List<Pair<Long, Long>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public infix fun ShortArray.zip(array: ShortArray): List<Pair<Short, Short>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> BooleanArray.zip(array: BooleanArray, transform: (Boolean, Boolean) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> ByteArray.zip(array: ByteArray, transform: (Byte, Byte) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> CharArray.zip(array: CharArray, transform: (Char, Char) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> DoubleArray.zip(array: DoubleArray, transform: (Double, Double) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> FloatArray.zip(array: FloatArray, transform: (Float, Float) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> IntArray.zip(array: IntArray, transform: (Int, Int) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> LongArray.zip(array: LongArray, transform: (Long, Long) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
-    }
-    return list
-}
-
-/**
- * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
- */
-public inline fun <V> ShortArray.zip(array: ShortArray, transform: (Short, Short) -> V): List<V> {
-    val size = Math.min(size, array.size)
-    val list = ArrayList<V>(size)
-    for (i in 0..size-1) {
-        list.add(transform(this[i], array[i]))
+        list.add(transform(this[i], other[i]))
     }
     return list
 }
@@ -10106,6 +9963,158 @@ public inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (Short, R
     return list
 }
 
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun BooleanArray.zip(other: BooleanArray): List<Pair<Boolean, Boolean>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun ByteArray.zip(other: ByteArray): List<Pair<Byte, Byte>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun CharArray.zip(other: CharArray): List<Pair<Char, Char>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun DoubleArray.zip(other: DoubleArray): List<Pair<Double, Double>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun FloatArray.zip(other: FloatArray): List<Pair<Float, Float>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun LongArray.zip(other: LongArray): List<Pair<Long, Long>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public infix fun ShortArray.zip(other: ShortArray): List<Pair<Short, Short>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> BooleanArray.zip(other: BooleanArray, transform: (Boolean, Boolean) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> ByteArray.zip(other: ByteArray, transform: (Byte, Byte) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> CharArray.zip(other: CharArray, transform: (Char, Char) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> DoubleArray.zip(other: DoubleArray, transform: (Double, Double) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> FloatArray.zip(other: FloatArray, transform: (Float, Float) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> IntArray.zip(other: IntArray, transform: (Int, Int) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> LongArray.zip(other: LongArray, transform: (Long, Long) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
+/**
+ * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
+ */
+public inline fun <V> ShortArray.zip(other: ShortArray, transform: (Short, Short) -> V): List<V> {
+    val size = Math.min(size, other.size)
+    val list = ArrayList<V>(size)
+    for (i in 0..size-1) {
+        list.add(transform(this[i], other[i]))
+    }
+    return list
+}
+
 /**
  * Appends the string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
  * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
@@ -10599,10 +10608,10 @@ public fun BooleanArray.asList(): List<Boolean> {
     return object : AbstractList<Boolean>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Boolean): Boolean = this@asList.contains(o)
+        override fun contains(element: Boolean): Boolean = this@asList.contains(element)
         override fun get(index: Int): Boolean = this@asList[index]
-        override fun indexOf(o: Boolean): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Boolean): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Boolean): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Boolean): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10614,10 +10623,10 @@ public fun ByteArray.asList(): List<Byte> {
     return object : AbstractList<Byte>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Byte): Boolean = this@asList.contains(o)
+        override fun contains(element: Byte): Boolean = this@asList.contains(element)
         override fun get(index: Int): Byte = this@asList[index]
-        override fun indexOf(o: Byte): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Byte): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Byte): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Byte): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10629,10 +10638,10 @@ public fun CharArray.asList(): List<Char> {
     return object : AbstractList<Char>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Char): Boolean = this@asList.contains(o)
+        override fun contains(element: Char): Boolean = this@asList.contains(element)
         override fun get(index: Int): Char = this@asList[index]
-        override fun indexOf(o: Char): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Char): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Char): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Char): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10644,10 +10653,10 @@ public fun DoubleArray.asList(): List<Double> {
     return object : AbstractList<Double>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Double): Boolean = this@asList.contains(o)
+        override fun contains(element: Double): Boolean = this@asList.contains(element)
         override fun get(index: Int): Double = this@asList[index]
-        override fun indexOf(o: Double): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Double): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Double): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Double): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10659,10 +10668,10 @@ public fun FloatArray.asList(): List<Float> {
     return object : AbstractList<Float>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Float): Boolean = this@asList.contains(o)
+        override fun contains(element: Float): Boolean = this@asList.contains(element)
         override fun get(index: Int): Float = this@asList[index]
-        override fun indexOf(o: Float): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Float): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Float): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Float): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10674,10 +10683,10 @@ public fun IntArray.asList(): List<Int> {
     return object : AbstractList<Int>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Int): Boolean = this@asList.contains(o)
+        override fun contains(element: Int): Boolean = this@asList.contains(element)
         override fun get(index: Int): Int = this@asList[index]
-        override fun indexOf(o: Int): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Int): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Int): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Int): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10689,10 +10698,10 @@ public fun LongArray.asList(): List<Long> {
     return object : AbstractList<Long>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Long): Boolean = this@asList.contains(o)
+        override fun contains(element: Long): Boolean = this@asList.contains(element)
         override fun get(index: Int): Long = this@asList[index]
-        override fun indexOf(o: Long): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Long): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Long): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Long): Int = this@asList.lastIndexOf(element)
     }
 }
 
@@ -10704,10 +10713,10 @@ public fun ShortArray.asList(): List<Short> {
     return object : AbstractList<Short>(), RandomAccess {
         override val size: Int get() = this@asList.size
         override fun isEmpty(): Boolean = this@asList.isEmpty()
-        override fun contains(o: Short): Boolean = this@asList.contains(o)
+        override fun contains(element: Short): Boolean = this@asList.contains(element)
         override fun get(index: Int): Short = this@asList[index]
-        override fun indexOf(o: Short): Int = this@asList.indexOf(o)
-        override fun lastIndexOf(o: Short): Int = this@asList.lastIndexOf(o)
+        override fun indexOf(element: Short): Int = this@asList.indexOf(element)
+        override fun lastIndexOf(element: Short): Int = this@asList.lastIndexOf(element)
     }
 }
 
diff --git a/libraries/stdlib/src/generated/_Collections.kt b/libraries/stdlib/src/generated/_Collections.kt
index 6b6a6d19d6c..f3f66782237 100644
--- a/libraries/stdlib/src/generated/_Collections.kt
+++ b/libraries/stdlib/src/generated/_Collections.kt
@@ -992,13 +992,13 @@ public fun <T> Iterable<T>.toArrayList(): ArrayList<T> {
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(collection: C): C {
+public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
@@ -1088,18 +1088,18 @@ public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(dest
 }
 
 /**
- * Returns a map of the elements in original collection grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original collection grouped by the key returned by the given [selector] function.
  */
-public inline fun <T, K> Iterable<T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
-    return groupByTo(LinkedHashMap<K, MutableList<T>>(), toKey)
+public inline fun <T, K> Iterable<T>.groupBy(selector: (T) -> K): Map<K, List<T>> {
+    return groupByTo(LinkedHashMap<K, MutableList<T>>(), selector)
 }
 
 /**
- * Appends elements from original collection grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original collection grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <T, K> Iterable<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
+public inline fun <T, K> Iterable<T>.groupByTo(map: MutableMap<K, MutableList<T>>, selector: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
@@ -1193,14 +1193,15 @@ public fun <T> Iterable<T>.distinct(): List<T> {
 }
 
 /**
- * Returns a list containing only distinct elements from the given collection according to the [keySelector].
+ * Returns a list containing only elements from the given collection
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting list are in the same order as they were in the source collection.
  */
-public inline fun <T, K> Iterable<T>.distinctBy(keySelector: (T) -> K): List<T> {
+public inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T> {
     val set = HashSet<K>()
     val list = ArrayList<T>()
     for (e in this) {
-        val key = keySelector(e)
+        val key = selector(e)
         if (set.add(key))
             list.add(e)
     }
@@ -1315,18 +1316,18 @@ public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, R) -> R):
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun <T> Iterable<T>.forEach(operation: (T) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun <T> Iterable<T>.forEachIndexed(operation: (Int, T) -> Unit): Unit {
+public inline fun <T> Iterable<T>.forEachIndexed(action: (Int, T) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
@@ -1346,14 +1347,14 @@ public fun <T : Comparable<T>> Iterable<T>.max(): T? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Iterable<T>.maxBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Iterable<T>.maxBy(selector: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var maxElem = iterator.next()
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -1379,14 +1380,14 @@ public fun <T : Comparable<T>> Iterable<T>.min(): T? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Iterable<T>.minBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Iterable<T>.minBy(selector: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var minElem = iterator.next()
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -1438,23 +1439,23 @@ public inline fun <S, T: S> List<T>.reduceRight(operation: (T, S) -> S): S {
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the collection.
+ * Returns the sum of all values produced by [selector] function applied to each element in the collection.
  */
-public inline fun <T> Iterable<T>.sumBy(transform: (T) -> Int): Int {
+public inline fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the collection.
+ * Returns the sum of all values produced by [selector] function applied to each element in the collection.
  */
-public inline fun <T> Iterable<T>.sumByDouble(transform: (T) -> Double): Double {
+public inline fun <T> Iterable<T>.sumByDouble(selector: (T) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
@@ -1631,20 +1632,20 @@ public operator fun <T> Iterable<T>.plus(sequence: Sequence<T>): List<T> {
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public infix fun <T, R> Iterable<T>.zip(array: Array<out R>): List<Pair<T, R>> {
-    return zip(array) { t1, t2 -> t1 to t2 }
+public infix fun <T, R> Iterable<T>.zip(other: Array<out R>): List<Pair<T, R>> {
+    return zip(other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a list of values built from elements of both collections with same indexes using provided [transform]. List has length of shortest collection.
  */
-public inline fun <T, R, V> Iterable<T>.zip(array: Array<out R>, transform: (T, R) -> V): List<V> {
-    val arraySize = array.size
+public inline fun <T, R, V> Iterable<T>.zip(other: Array<out R>, transform: (T, R) -> V): List<V> {
+    val arraySize = other.size
     val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), arraySize))
     var i = 0
     for (element in this) {
         if (i >= arraySize) break
-        list.add(transform(element, array[i++]))
+        list.add(transform(element, other[i++]))
     }
     return list
 }
diff --git a/libraries/stdlib/src/generated/_Maps.kt b/libraries/stdlib/src/generated/_Maps.kt
index 38596846b8e..5ccbf6f8d45 100644
--- a/libraries/stdlib/src/generated/_Maps.kt
+++ b/libraries/stdlib/src/generated/_Maps.kt
@@ -128,23 +128,23 @@ public inline fun <K, V> Map<K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean
 }
 
 /**
- * Performs the given [operation] on each entry.
+ * Performs the given [action] on each entry.
  */
-public inline fun <K, V> Map<K, V>.forEach(operation: (Map.Entry<K, V>) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun <K, V> Map<K, V>.forEach(action: (Map.Entry<K, V>) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
  * Returns the first map entry yielding the largest value of the given function or `null` if there are no entries.
  */
-public inline fun <K, V, R : Comparable<R>> Map<K, V>.maxBy(f: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
+public inline fun <K, V, R : Comparable<R>> Map<K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var maxElem = iterator.next()
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -156,14 +156,14 @@ public inline fun <K, V, R : Comparable<R>> Map<K, V>.maxBy(f: (Map.Entry<K, V>)
 /**
  * Returns the first map entry yielding the smallest value of the given function or `null` if there are no entries.
  */
-public inline fun <K, V, R : Comparable<R>> Map<K, V>.minBy(f: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
+public inline fun <K, V, R : Comparable<R>> Map<K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var minElem = iterator.next()
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
diff --git a/libraries/stdlib/src/generated/_Sequences.kt b/libraries/stdlib/src/generated/_Sequences.kt
index 0e1b8530d21..fe6fb4ca544 100644
--- a/libraries/stdlib/src/generated/_Sequences.kt
+++ b/libraries/stdlib/src/generated/_Sequences.kt
@@ -488,13 +488,13 @@ public fun <T> Sequence<T>.toArrayList(): ArrayList<T> {
 }
 
 /**
- * Appends all elements to the given [collection].
+ * Appends all elements to the given [destination] collection.
  */
-public fun <T, C : MutableCollection<in T>> Sequence<T>.toCollection(collection: C): C {
+public fun <T, C : MutableCollection<in T>> Sequence<T>.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
@@ -582,18 +582,18 @@ public inline fun <T, R, C : MutableCollection<in R>> Sequence<T>.flatMapTo(dest
 }
 
 /**
- * Returns a map of the elements in original sequence grouped by the result of given [toKey] function.
+ * Returns a map of the elements in original sequence grouped by the key returned by the given [selector] function.
  */
-public inline fun <T, K> Sequence<T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
-    return groupByTo(LinkedHashMap<K, MutableList<T>>(), toKey)
+public inline fun <T, K> Sequence<T>.groupBy(selector: (T) -> K): Map<K, List<T>> {
+    return groupByTo(LinkedHashMap<K, MutableList<T>>(), selector)
 }
 
 /**
- * Appends elements from original sequence grouped by the result of given [toKey] function to the given [map].
+ * Appends elements from original sequence grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <T, K> Sequence<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
+public inline fun <T, K> Sequence<T>.groupByTo(map: MutableMap<K, MutableList<T>>, selector: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
@@ -687,11 +687,12 @@ public fun <T> Sequence<T>.distinct(): Sequence<T> {
 }
 
 /**
- * Returns a sequence containing only distinct elements from the given sequence according to the [keySelector].
+ * Returns a sequence containing only elements from the given sequence
+ * having distinct keys returned by the given [selector] function.
  * The elements in the resulting sequence are in the same order as they were in the source sequence.
  */
-public fun <T, K> Sequence<T>.distinctBy(keySelector: (T) -> K): Sequence<T> {
-    return DistinctSequence(this, keySelector)
+public fun <T, K> Sequence<T>.distinctBy(selector: (T) -> K): Sequence<T> {
+    return DistinctSequence(this, selector)
 }
 
 /**
@@ -755,18 +756,18 @@ public inline fun <T, R> Sequence<T>.fold(initial: R, operation: (R, T) -> R): R
 }
 
 /**
- * Performs the given [operation] on each element.
+ * Performs the given [action] on each element.
  */
-public inline fun <T> Sequence<T>.forEach(operation: (T) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun <T> Sequence<T>.forEach(action: (T) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each element, providing sequential index with the element.
+ * Performs the given [action] on each element, providing sequential index with the element.
  */
-public inline fun <T> Sequence<T>.forEachIndexed(operation: (Int, T) -> Unit): Unit {
+public inline fun <T> Sequence<T>.forEachIndexed(action: (Int, T) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
@@ -786,14 +787,14 @@ public fun <T : Comparable<T>> Sequence<T>.max(): T? {
 /**
  * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Sequence<T>.maxBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Sequence<T>.maxBy(selector: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var maxElem = iterator.next()
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -819,14 +820,14 @@ public fun <T : Comparable<T>> Sequence<T>.min(): T? {
 /**
  * Returns the first element yielding the smallest value of the given function or `null` if there are no elements.
  */
-public inline fun <R : Comparable<R>, T : Any> Sequence<T>.minBy(f: (T) -> R): T? {
+public inline fun <R : Comparable<R>, T : Any> Sequence<T>.minBy(selector: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
     var minElem = iterator.next()
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -865,23 +866,23 @@ public inline fun <S, T: S> Sequence<T>.reduce(operation: (S, T) -> S): S {
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the sequence.
+ * Returns the sum of all values produced by [selector] function applied to each element in the sequence.
  */
-public inline fun <T> Sequence<T>.sumBy(transform: (T) -> Int): Int {
+public inline fun <T> Sequence<T>.sumBy(selector: (T) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each element in the sequence.
+ * Returns the sum of all values produced by [selector] function applied to each element in the sequence.
  */
-public inline fun <T> Sequence<T>.sumByDouble(transform: (T) -> Double): Double {
+public inline fun <T> Sequence<T>.sumByDouble(selector: (T) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
@@ -1007,18 +1008,18 @@ public operator fun <T> Sequence<T>.plus(sequence: Sequence<T>): Sequence<T> {
 }
 
 /**
- * Returns a sequence of pairs built from elements of both collections with same indexes.
+ * Returns a sequence of pairs built from elements of both sequences with same indexes.
  * Resulting sequence has length of shortest input sequence.
  */
-public infix fun <T, R> Sequence<T>.zip(sequence: Sequence<R>): Sequence<Pair<T, R>> {
-    return MergingSequence(this, sequence) { t1, t2 -> t1 to t2 }
+public infix fun <T, R> Sequence<T>.zip(other: Sequence<R>): Sequence<Pair<T, R>> {
+    return MergingSequence(this, other) { t1, t2 -> t1 to t2 }
 }
 
 /**
  * Returns a sequence of values built from elements of both collections with same indexes using provided [transform]. Resulting sequence has length of shortest input sequences.
  */
-public fun <T, R, V> Sequence<T>.zip(sequence: Sequence<R>, transform: (T, R) -> V): Sequence<V> {
-    return MergingSequence(this, sequence, transform)
+public fun <T, R, V> Sequence<T>.zip(other: Sequence<R>, transform: (T, R) -> V): Sequence<V> {
+    return MergingSequence(this, other, transform)
 }
 
 /**
diff --git a/libraries/stdlib/src/generated/_Strings.kt b/libraries/stdlib/src/generated/_Strings.kt
index 46a6b395e0c..f1fdeb80ceb 100644
--- a/libraries/stdlib/src/generated/_Strings.kt
+++ b/libraries/stdlib/src/generated/_Strings.kt
@@ -747,24 +747,24 @@ public fun String.toArrayList(): ArrayList<Char> {
 }
 
 /**
- * Appends all characters to the given [collection].
+ * Appends all characters to the given [destination] collection.
  */
-public fun <C : MutableCollection<in Char>> CharSequence.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Char>> CharSequence.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
- * Appends all characters to the given [collection].
+ * Appends all characters to the given [destination] collection.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public fun <C : MutableCollection<in Char>> String.toCollection(collection: C): C {
+public fun <C : MutableCollection<in Char>> String.toCollection(destination: C): C {
     for (item in this) {
-        collection.add(item)
+        destination.add(item)
     }
-    return collection
+    return destination
 }
 
 /**
@@ -940,26 +940,26 @@ public inline fun <R, C : MutableCollection<in R>> String.flatMapTo(destination:
 }
 
 /**
- * Returns a map of the characters in original char sequence grouped by the result of given [toKey] function.
+ * Returns a map of the characters in original char sequence grouped by the key returned by the given [selector] function.
  */
-public inline fun <K> CharSequence.groupBy(toKey: (Char) -> K): Map<K, List<Char>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), toKey)
+public inline fun <K> CharSequence.groupBy(selector: (Char) -> K): Map<K, List<Char>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), selector)
 }
 
 /**
- * Returns a map of the characters in original string grouped by the result of given [toKey] function.
+ * Returns a map of the characters in original string grouped by the key returned by the given [selector] function.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun <K> String.groupBy(toKey: (Char) -> K): Map<K, List<Char>> {
-    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), toKey)
+public inline fun <K> String.groupBy(selector: (Char) -> K): Map<K, List<Char>> {
+    return groupByTo(LinkedHashMap<K, MutableList<Char>>(), selector)
 }
 
 /**
- * Appends characters from original char sequence grouped by the result of given [toKey] function to the given [map].
+ * Appends characters from original char sequence grouped by the key returned by the given [selector] function to the given [map].
  */
-public inline fun <K> CharSequence.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K): Map<K, MutableList<Char>> {
+public inline fun <K> CharSequence.groupByTo(map: MutableMap<K, MutableList<Char>>, selector: (Char) -> K): Map<K, MutableList<Char>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Char>() }
         list.add(element)
     }
@@ -967,12 +967,12 @@ public inline fun <K> CharSequence.groupByTo(map: MutableMap<K, MutableList<Char
 }
 
 /**
- * Appends characters from original string grouped by the result of given [toKey] function to the given [map].
+ * Appends characters from original string grouped by the key returned by the given [selector] function to the given [map].
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun <K> String.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K): Map<K, MutableList<Char>> {
+public inline fun <K> String.groupByTo(map: MutableMap<K, MutableList<Char>>, selector: (Char) -> K): Map<K, MutableList<Char>> {
     for (element in this) {
-        val key = toKey(element)
+        val key = selector(element)
         val list = map.getOrPut(key) { ArrayList<Char>() }
         list.add(element)
     }
@@ -1236,35 +1236,35 @@ public inline fun <R> String.foldRight(initial: R, operation: (Char, R) -> R): R
 }
 
 /**
- * Performs the given [operation] on each character.
+ * Performs the given [action] on each character.
  */
-public inline fun CharSequence.forEach(operation: (Char) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun CharSequence.forEach(action: (Char) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each character.
+ * Performs the given [action] on each character.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun String.forEach(operation: (Char) -> Unit): Unit {
-    for (element in this) operation(element)
+public inline fun String.forEach(action: (Char) -> Unit): Unit {
+    for (element in this) action(element)
 }
 
 /**
- * Performs the given [operation] on each character, providing sequential index with the character.
+ * Performs the given [action] on each character, providing sequential index with the character.
  */
-public inline fun CharSequence.forEachIndexed(operation: (Int, Char) -> Unit): Unit {
+public inline fun CharSequence.forEachIndexed(action: (Int, Char) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
- * Performs the given [operation] on each character, providing sequential index with the character.
+ * Performs the given [action] on each character, providing sequential index with the character.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun String.forEachIndexed(operation: (Int, Char) -> Unit): Unit {
+public inline fun String.forEachIndexed(action: (Int, Char) -> Unit): Unit {
     var index = 0
-    for (item in this) operation(index++, item)
+    for (item in this) action(index++, item)
 }
 
 /**
@@ -1297,13 +1297,13 @@ public fun String.max(): Char? {
 /**
  * Returns the first character yielding the largest value of the given function or `null` if there are no characters.
  */
-public inline fun <R : Comparable<R>> CharSequence.maxBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> CharSequence.maxBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -1316,13 +1316,13 @@ public inline fun <R : Comparable<R>> CharSequence.maxBy(f: (Char) -> R): Char?
  * Returns the first character yielding the largest value of the given function or `null` if there are no characters.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun <R : Comparable<R>> String.maxBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> String.maxBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var maxElem = this[0]
-    var maxValue = f(maxElem)
+    var maxValue = selector(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (maxValue < v) {
             maxElem = e
             maxValue = v
@@ -1361,13 +1361,13 @@ public fun String.min(): Char? {
 /**
  * Returns the first character yielding the smallest value of the given function or `null` if there are no characters.
  */
-public inline fun <R : Comparable<R>> CharSequence.minBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> CharSequence.minBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -1380,13 +1380,13 @@ public inline fun <R : Comparable<R>> CharSequence.minBy(f: (Char) -> R): Char?
  * Returns the first character yielding the smallest value of the given function or `null` if there are no characters.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun <R : Comparable<R>> String.minBy(f: (Char) -> R): Char? {
+public inline fun <R : Comparable<R>> String.minBy(selector: (Char) -> R): Char? {
     if (isEmpty()) return null
     var minElem = this[0]
-    var minValue = f(minElem)
+    var minValue = selector(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
-        val v = f(e)
+        val v = selector(e)
         if (minValue > v) {
             minElem = e
             minValue = v
@@ -1484,47 +1484,47 @@ public inline fun String.reduceRight(operation: (Char, Char) -> Char): Char {
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each character in the char sequence.
+ * Returns the sum of all values produced by [selector] function applied to each character in the char sequence.
  */
-public inline fun CharSequence.sumBy(transform: (Char) -> Int): Int {
+public inline fun CharSequence.sumBy(selector: (Char) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each character in the string.
+ * Returns the sum of all values produced by [selector] function applied to each character in the string.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun String.sumBy(transform: (Char) -> Int): Int {
+public inline fun String.sumBy(selector: (Char) -> Int): Int {
     var sum: Int = 0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each character in the char sequence.
+ * Returns the sum of all values produced by [selector] function applied to each character in the char sequence.
  */
-public inline fun CharSequence.sumByDouble(transform: (Char) -> Double): Double {
+public inline fun CharSequence.sumByDouble(selector: (Char) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
 
 /**
- * Returns the sum of all values produced by [transform] function applied to each character in the string.
+ * Returns the sum of all values produced by [selector] function applied to each character in the string.
  */
 @Deprecated("Provided for binary compatibility", level = DeprecationLevel.HIDDEN)
-public inline fun String.sumByDouble(transform: (Char) -> Double): Double {
+public inline fun String.sumByDouble(selector: (Char) -> Double): Double {
     var sum: Double = 0.0
     for (element in this) {
-        sum += transform(element)
+        sum += selector(element)
     }
     return sum
 }
diff --git a/libraries/stdlib/src/kotlin/io/Constants.kt b/libraries/stdlib/src/kotlin/io/Constants.kt
index 7905f8f3df8..9838589ef1b 100644
--- a/libraries/stdlib/src/kotlin/io/Constants.kt
+++ b/libraries/stdlib/src/kotlin/io/Constants.kt
@@ -5,7 +5,7 @@ package kotlin.io
 
 /**
  * Returns the default buffer size when working with buffered streams.
- */
+*/
 public val defaultBufferSize: Int = 64 * 1024
 /**
  * Returns the default block size for forEachBlock().
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
index cbd3ad494d3..195d84a5250 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
@@ -111,34 +111,34 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("sumBy(transform: (T) -> Int)") {
+    templates add f("sumBy(selector: (T) -> Int)") {
         inline(true)
         include(CharSequences, Strings)
         deprecate(Strings) { forBinaryCompatibility }
-        doc { f -> "Returns the sum of all values produced by [transform] function applied to each ${f.element} in the ${f.collection}." }
+        doc { f -> "Returns the sum of all values produced by [selector] function applied to each ${f.element} in the ${f.collection}." }
         returns("Int")
         body {
             """
             var sum: Int = 0
             for (element in this) {
-                sum += transform(element)
+                sum += selector(element)
             }
             return sum
             """
         }
     }
 
-    templates add f("sumByDouble(transform: (T) -> Double)") {
+    templates add f("sumByDouble(selector: (T) -> Double)") {
         inline(true)
         include(CharSequences, Strings)
         deprecate(Strings) { forBinaryCompatibility }
-        doc { f -> "Returns the sum of all values produced by [transform] function applied to each ${f.element} in the ${f.collection}." }
+        doc { f -> "Returns the sum of all values produced by [selector] function applied to each ${f.element} in the ${f.collection}." }
         returns("Double")
         body {
             """
             var sum: Double = 0.0
             for (element in this) {
-                sum += transform(element)
+                sum += selector(element)
             }
             return sum
             """
@@ -177,7 +177,7 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("minBy(f: (T) -> R)") {
+    templates add f("minBy(selector: (T) -> R)") {
         inline(true)
 
         doc { f -> "Returns the first ${f.element} yielding the smallest value of the given function or `null` if there are no ${f.element}s." }
@@ -190,10 +190,10 @@ fun aggregates(): List<GenericFunction> {
             if (!iterator.hasNext()) return null
 
             var minElem = iterator.next()
-            var minValue = f(minElem)
+            var minValue = selector(minElem)
             while (iterator.hasNext()) {
                 val e = iterator.next()
-                val v = f(e)
+                val v = selector(e)
                 if (minValue > v) {
                     minElem = e
                     minValue = v
@@ -208,10 +208,10 @@ fun aggregates(): List<GenericFunction> {
             if (isEmpty()) return null
 
             var minElem = this[0]
-            var minValue = f(minElem)
+            var minValue = selector(minElem)
             for (i in 1..lastIndex) {
                 val e = this[i]
-                val v = f(e)
+                val v = selector(e)
                 if (minValue > v) {
                     minElem = e
                     minValue = v
@@ -222,7 +222,7 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("minBy(f: (T) -> R)") {
+    templates add f("minBy(selector: (T) -> R)") {
         inline(true)
 
         only(Maps)
@@ -235,10 +235,10 @@ fun aggregates(): List<GenericFunction> {
             if (!iterator.hasNext()) return null
 
             var minElem = iterator.next()
-            var minValue = f(minElem)
+            var minValue = selector(minElem)
             while (iterator.hasNext()) {
                 val e = iterator.next()
-                val v = f(e)
+                val v = selector(e)
                 if (minValue > v) {
                     minElem = e
                     minValue = v
@@ -283,7 +283,7 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("maxBy(f: (T) -> R)") {
+    templates add f("maxBy(selector: (T) -> R)") {
         inline(true)
 
         doc { f -> "Returns the first ${f.element} yielding the largest value of the given function or `null` if there are no ${f.element}s." }
@@ -296,10 +296,10 @@ fun aggregates(): List<GenericFunction> {
             if (!iterator.hasNext()) return null
 
             var maxElem = iterator.next()
-            var maxValue = f(maxElem)
+            var maxValue = selector(maxElem)
             while (iterator.hasNext()) {
                 val e = iterator.next()
-                val v = f(e)
+                val v = selector(e)
                 if (maxValue < v) {
                     maxElem = e
                     maxValue = v
@@ -314,10 +314,10 @@ fun aggregates(): List<GenericFunction> {
             if (isEmpty()) return null
 
             var maxElem = this[0]
-            var maxValue = f(maxElem)
+            var maxValue = selector(maxElem)
             for (i in 1..lastIndex) {
                 val e = this[i]
-                val v = f(e)
+                val v = selector(e)
                 if (maxValue < v) {
                     maxElem = e
                     maxValue = v
@@ -328,7 +328,7 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("maxBy(f: (T) -> R)") {
+    templates add f("maxBy(selector: (T) -> R)") {
         inline(true)
 
         only(Maps)
@@ -341,10 +341,10 @@ fun aggregates(): List<GenericFunction> {
             if (!iterator.hasNext()) return null
 
             var maxElem = iterator.next()
-            var maxValue = f(maxElem)
+            var maxValue = selector(maxElem)
             while (iterator.hasNext()) {
                 val e = iterator.next()
-                val v = f(e)
+                val v = selector(e)
                 if (maxValue < v) {
                     maxElem = e
                     maxValue = v
@@ -482,30 +482,30 @@ fun aggregates(): List<GenericFunction> {
         }
     }
 
-    templates add f("forEach(operation: (T) -> Unit)") {
+    templates add f("forEach(action: (T) -> Unit)") {
         inline(true)
 
-        doc { f -> "Performs the given [operation] on each ${f.element}." }
+        doc { f -> "Performs the given [action] on each ${f.element}." }
         returns("Unit")
         body {
             """
-            for (element in this) operation(element)
+            for (element in this) action(element)
             """
         }
         deprecate(Strings) { forBinaryCompatibility }
         include(Maps, CharSequences, Strings)
     }
 
-    templates add f("forEachIndexed(operation: (Int, T) -> Unit)") {
+    templates add f("forEachIndexed(action: (Int, T) -> Unit)") {
         inline(true)
         deprecate(Strings) { forBinaryCompatibility }
         include(CharSequences, Strings)
-        doc { f -> "Performs the given [operation] on each ${f.element}, providing sequential index with the ${f.element}." }
+        doc { f -> "Performs the given [action] on each ${f.element}, providing sequential index with the ${f.element}." }
         returns("Unit")
         body {
             """
             var index = 0
-            for (item in this) operation(index++, item)
+            for (item in this) action(index++, item)
             """
         }
     }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
index f8a14af3ae1..84d202c211a 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
@@ -480,7 +480,7 @@ fun generators(): List<GenericFunction> {
         }
     }
 
-    templates add f("zip(array: Array<out R>, transform: (T, R) -> V)") {
+    templates add f("zip(other: Array<out R>, transform: (T, R) -> V)") {
         exclude(Sequences)
         doc {
             """
@@ -493,22 +493,22 @@ fun generators(): List<GenericFunction> {
         inline(true)
         body {
             """
-            val arraySize = array.size
+            val arraySize = other.size
             val list = ArrayList<V>(Math.min(collectionSizeOrDefault(10), arraySize))
             var i = 0
             for (element in this) {
                 if (i >= arraySize) break
-                list.add(transform(element, array[i++]))
+                list.add(transform(element, other[i++]))
             }
             return list
             """
         }
         body(ArraysOfObjects, ArraysOfPrimitives) {
             """
-            val size = Math.min(size, array.size)
+            val size = Math.min(size, other.size)
             val list = ArrayList<V>(size)
             for (i in 0..size-1) {
-                list.add(transform(this[i], array[i]))
+                list.add(transform(this[i], other[i]))
             }
             return list
             """
@@ -516,7 +516,7 @@ fun generators(): List<GenericFunction> {
 
     }
 
-    templates add f("zip(array: SELF, transform: (T, T) -> V)") {
+    templates add f("zip(other: SELF, transform: (T, T) -> V)") {
         only(ArraysOfPrimitives)
         doc {
             """
@@ -528,17 +528,17 @@ fun generators(): List<GenericFunction> {
         inline(true)
         body() {
             """
-            val size = Math.min(size, array.size)
+            val size = Math.min(size, other.size)
             val list = ArrayList<V>(size)
             for (i in 0..size-1) {
-                list.add(transform(this[i], array[i]))
+                list.add(transform(this[i], other[i]))
             }
             return list
             """
         }
     }
 
-    templates add f("zip(sequence: Sequence<R>, transform: (T, R) -> V)") {
+    templates add f("zip(other: Sequence<R>, transform: (T, R) -> V)") {
         only(Sequences)
         doc {
             """
@@ -550,7 +550,7 @@ fun generators(): List<GenericFunction> {
         returns("Sequence<V>")
         body {
             """
-            return MergingSequence(this, sequence, transform)
+            return MergingSequence(this, other, transform)
             """
         }
     }
@@ -614,7 +614,7 @@ fun generators(): List<GenericFunction> {
         }
     }
 
-    templates add f("zip(array: Array<out R>)") {
+    templates add f("zip(other: Array<out R>)") {
         infix(true)
         exclude(Sequences)
         doc {
@@ -626,12 +626,12 @@ fun generators(): List<GenericFunction> {
         returns("List<Pair<T, R>>")
         body {
             """
-            return zip(array) { t1, t2 -> t1 to t2 }
+            return zip(other) { t1, t2 -> t1 to t2 }
             """
         }
     }
 
-    templates add f("zip(array: SELF)") {
+    templates add f("zip(other: SELF)") {
         infix(true)
         only(ArraysOfPrimitives)
         doc {
@@ -642,17 +642,17 @@ fun generators(): List<GenericFunction> {
         returns("List<Pair<T, T>>")
         body {
             """
-            return zip(array) { t1, t2 -> t1 to t2 }
+            return zip(other) { t1, t2 -> t1 to t2 }
             """
         }
     }
 
-    templates add f("zip(sequence: Sequence<R>)") {
+    templates add f("zip(other: Sequence<R>)") {
         infix(true)
         only(Sequences)
         doc {
             """
-            Returns a sequence of pairs built from elements of both collections with same indexes.
+            Returns a sequence of pairs built from elements of both sequences with same indexes.
             Resulting sequence has length of shortest input sequence.
             """
         }
@@ -660,7 +660,7 @@ fun generators(): List<GenericFunction> {
         returns("Sequence<Pair<T, R>>")
         body {
             """
-            return MergingSequence(this, sequence) { t1, t2 -> t1 to t2 }
+            return MergingSequence(this, other) { t1, t2 -> t1 to t2 }
             """
         }
     }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
index f4e0c18ffcd..41d05eea1d4 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
@@ -284,29 +284,29 @@ fun mapping(): List<GenericFunction> {
         }
     }
 
-    templates add f("groupBy(toKey: (T) -> K)") {
+    templates add f("groupBy(selector: (T) -> K)") {
         inline(true)
 
         deprecate(Strings) { forBinaryCompatibility }
         include(CharSequences, Strings)
-        doc { f -> "Returns a map of the ${f.element}s in original ${f.collection} grouped by the result of given [toKey] function." }
+        doc { f -> "Returns a map of the ${f.element}s in original ${f.collection} grouped by the key returned by the given [selector] function." }
         typeParam("K")
         returns("Map<K, List<T>>")
-        body { "return groupByTo(LinkedHashMap<K, MutableList<T>>(), toKey)" }
+        body { "return groupByTo(LinkedHashMap<K, MutableList<T>>(), selector)" }
     }
 
-    templates add f("groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K)") {
+    templates add f("groupByTo(map: MutableMap<K, MutableList<T>>, selector: (T) -> K)") {
         inline(true)
 
         deprecate(Strings) { forBinaryCompatibility }
         include(CharSequences, Strings)
         typeParam("K")
-        doc { f -> "Appends ${f.element}s from original ${f.collection} grouped by the result of given [toKey] function to the given [map]." }
+        doc { f -> "Appends ${f.element}s from original ${f.collection} grouped by the key returned by the given [selector] function to the given [map]." }
         returns("Map<K, MutableList<T>>")
         body {
             """
                 for (element in this) {
-                    val key = toKey(element)
+                    val key = selector(element)
                     val list = map.getOrPut(key) { ArrayList<T>() }
                     list.add(element)
                 }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Sets.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Sets.kt
index 3cd28b5c29d..e06f951e82a 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Sets.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Sets.kt
@@ -50,11 +50,12 @@ fun sets(): List<GenericFunction> {
         body(Sequences) { "return this.distinctBy { it }" }
     }
 
-    templates add f("distinctBy(keySelector: (T) -> K)") {
+    templates add f("distinctBy(selector: (T) -> K)") {
         exclude(Strings)
         doc { f ->
             """
-                Returns a ${f.mapResult} containing only distinct ${f.element}s from the given ${f.collection} according to the [keySelector].
+                Returns a ${f.mapResult} containing only ${f.element}s from the given ${f.collection}
+                having distinct keys returned by the given [selector] function.
 
                 The ${f.element}s in the resulting ${f.mapResult} are in the same order as they were in the source ${f.collection}.
                 """
@@ -68,7 +69,7 @@ fun sets(): List<GenericFunction> {
             val set = HashSet<K>()
             val list = ArrayList<T>()
             for (e in this) {
-                val key = keySelector(e)
+                val key = selector(e)
                 if (set.add(key))
                     list.add(e)
             }
@@ -80,7 +81,7 @@ fun sets(): List<GenericFunction> {
         returns(Sequences) { "Sequence<T>" }
         body(Sequences) {
             """
-            return DistinctSequence(this, keySelector)
+            return DistinctSequence(this, selector)
             """
         }
 
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
index d5ea9fbe3e9..a63e6a833a1 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
@@ -5,18 +5,18 @@ import templates.Family.*
 fun snapshots(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
-    templates add f("toCollection(collection: C)") {
+    templates add f("toCollection(destination: C)") {
         deprecate(Strings) { forBinaryCompatibility }
         include(CharSequences, Strings)
-        doc { f -> "Appends all ${f.element}s to the given [collection]." }
+        doc { f -> "Appends all ${f.element}s to the given [destination] collection." }
         returns("C")
         typeParam("C : MutableCollection<in T>")
         body {
             """
             for (item in this) {
-                collection.add(item)
+                destination.add(item)
             }
-            return collection
+            return destination
             """
         }
     }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
index b0ed8b40b35..8f601ee90c3 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
@@ -244,15 +244,16 @@ fun specialJVM(): List<GenericFunction> {
             """
         }
 
+        // TODO: Use own readonly kotlin.AbstractList
         body(ArraysOfPrimitives) {
             """
             return object : AbstractList<T>(), RandomAccess {
                 override val size: Int get() = this@asList.size
                 override fun isEmpty(): Boolean = this@asList.isEmpty()
-                override fun contains(o: T): Boolean = this@asList.contains(o)
+                override fun contains(element: T): Boolean = this@asList.contains(element)
                 override fun get(index: Int): T = this@asList[index]
-                override fun indexOf(o: T): Int = this@asList.indexOf(o)
-                override fun lastIndexOf(o: T): Int = this@asList.lastIndexOf(o)
+                override fun indexOf(element: T): Int = this@asList.indexOf(element)
+                override fun lastIndexOf(element: T): Int = this@asList.lastIndexOf(element)
             }
             """
         }