Introduce new overloads of flatMap and flatMapTo

- Sequence<T>.flatMap((T) -> Iterable<R>)
- Iterable<T>.flatMap((T) -> Sequence<R>)
- Array<T>.flatMap((T) -> Sequence<R>)
- Map.flatMap((Entry) -> Sequence<R>)

KT-34506

libraries/stdlib/test/collections/ArraysTest.kt

@@ -12,6 +12,7 @@ import test.assertTypeEquals
 import test.collections.behaviors.*
 import test.comparisons.STRING_CASE_INSENSITIVE_ORDER
 import test.text.isAsciiLetter
+import kotlin.math.exp
 import kotlin.test.*
 import kotlin.random.Random
 
@@ -1756,6 +1757,15 @@ class ArraysTest {
         assertEquals(listOf(2), arrayOf("a", null, "test").mapIndexedNotNull { index, it -> it?.run { if (index != 0) length / index else null  } })
     }
 
+    @Test fun flatMap() {
+        val data = arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6))
+        val result1 = data.flatMap { it.asList() }
+        val result2 = data.flatMap { it.asSequence() }
+        val expected = (data[0] + data[1]).toList()
+        assertEquals(expected, result1)
+        assertEquals(expected, result2)
+    }
+
     @Test fun flattenArray() {
         val arr1: Array<Array<Int>> = arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6))
         val arr2: Array<out Array<Int>> = arr1

libraries/stdlib/test/collections/CollectionTest.kt

@@ -46,6 +46,17 @@ class CollectionTest {
         assertStaticAndRuntimeTypeIs<List<String>>(foo)
     }
 
+
+    @Test fun flatMap() {
+        val source = listOf(null, "foo", "bar")
+        val result1 = source.flatMap { it.orEmpty().asSequence() }
+        val result2 = source.flatMap { it.orEmpty().asIterable() }
+
+        val expected = "foobar".toList()
+        assertEquals(expected, result1)
+        assertEquals(expected, result2)
+    }
+
     /*
     @Test fun mapNotNull() {
         val data = listOf(null, "foo", null, "bar")

libraries/stdlib/test/collections/MapTest.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -216,6 +216,21 @@ class MapTest {
         assertEquals(mapOf(8 to "Mells"), m3)
     }
 
+    @Test fun flatMap() {
+        fun <T> list(entry: Map.Entry<T, T>): List<T> = listOf(entry.key, entry.value)
+        fun <T> seq(entry: Map.Entry<T, T>): Sequence<T> = sequenceOf(entry.key, entry.value)
+        val m = mapOf("x" to 1, "y" to 0)
+        val result1 = m.flatMap { list(it) }
+        val result2 = m.flatMap { seq(it) }
+        val result3 = m.flatMap(::list)
+        val result4 = m.flatMap(::seq)
+        val expected = listOf("x", 1, "y", 0)
+        assertEquals(expected, result1)
+        assertEquals(expected, result2)
+        assertEquals(expected, result3)
+        assertEquals(expected, result4)
+    }
+
     @Test fun createFrom() {
         val pairs = arrayOf("a" to 1, "b" to 2)
         val expected = mapOf(*pairs)

libraries/stdlib/test/collections/SequenceTest.kt

@@ -572,18 +572,24 @@ public class SequenceTest {
     }
 
     @Test fun flatMap() {
-        val result = sequenceOf(1, 2).flatMap { (0..it).asSequence() }
-        assertEquals(listOf(0, 1, 0, 1, 2), result.toList())
+        val result1 = sequenceOf(1, 2).flatMap { (0..it).asSequence() }
+        val result2 = sequenceOf(1, 2).flatMap { 0..it }
+        val expected = listOf(0, 1, 0, 1, 2)
+        assertEquals(expected, result1.toList())
+        assertEquals(expected, result2.toList())
     }
 
     @Test fun flatMapOnEmpty() {
-        val result = sequenceOf<Int>().flatMap { (0..it).asSequence() }
-        assertTrue(result.none())
+        assertTrue(sequenceOf<Int>().flatMap { sequenceOf(1) }.none())
+        assertTrue(sequenceOf<Int>().flatMap { listOf(1) }.none())
     }
 
     @Test fun flatMapWithEmptyItems() {
-        val result = sequenceOf(1, 2, 4).flatMap { if (it == 2) sequenceOf<Int>() else (it - 1..it).asSequence() }
-        assertEquals(listOf(0, 1, 3, 4), result.toList())
+        val result1 = sequenceOf(1, 2, 4).flatMap { if (it == 2) sequenceOf<Int>() else (it - 1..it).asSequence() }
+        val result2 = sequenceOf(1, 2, 4).flatMap { if (it == 2) emptyList<Int>() else it - 1..it }
+        val expected = listOf(0, 1, 3, 4)
+        assertEquals(expected, result1.toList())
+        assertEquals(expected, result2.toList())
     }
 
     @Test fun flatten() {