Implement plus for sequence as operand and refactor plus tests.

libraries/stdlib/src/generated/_Generators.kt

@@ -717,6 +717,26 @@ public fun <T> Set<T>.plus(element: T): Set<T> {
     return result
 }
 
+/**
+ * Returns a list containing all elements of the original collection and then all elements of the given [sequence].
+ */
+public fun <T> Collection<T>.plus(sequence: Sequence<T>): List<T> {
+    val result = ArrayList<T>(this.size() + 10)
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
+/**
+ * Returns a list containing all elements of the original collection and then all elements of the given [sequence].
+ */
+public fun <T> Iterable<T>.plus(sequence: Sequence<T>): List<T> {
+    val result = ArrayList<T>()
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
 /**
  * Returns a sequence containing all elements of original sequence and then all elements of the given [sequence].
  */
@@ -724,6 +744,16 @@ public fun <T> Sequence<T>.plus(sequence: Sequence<T>): Sequence<T> {
     return sequenceOf(this, sequence).flatten()
 }
 
+/**
+ * Returns a set containing all elements both of the original set and the given [sequence].
+ */
+public fun <T> Set<T>.plus(sequence: Sequence<T>): Set<T> {
+    val result = LinkedHashSet<T>(mapCapacity(this.size() * 2))
+    result.addAll(this)
+    result.addAll(sequence)
+    return result
+}
+
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */

libraries/stdlib/src/kotlin/collections/MutableCollections.kt

@@ -21,6 +21,12 @@ public fun <T> MutableCollection<in T>.plusAssign(array: Array<T>) {
     this.addAll(array)
 }
 
+/**
+ * Adds all elements of the given [sequence] to this mutable collection.
+ */
+public fun <T> MutableCollection<in T>.plusAssign(sequence: Sequence<T>) {
+    this.addAll(sequence)
+}
 
 /**
  * Adds all elements of the given [iterable] to this [MutableCollection].

libraries/stdlib/test/collections/CollectionTest.kt

@@ -197,32 +197,23 @@ class CollectionTest {
         assertEquals(listOf(2, 4, 6), range)
     }
 
-    test fun plusElement() {
+    fun testPlus(doPlus: (List<String>) -> List<String>) {
         val list = listOf("foo", "bar")
-        val list2: List<String> = list + "cheese"
+        val list2: List<String> = doPlus(list)
         assertEquals(listOf("foo", "bar"), list)
-        assertEquals(listOf("foo", "bar", "cheese"), list2)
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), list2)
     }
 
+    test fun plusElement() = testPlus { it + "cheese" + "wine" }
+    test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
+    test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
+    test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
+
     test fun plusCollectionBug() {
         val list = listOf("foo", "bar") + listOf("cheese", "wine")
         assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
     }
 
-    test fun plusCollection() {
-        val a = listOf("foo", "bar")
-        val b = listOf("cheese", "wine")
-        val list: List<String> = a + b
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
-    }
-
-    test fun plusArray() {
-        val a = listOf("foo", "bar")
-        val b = arrayOf("cheese", "wine")
-        val list: List<String> = a + b
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
-
-    }
 
     test fun plusAssign() {
         // lets use a mutable variable of readonly list
@@ -231,13 +222,15 @@ class CollectionTest {
         l += "foo"
         l += listOf("beer")
         l += arrayOf("cheese", "wine")
-        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine"), l)
+        l += sequenceOf("bar", "foo")
+        assertEquals(listOf("cheese", "foo", "beer", "cheese", "wine", "bar", "foo"), l)
         assertTrue(l !== lOriginal)
 
         val ml = arrayListOf("cheese")
         ml += "foo"
         ml += listOf("beer")
         ml += arrayOf("cheese", "wine")
+        ml += sequenceOf("bar", "foo")
         assertEquals(l, ml)
     }
 

libraries/stdlib/test/collections/IterableTests.kt

@@ -282,23 +282,20 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         assertEquals("FOO-BAR", result)
     }
 
-    Test
+    fun testPlus(doPlus: (Iterable<String>) -> List<String>) {
-    fun plusElement() {
+        val result: List<String> = doPlus(data)
-        val result = data + "zoo" + "g"
         assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+        assertFalse(result === data)
     }
 
     Test
-    fun plusCollection() {
+    fun plusElement() = testPlus { it + "zoo" + "g" }
-        val result = data + listOf("zoo", "g")
-        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
-    }
-
     Test
-    fun plusArray() {
+    fun plusCollection() = testPlus { it + listOf("zoo", "g") }
-        val result = data + arrayOf("zoo", "g")
+    Test
-        assertEquals(listOf("foo", "bar", "zoo", "g"), result)
+    fun plusArray() = testPlus { it + arrayOf("zoo", "g") }
-    }
+    Test
+    fun plusSequence() = testPlus { it + sequenceOf("zoo", "g") }
 
     Test
     fun plusAssign() {
@@ -307,7 +304,8 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
         result += "foo"
         result += listOf("beer")
         result += arrayOf("cheese", "wine")
-        assertEquals(listOf("foo", "bar", "foo", "beer", "cheese", "wine"), result)
+        result += sequenceOf("zoo", "g")
+        assertEquals(listOf("foo", "bar", "foo", "beer", "cheese", "wine", "zoo", "g"), result)
     }
 
 }

libraries/stdlib/test/collections/SequenceTest.kt

@@ -132,33 +132,28 @@ public class SequenceTest {
         assertEquals("144, 233, 377, 610, 987", fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.joinToString())
     }
 
-    test fun plusElement() {
+
-        val sequence = sequenceOf("foo", "bar")
+    fun testPlus(doPlus: (Sequence<String>) -> Sequence<String>) {
-        val sequenceCheese: Sequence<String> = sequence + "cheese"
+        val seq = sequenceOf("foo", "bar")
-        assertEquals(listOf("foo", "bar", "cheese"), sequenceCheese.toList())
+        val seq2: Sequence<String> = doPlus(seq)
+        assertEquals(listOf("foo", "bar"), seq.toList())
+        assertEquals(listOf("foo", "bar", "cheese", "wine"), seq2.toList())
     }
 
-    test fun plusCollection() {
-        val a = sequenceOf("foo", "bar")
-        val b = listOf("cheese", "wine")
-        val sequence: Sequence<String> = a + b
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), sequence.toList())
-    }
 
-    test fun plusArray() {
+    test fun plusElement() = testPlus { it + "cheese" + "wine" }
-        val a = sequenceOf("foo", "bar")
+    test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
-        val b = listOf("cheese", "wine")
+    test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
-        val sequence: Sequence<String> = a + b
+    test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
-        assertEquals(listOf("foo", "bar", "cheese", "wine"), sequence.toList())
-    }
 
     test fun plusAssign() {
         // lets use a mutable variable
-        var ml = sequenceOf("a")
+        var seq = sequenceOf("a")
-        ml += "foo"
+        seq += "foo"
-        ml += listOf("beer")
+        seq += listOf("beer")
-        ml += arrayOf("cheese", "wine")
+        seq += arrayOf("cheese", "wine")
-        assertEquals(listOf("a", "foo", "beer", "cheese", "wine"), ml.toList())
+        seq += sequenceOf("bar", "foo")
+        assertEquals(listOf("a", "foo", "beer", "cheese", "wine", "bar", "foo"), seq.toList())
     }
 
 

libraries/stdlib/test/collections/SetOperationsTest.kt

@@ -33,33 +33,35 @@ class SetOperationsTest {
         assertTrue(listOf<Int>().intersect(listOf(1)).none())
     }
 
-    test fun plusElement() {
+    fun testPlus(doPlus: (Set<String>) -> Set<String>) {
-        val set = setOf("foo")
+        val set = setOf("foo", "bar")
-        val result: Set<String> = set + "bar" + "bar"
+        val set2: Set<String> = doPlus(set)
-        assertEquals(setOf("foo", "bar"), result)
+        assertEquals(setOf("foo", "bar"), set)
+        assertEquals(setOf("foo", "bar", "cheese", "wine"), set2)
     }
 
-    test fun plusCollection() {
+    test fun plusElement() = testPlus { it + "bar" + "cheese" + "wine" }
-        val set = setOf("foo")
+    test fun plusCollection() = testPlus { it + listOf("bar", "cheese", "wine") }
-        val result: Set<String> = set + listOf("bar", "bar")
+    test fun plusArray() = testPlus { it + arrayOf("bar", "cheese", "wine") }
-        assertEquals(setOf("foo", "bar"), result)
+    test fun plusSequence() = testPlus { it + sequenceOf("bar", "cheese", "wine") }
-    }
-
-    test fun plusArray() {
-        val set = setOf("foo")
-        val result: Set<String> = set + arrayOf("foo", "bar")
-        assertEquals(setOf("foo", "bar"), result)
-    }
 
     test fun plusAssign() {
         // lets use a mutable variable
         var set = setOf("a")
         val setOriginal = set
         set += "foo"
-        set += listOf("beer")
+        set += listOf("beer", "a")
-        set += arrayOf("cheese", "wine")
+        set += arrayOf("cheese", "beer")
-        assertEquals(setOf("a", "foo", "beer", "cheese", "wine"), set)
+        set += sequenceOf("bar", "foo")
+        assertEquals(setOf("a", "foo", "beer", "cheese", "bar"), set)
         assertTrue(set !== setOriginal)
+
+        val mset = hashSetOf("a")
+        mset += "foo"
+        mset += listOf("beer", "a")
+        mset += arrayOf("cheese", "beer")
+        mset += sequenceOf("bar", "foo")
+        assertEquals(set, mset)
     }
 
 }

libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt

@@ -137,10 +137,40 @@ fun generators(): List<GenericFunction> {
 
 
     templates add f("plus(sequence: Sequence<T>)") {
-        only(Sequences)
+        only(Iterables, Sets, Sequences)
-        doc { "Returns a sequence containing all elements of original sequence and then all elements of the given [sequence]." }
+        doc { "Returns a list containing all elements of the original collection and then all elements of the given [sequence]." }
-        returns("Sequence<T>")
+        returns("List<T>")
+        returns("SELF", Sets, Sequences)
         body {
+            """
+            val result = ArrayList<T>()
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+        body(Collections) {
+            """
+            val result = ArrayList<T>(this.size() + 10)
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+
+        // TODO: use immutable set builder when available
+        doc(Sets) { "Returns a set containing all elements both of the original set and the given [sequence]." }
+        body(Sets) {
+            """
+            val result = LinkedHashSet<T>(mapCapacity(this.size() * 2))
+            result.addAll(this)
+            result.addAll(sequence)
+            return result
+            """
+        }
+
+        doc(Sequences) { "Returns a sequence containing all elements of original sequence and then all elements of the given [sequence]." }
+        body(Sequences) {
             """
             return sequenceOf(this, sequence).flatten()
             """