Introduce minByOrNull and maxByOrNull extension functions #KT-38854

libraries/stdlib/test/collections/ArraysTest.kt

@@ -412,63 +412,63 @@ class ArraysTest {
         expect(-4, { intArrayOf(2, 3, -4).maxWith(compareBy { it*it }) })
     }
 
-    @Test fun minBy() {
-        expect(null, { arrayOf<Int>().minBy { it } })
-        expect(1, { arrayOf(1).minBy { it } })
-        expect(3, { arrayOf(2, 3).minBy { -it } })
-        expect('a', { arrayOf('a', 'b').minBy { "x$it" } })
-        expect("b", { arrayOf("b", "abc").minBy { it.length } })
+    @Test fun minByOrNull() {
+        expect(null, { arrayOf<Int>().minByOrNull { it } })
+        expect(1, { arrayOf(1).minByOrNull { it } })
+        expect(3, { arrayOf(2, 3).minByOrNull { -it } })
+        expect('a', { arrayOf('a', 'b').minByOrNull { "x$it" } })
+        expect("b", { arrayOf("b", "abc").minByOrNull { it.length } })
     }
 
-    @Test fun minByInPrimitiveArrays() {
-        expect(null, { intArrayOf().minBy { it } })
-        expect(1, { intArrayOf(1).minBy { it } })
-        expect(3, { intArrayOf(2, 3).minBy { -it } })
-        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minBy { it + 1 } })
-        expect(1, { byteArrayOf(1, 3, 2).minBy { it * it } })
-        expect(3, { shortArrayOf(3, 2).minBy { "a" } })
-        expect(2.0F, { floatArrayOf(3.0F, 2.0F).minBy { it.toString() } })
-        expect(2.0, { doubleArrayOf(2.0, 3.0).minBy { it * it } })
+    @Test fun minByOrNullInPrimitiveArrays() {
+        expect(null, { intArrayOf().minByOrNull { it } })
+        expect(1, { intArrayOf(1).minByOrNull { it } })
+        expect(3, { intArrayOf(2, 3).minByOrNull { -it } })
+        expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minByOrNull { it + 1 } })
+        expect(1, { byteArrayOf(1, 3, 2).minByOrNull { it * it } })
+        expect(3, { shortArrayOf(3, 2).minByOrNull { "a" } })
+        expect(2.0F, { floatArrayOf(3.0F, 2.0F).minByOrNull { it.toString() } })
+        expect(2.0, { doubleArrayOf(2.0, 3.0).minByOrNull { it * it } })
     }
 
