ifEmpty and isBlank extensions

- Introduce ifEmpty extension for Collections, Maps, Arrays, Sequences
- Introduce ifEmpty and isBlank for CharSequences

#KT-15695 Fixed

libraries/stdlib/samples/test/samples/collections/arrays.kt

@@ -45,6 +45,21 @@ class Arrays {
             val array: Array<Char>? = arrayOf('a', 'b', 'c')
             assertFalse(array.isNullOrEmpty())
         }
+
+        @Sample
+        fun arrayIfEmpty() {
+            val emptyArray: Array<Any> = emptyArray()
+
+            val emptyOrNull: Array<Any>? = emptyArray.ifEmpty { null }
+            assertPrints(emptyOrNull, "null")
+
+            val emptyOrDefault: Array<Any> = emptyArray.ifEmpty { arrayOf("default") }
+            assertPrints(emptyOrDefault.contentToString(), "[default]")
+
+            val nonEmptyArray = arrayOf(1)
+            val sameArray = nonEmptyArray.ifEmpty { arrayOf(2) }
+            assertTrue(nonEmptyArray === sameArray)
+        }
     }
 
     class Transformations {

libraries/stdlib/samples/test/samples/collections/collections.kt

@@ -63,6 +63,21 @@ class Collections {
             assertFalse(collection.isNullOrEmpty())
         }
 
+        @Sample
+        fun collectionIfEmpty() {
+            val empty: List<Int> = emptyList()
+
+            val emptyOrNull: List<Int>? = empty.ifEmpty { null }
+            assertPrints(emptyOrNull, "null")
+
+            val emptyOrDefault: List<Any> = empty.ifEmpty { listOf("default") }
+            assertPrints(emptyOrDefault, "[default]")
+
+            val nonEmpty = listOf("x")
+            val sameList: List<String> = nonEmpty.ifEmpty { listOf("empty") }
+            assertTrue(nonEmpty === sameList)
+        }
+
         @Sample
         fun collectionContainsAll() {
             val collection = mutableListOf('a', 'b')

libraries/stdlib/samples/test/samples/collections/maps.kt

@@ -118,6 +118,21 @@ class Maps {
             val map: Map<Char, Int>? = mapOf('a' to 1, 'b' to 2, 'c' to 3)
             assertFalse(map.isNullOrEmpty())
         }
+
+        @Sample
+        fun mapIfEmpty() {
+            val emptyMap: Map<String, Int> = emptyMap()
+
+            val emptyOrNull = emptyMap.ifEmpty { null }
+            assertPrints(emptyOrNull, "null")
+
+            val emptyOrDefault: Map<String, Any> = emptyMap.ifEmpty { mapOf("s" to "a") }
+            assertPrints(emptyOrDefault, "{s=a}")
+
+            val nonEmptyMap = mapOf("x" to 1)
+            val sameMap = nonEmptyMap.ifEmpty { null }
+            assertTrue(nonEmptyMap === sameMap)
+        }
     }
 
     class Filtering {

libraries/stdlib/samples/test/samples/collections/sequences.kt

@@ -169,6 +169,19 @@ class Sequences {
             val sequence: Sequence<Int>? = sequenceOf(1, 2, 3)
             assertPrints(sequence.orEmpty().toList(), "[1, 2, 3]")
         }
+
+        @Sample
+        fun sequenceIfEmpty() {
+            val empty = emptySequence<Int>()
+
+            val emptyOrDefault = empty.ifEmpty { sequenceOf("default") }
+            assertPrints(emptyOrDefault.toList(), "[default]")
+
+            val nonEmpty = sequenceOf("value")
+
+            val nonEmptyOrDefault = nonEmpty.ifEmpty { sequenceOf("default") }
+            assertPrints(nonEmptyOrDefault.toList(), "[value]")
+        }
     }
 
     class Transformations {

libraries/stdlib/samples/test/samples/text/strings.kt

@@ -1,6 +1,7 @@
 package samples.text
 
 import samples.*
+import kotlin.test.assertTrue
 
 class Strings {
 
@@ -146,4 +147,33 @@ class Strings {
         assertPrints(builder, "")
     }
 
+    @Sample
+    fun stringIfEmpty() {
+        val empty = ""
+
+        val emptyOrNull: String? = empty.ifEmpty { null }
+        assertPrints(emptyOrNull, "null")
+
+        val emptyOrDefault = empty.ifEmpty { "default" }
+        assertPrints(emptyOrDefault, "default")
+
+        val nonEmpty = "abc"
+        val sameString = nonEmpty.ifEmpty { "def" }
+        assertTrue(nonEmpty === sameString)
+    }
+
+    @Sample
+    fun stringIfBlank() {
+        val blank = "    "
+
+        val blankOrNull: String? = blank.ifBlank { null }
+        assertPrints(blankOrNull, "null")
+
+        val blankOrDefault = blank.ifBlank { "default" }
+        assertPrints(blankOrDefault, "default")
+
+        val nonBlank = "abc"
+        val sameString = nonBlank.ifBlank { "def" }
+        assertTrue(nonBlank === sameString)
+    }
 }