Introduce minWithOrNull and maxWithOrNull extension functions #KT-38854

libraries/stdlib/test/collections/ArraysTest.kt

@@ -390,26 +390,26 @@ class ArraysTest {
         expect('b', { charArrayOf('a', 'b').maxOrNull() })
     }
 
-    @Test fun minWith() {
-        assertEquals(null, arrayOf<Int>().minWith(naturalOrder()) )
-        assertEquals("a", arrayOf("a", "B").minWith(STRING_CASE_INSENSITIVE_ORDER))
+    @Test fun minWithOrNull() {
+        assertEquals(null, arrayOf<Int>().minWithOrNull(naturalOrder()))
+        assertEquals("a", arrayOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER))
     }
 
-    @Test fun minWithInPrimitiveArrays() {
-        expect(null, { intArrayOf().minWith(naturalOrder()) })
-        expect(1, { intArrayOf(1).minWith(naturalOrder()) })
-        expect(4, { intArrayOf(2, 3, 4).minWith(compareBy { it % 4 }) })
+    @Test fun minWithOrNullInPrimitiveArrays() {
+        expect(null, { intArrayOf().minWithOrNull(naturalOrder()) })
+        expect(1, { intArrayOf(1).minWithOrNull(naturalOrder()) })
+        expect(4, { intArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 }) })
     }
 
-    @Test fun maxWith() {
-        assertEquals(null, arrayOf<Int>().maxWith(naturalOrder()) )
-        assertEquals("B", arrayOf("a", "B").maxWith(STRING_CASE_INSENSITIVE_ORDER))
+    @Test fun maxWithOrNull() {
+        assertEquals(null, arrayOf<Int>().maxWithOrNull(naturalOrder()))
+        assertEquals("B", arrayOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER))
     }
 