-    @Test fun maxBy() {
-        expect(null, { arrayOf<Int>().maxBy { it } })
-        expect(1, { arrayOf(1).maxBy { it } })
-        expect(2, { arrayOf(2, 3).maxBy { -it } })
-        expect('b', { arrayOf('a', 'b').maxBy { "x$it" } })
-        expect("abc", { arrayOf("b", "abc").maxBy { it.length } })
+    @Test fun maxByOrNull() {
+        expect(null, { arrayOf<Int>().maxByOrNull { it } })
+        expect(1, { arrayOf(1).maxByOrNull { it } })
+        expect(2, { arrayOf(2, 3).maxByOrNull { -it } })
+        expect('b', { arrayOf('a', 'b').maxByOrNull { "x$it" } })
+        expect("abc", { arrayOf("b", "abc").maxByOrNull { it.length } })
     }
 
-    @Test fun maxByInPrimitiveArrays() {
-        expect(null, { intArrayOf().maxBy { it } })
-        expect(1, { intArrayOf(1).maxBy { it } })
-        expect(2, { intArrayOf(2, 3).maxBy { -it } })
-        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxBy { it + 1 } })
-        expect(3, { byteArrayOf(1, 3, 2).maxBy { it * it } })
-        expect(3, { shortArrayOf(3, 2).maxBy { "a" } })
-        expect(3.0F, { floatArrayOf(3.0F, 2.0F).maxBy { it.toString() } })
-        expect(3.0, { doubleArrayOf(2.0, 3.0).maxBy { it * it } })
+    @Test fun maxByOrNullInPrimitiveArrays() {
+        expect(null, { intArrayOf().maxByOrNull { it } })
+        expect(1, { intArrayOf(1).maxByOrNull { it } })
+        expect(2, { intArrayOf(2, 3).maxByOrNull { -it } })
+        expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxByOrNull { it + 1 } })
+        expect(3, { byteArrayOf(1, 3, 2).maxByOrNull { it * it } })
+        expect(3, { shortArrayOf(3, 2).maxByOrNull { "a" } })
+        expect(3.0F, { floatArrayOf(3.0F, 2.0F).maxByOrNull { it.toString() } })
+        expect(3.0, { doubleArrayOf(2.0, 3.0).maxByOrNull { it * it } })
     }
 
     @Test fun minIndex() {
         val a = intArrayOf(1, 7, 9, -42, 54, 93)
-        expect(3, { a.indices.minBy { a[it] } })
+        expect(3, { a.indices.minByOrNull { a[it] } })
     }
 
     @Test fun maxIndex() {
         val a = intArrayOf(1, 7, 9, 239, 54, 93)
-        expect(3, { a.indices.maxBy { a[it] } })
+        expect(3, { a.indices.maxByOrNull { a[it] } })
     }
 
     @Test fun minByEvaluateOnce() {
         var c = 0
-        expect(1, { arrayOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
+        expect(1, { arrayOf(5, 4, 3, 2, 1).minByOrNull { c++; it * it } })
         assertEquals(5, c)
     }
 
     @Test fun maxByEvaluateOnce() {
         var c = 0
-        expect(5, { arrayOf(5, 4, 3, 2, 1).maxBy { c++; it * it } })
+        expect(5, { arrayOf(5, 4, 3, 2, 1).maxByOrNull { c++; it * it } })
         assertEquals(5, c)
     }
 

libraries/stdlib/test/collections/CollectionTest.kt

@@ -865,41 +865,41 @@ class CollectionTest {
         expect("B", { listOf("a", "B").asSequence().maxWith(STRING_CASE_INSENSITIVE_ORDER) })
     }
 
-    @Test fun minBy() {
-        expect(null, { listOf<Int>().minBy { it } })
-        expect(1, { listOf(1).minBy { it } })
-        expect(3, { listOf(2, 3).minBy { -it } })
-        expect('a', { listOf('a', 'b').minBy { "x$it" } })
-        expect("b", { listOf("b", "abc").minBy { it.length } })
-        expect(null, { listOf<Int>().asSequence().minBy { it } })
-        expect(3, { listOf(2, 3).asSequence().minBy { -it } })
+    @Test fun minByOrNull() {
+        expect(null, { listOf<Int>().minByOrNull { it } })
+        expect(1, { listOf(1).minByOrNull { it } })
+        expect(3, { listOf(2, 3).minByOrNull { -it } })
+        expect('a', { listOf('a', 'b').minByOrNull { "x$it" } })
+        expect("b", { listOf("b", "abc").minByOrNull { it.length } })
+        expect(null, { listOf<Int>().asSequence().minByOrNull { it } })
+        expect(3, { listOf(2, 3).asSequence().minByOrNull { -it } })
     }
 
-    @Test fun maxBy() {
-        expect(null, { listOf<Int>().maxBy { it } })
-        expect(1, { listOf(1).maxBy { it } })
-        expect(2, { listOf(2, 3).maxBy { -it } })
-        expect('b', { listOf('a', 'b').maxBy { "x$it" } })
-        expect("abc", { listOf("b", "abc").maxBy { it.length } })
-        expect(null, { listOf<Int>().asSequence().maxBy { it } })
-        expect(2, { listOf(2, 3).asSequence().maxBy { -it } })
+    @Test fun maxByOrNull() {
+        expect(null, { listOf<Int>().maxByOrNull { it } })
+        expect(1, { listOf(1).maxByOrNull { it } })
+        expect(2, { listOf(2, 3).maxByOrNull { -it } })
+        expect('b', { listOf('a', 'b').maxByOrNull { "x$it" } })
+        expect("abc", { listOf("b", "abc").maxByOrNull { it.length } })
+        expect(null, { listOf<Int>().asSequence().maxByOrNull { it } })
+        expect(2, { listOf(2, 3).asSequence().maxByOrNull { -it } })
     }
 
-    @Test fun minByEvaluateOnce() {
+    @Test fun minByOrNullEvaluateOnce() {
         var c = 0
-        expect(1, { listOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
+        expect(1, { listOf(5, 4, 3, 2, 1).minByOrNull { c++; it * it } })
         assertEquals(5, c)
         c = 0
-        expect(1, { listOf(5, 4, 3, 2, 1).asSequence().minBy { c++; it * it } })
+        expect(1, { listOf(5, 4, 3, 2, 1).asSequence().minByOrNull { c++; it * it } })
         assertEquals(5, c)
     }
 
-    @Test fun maxByEvaluateOnce() {
+    @Test fun maxByOrNullEvaluateOnce() {
         var c = 0
-        expect(5, { listOf(5, 4, 3, 2, 1).maxBy { c++; it * it } })
+        expect(5, { listOf(5, 4, 3, 2, 1).maxByOrNull { c++; it * it } })
         assertEquals(5, c)
         c = 0
-        expect(5, { listOf(5, 4, 3, 2, 1).asSequence().maxBy { c++; it * it } })
+        expect(5, { listOf(5, 4, 3, 2, 1).asSequence().maxByOrNull { c++; it * it } })
         assertEquals(5, c)
     }
 

libraries/stdlib/test/collections/IterableTests.kt

@@ -396,13 +396,13 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
     @Test
     fun maxOrNull() {
         expect("foo") { data.maxOrNull() }
-        expect("bar") { data.maxBy { it.last() } }
+        expect("bar") { data.maxByOrNull { it.last() } }
     }
 
     @Test
     fun minOrNull() {
         expect("bar") { data.minOrNull() }
-        expect("foo") { data.minBy { it.last() } }
+        expect("foo") { data.minByOrNull { it.last() } }
     }
 
     @Test

libraries/stdlib/test/collections/UnsignedArraysTest.kt

@@ -483,35 +483,35 @@ class UnsignedArraysTest {
     }
 
     @Test
-    fun minBy() {
-        expect(null) { arrayOf<UByte>().minBy { it * it } }
-        expect(1u) { arrayOf<UShort>(1).minBy { it * it } }
-        expect(2u) { arrayOf<UInt>(2, 3).minBy { it * it } }
-        expect(3uL) { arrayOf<ULong>(3, 2).minBy { it - 3 } }
+    fun minByOrNull() {
+        expect(null) { arrayOf<UByte>().minByOrNull { it * it } }
+        expect(1u) { arrayOf<UShort>(1).minByOrNull { it * it } }
+        expect(2u) { arrayOf<UInt>(2, 3).minByOrNull { it * it } }
+        expect(3uL) { arrayOf<ULong>(3, 2).minByOrNull { it - 3 } }
     }
 
     @Test
-    fun minByInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().minBy { it * it } }
-        expect(1u) { ushortArrayOf(1).minBy { it * it } }
-        expect(2u) { uintArrayOf(2, 3).minBy { it * it } }
-        expect(3uL) { ulongArrayOf(3, 2).minBy { it - 3 } }
+    fun minByOrNullInUnsignedArrays() {
+        expect(null) { ubyteArrayOf().minByOrNull { it * it } }
+        expect(1u) { ushortArrayOf(1).minByOrNull { it * it } }
+        expect(2u) { uintArrayOf(2, 3).minByOrNull { it * it } }
+        expect(3uL) { ulongArrayOf(3, 2).minByOrNull { it - 3 } }
     }
 
     @Test
-    fun maxBy() {
-        expect(null) { arrayOf<UByte>().maxBy { it + 1 } }
-        expect(1u) { arrayOf<UShort>(1).maxBy { it + 1 } }
-        expect(2u) { arrayOf<UInt>(2, 3).maxBy { it - 3 } }
-        expect(3uL) { arrayOf<ULong>(3, 2).maxBy { it + 1 } }
+    fun maxByOrNull() {
+        expect(null) { arrayOf<UByte>().maxByOrNull { it + 1 } }
+        expect(1u) { arrayOf<UShort>(1).maxByOrNull { it + 1 } }
+        expect(2u) { arrayOf<UInt>(2, 3).maxByOrNull { it - 3 } }
+        expect(3uL) { arrayOf<ULong>(3, 2).maxByOrNull { it + 1 } }
     }
 
     @Test
-    fun maxByInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().maxBy { it + 1 } }
-        expect(1u) { ushortArrayOf(1).maxBy { it + 1 } }
-        expect(2u) { uintArrayOf(2, 3).maxBy { it - 3 } }
-        expect(3uL) { ulongArrayOf(3, 2).maxBy { it + 1 } }
+    fun maxByOrNullInUnsignedArrays() {
+        expect(null) { ubyteArrayOf().maxByOrNull { it + 1 } }
+        expect(1u) { ushortArrayOf(1).maxByOrNull { it + 1 } }
+        expect(2u) { uintArrayOf(2, 3).maxByOrNull { it - 3 } }
+        expect(3uL) { ulongArrayOf(3, 2).maxByOrNull { it + 1 } }
     }
 
     @Test
@@ -996,7 +996,7 @@ class UnsignedArraysTest {
             ),
             ushortArrayOf(1, 2, 3).withIndex()
         )
-        assertEquals(IndexedValue(1, 2.toUInt()), uintArrayOf(1, 2, 3).withIndex().minBy { it.value % 2 })
+        assertEquals(IndexedValue(1, 2.toUInt()), uintArrayOf(1, 2, 3).withIndex().minByOrNull { it.value % 2 })
         assertIterableContentEquals(listOf(0, 1, 2), ulongArrayOf(1, 2, 3).withIndex().map { it.index })
     }