-    @Test fun maxWithInPrimitiveArrays() {
-        expect(null, { intArrayOf().maxWith(naturalOrder()) })
-        expect(1, { intArrayOf(1).maxWith(naturalOrder()) })
-        expect(-4, { intArrayOf(2, 3, -4).maxWith(compareBy { it*it }) })
+    @Test fun maxWithOrNullInPrimitiveArrays() {
+        expect(null, { intArrayOf().maxWithOrNull(naturalOrder()) })
+        expect(1, { intArrayOf(1).maxWithOrNull(naturalOrder()) })
+        expect(-4, { intArrayOf(2, 3, -4).maxWithOrNull(compareBy { it * it }) })
     }
 
     @Test fun minByOrNull() {

libraries/stdlib/test/collections/CollectionTest.kt

@@ -851,18 +851,18 @@ class CollectionTest {
         assertIsPositiveZero(listOf(0.0F, -0.0F).shuffled().maxOrNull()!!.toDouble())
     }
 
-    @Test fun minWith() {
-        expect(null, { listOf<Int>().minWith(naturalOrder()) })
-        expect(1, { listOf(1).minWith(naturalOrder()) })
-        expect("a", { listOf("a", "B").minWith(STRING_CASE_INSENSITIVE_ORDER) })
-        expect("a", { listOf("a", "B").asSequence().minWith(STRING_CASE_INSENSITIVE_ORDER) })
+    @Test fun minWithOrNull() {
+        expect(null, { listOf<Int>().minWithOrNull(naturalOrder()) })
+        expect(1, { listOf(1).minWithOrNull(naturalOrder()) })
+        expect("a", { listOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
+        expect("a", { listOf("a", "B").asSequence().minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
     }
 
-    @Test fun maxWith() {
-        expect(null, { listOf<Int>().maxWith(naturalOrder()) })
-        expect(1, { listOf(1).maxWith(naturalOrder()) })
-        expect("B", { listOf("a", "B").maxWith(STRING_CASE_INSENSITIVE_ORDER) })
-        expect("B", { listOf("a", "B").asSequence().maxWith(STRING_CASE_INSENSITIVE_ORDER) })
+    @Test fun maxWithOrNull() {
+        expect(null, { listOf<Int>().maxWithOrNull(naturalOrder()) })
+        expect(1, { listOf(1).maxWithOrNull(naturalOrder()) })
+        expect("B", { listOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
+        expect("B", { listOf("a", "B").asSequence().maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
     }
 
     @Test fun minByOrNull() {

libraries/stdlib/test/collections/UnsignedArraysTest.kt

@@ -451,35 +451,35 @@ class UnsignedArraysTest {
     }
 
     @Test
-    fun minWith() {
-        expect(null) { arrayOf<UByte>().minWith(naturalOrder()) }
-        expect(1u) { arrayOf<UShort>(1).minWith(naturalOrder()) }
-        expect(2u) { arrayOf<UInt>(2, 3).minWith(naturalOrder()) }
-        expect(2uL) { arrayOf<ULong>(3, 2).minWith(naturalOrder()) }
+    fun minWitOrNullh() {
+        expect(null) { arrayOf<UByte>().minWithOrNull(naturalOrder()) }
+        expect(1u) { arrayOf<UShort>(1).minWithOrNull(naturalOrder()) }
+        expect(2u) { arrayOf<UInt>(2, 3).minWithOrNull(naturalOrder()) }
+        expect(2uL) { arrayOf<ULong>(3, 2).minWithOrNull(naturalOrder()) }
     }
 
     @Test
-    fun minWithInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().minWith(reverseOrder()) }
-        expect(1u) { ushortArrayOf(1).minWith(reverseOrder()) }
-        expect(3u) { uintArrayOf(2, 3).minWith(reverseOrder()) }
-        expect(3uL) { ulongArrayOf(3, 2).minWith(reverseOrder()) }
+    fun minWithOrNullInUnsignedArrays() {
+        expect(null) { ubyteArrayOf().minWithOrNull(reverseOrder()) }
+        expect(1u) { ushortArrayOf(1).minWithOrNull(reverseOrder()) }
+        expect(3u) { uintArrayOf(2, 3).minWithOrNull(reverseOrder()) }
+        expect(3uL) { ulongArrayOf(3, 2).minWithOrNull(reverseOrder()) }
     }
 
     @Test
-    fun maxWith() {
-        expect(null) { arrayOf<UByte>().maxWith(naturalOrder()) }
-        expect(1u) { arrayOf<UShort>(1).maxWith(naturalOrder()) }
-        expect(3u) { arrayOf<UInt>(2, 3).maxWith(naturalOrder()) }
-        expect(3uL) { arrayOf<ULong>(3, 2).maxWith(naturalOrder()) }
+    fun maxWithOrNull() {
+        expect(null) { arrayOf<UByte>().maxWithOrNull(naturalOrder()) }
+        expect(1u) { arrayOf<UShort>(1).maxWithOrNull(naturalOrder()) }
+        expect(3u) { arrayOf<UInt>(2, 3).maxWithOrNull(naturalOrder()) }
+        expect(3uL) { arrayOf<ULong>(3, 2).maxWithOrNull(naturalOrder()) }
     }
 
     @Test
-    fun maxWithInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().maxWith(reverseOrder()) }
-        expect(1u) { ushortArrayOf(1).maxWith(reverseOrder()) }
-        expect(2u) { uintArrayOf(2, 3).maxWith(reverseOrder()) }
-        expect(2uL) { ulongArrayOf(3, 2).maxWith(reverseOrder()) }
+    fun maxWithOrNullInUnsignedArrays() {
+        expect(null) { ubyteArrayOf().maxWithOrNull(reverseOrder()) }
+        expect(1u) { ushortArrayOf(1).maxWithOrNull(reverseOrder()) }
+        expect(2u) { uintArrayOf(2, 3).maxWithOrNull(reverseOrder()) }
+        expect(2uL) { ulongArrayOf(3, 2).maxWithOrNull(reverseOrder()) }
     }
 
     @Test