Rename sequence() extension to asSequence()

libraries/stdlib/test/collections/CollectionTest.kt

@@ -376,8 +376,8 @@ class CollectionTest {
         expect(2000000000000, { listOf(3000000000000, 2000000000000).min() })
         expect('a', { listOf('a', 'b').min() })
         expect("a", { listOf("a", "b").min() })
-        expect(null, { listOf<Int>().sequence().min<Int>() })
-        expect(2, { listOf(2, 3).sequence().min<Int>() })
+        expect(null, { listOf<Int>().asSequence().min<Int>() })
+        expect(2, { listOf(2, 3).asSequence().min<Int>() })
     }
 
     test fun max() {
@@ -387,8 +387,8 @@ class CollectionTest {
         expect(3000000000000, { listOf(3000000000000, 2000000000000).max() })
         expect('b', { listOf('a', 'b').max() })
         expect("b", { listOf("a", "b").max() })
-        expect(null, { listOf<Int>().sequence().max<Int>() })
-        expect(3, { listOf(2, 3).sequence().max<Int>() })
+        expect(null, { listOf<Int>().asSequence().max<Int>() })
+        expect(3, { listOf(2, 3).asSequence().max<Int>() })
     }
 
     test fun minBy() {
@@ -397,8 +397,8 @@ class CollectionTest {
         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>().sequence().minBy<Int, Int> { it } })
-        expect(3, { listOf(2, 3).sequence().minBy<Int, Int> { -it } })
+        expect(null, { listOf<Int>().asSequence().minBy<Int, Int> { it } })
+        expect(3, { listOf(2, 3).asSequence().minBy<Int, Int> { -it } })
     }
 
     test fun maxBy() {
@@ -407,8 +407,8 @@ class CollectionTest {
         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>().sequence().maxBy<Int, Int> { it } })
-        expect(2, { listOf(2, 3).sequence().maxBy<Int, Int> { -it } })
+        expect(null, { listOf<Int>().asSequence().maxBy<Int, Int> { it } })
+        expect(2, { listOf(2, 3).asSequence().maxBy<Int, Int> { -it } })
     }
 
     test fun minByEvaluateOnce() {
@@ -416,7 +416,7 @@ class CollectionTest {
         expect(1, { listOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
         assertEquals(5, c)
         c = 0
-        expect(1, { listOf(5, 4, 3, 2, 1).sequence().minBy<Int, Int> { c++; it * it } })
+        expect(1, { listOf(5, 4, 3, 2, 1).asSequence().minBy<Int, Int> { c++; it * it } })
         assertEquals(5, c)
     }
 
@@ -425,7 +425,7 @@ class CollectionTest {
         expect(5, { listOf(5, 4, 3, 2, 1).maxBy { c++; it * it } })
         assertEquals(5, c)
         c = 0
-        expect(5, { listOf(5, 4, 3, 2, 1).sequence().maxBy<Int, Int> { c++; it * it } })
+        expect(5, { listOf(5, 4, 3, 2, 1).asSequence().maxBy<Int, Int> { c++; it * it } })
         assertEquals(5, c)
     }
 

libraries/stdlib/test/collections/MapTest.kt

@@ -68,7 +68,7 @@ class MapTest {
 
     test fun stream() {
         val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
-        val named = map.sequence().filter { it.key == "name" }.single()
+        val named = map.asSequence().filter { it.key == "name" }.single()
         assertEquals("James", named.value)
     }
 

libraries/stdlib/test/collections/MutableCollectionsTest.kt

@@ -17,11 +17,11 @@ class MutableCollectionTest {
         assertEquals(data, collection)
     }
 
-    test fun fromStream() {
+    test fun fromSequence() {
         val list = listOf("foo", "bar")
         val collection = ArrayList<String>()
 
-        collection.addAll(list.sequence())
+        collection.addAll(list.asSequence())
 
         assertEquals(list, collection)
     }

libraries/stdlib/test/collections/SequenceJVMTest.kt

@@ -6,7 +6,7 @@ import kotlin.test.assertEquals
 class SequenceJVMTest {
 
     test fun filterIsInstance() {
-        val src: Sequence<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").sequence()
+        val src: Sequence<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").asSequence()
 
         val intValues: Sequence<Int> = src.filterIsInstance<Int>()
         assertEquals(listOf(1, 2), intValues.toArrayList())

libraries/stdlib/test/collections/SequenceTest.kt

@@ -189,7 +189,7 @@ public class SequenceTest {
     test fun sequenceFromIterator() {
         val list = listOf(3, 2, 1, 0)
         val iterator = list.iterator()
-        val sequence = iterator.sequence()
+        val sequence = iterator.asSequence()
         assertEquals(list, sequence.toList())
         fails {
             sequence.toList()
@@ -233,7 +233,7 @@ public class SequenceTest {
                 '5' // fibonacci(10) = 55
                              )
 
-        assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().sequence() }.take(10).toList())
+        assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().asSequence() }.take(10).toList())
     }
 
     test fun flatMap() {

libraries/stdlib/test/iterators/IteratorsJVMTest.kt

@@ -27,7 +27,7 @@ class IteratorsJVMTest {
     }
 
     test fun flatMapOnIterator() {
-        val result = sequenceOf(1, 2).flatMap { i -> (0..i).sequence()}
+        val result = sequenceOf(1, 2).flatMap { i -> (0..i).asSequence()}
         assertEquals(listOf(0, 1, 0, 1, 2), result.toList())
     }
 }

libraries/stdlib/test/iterators/IteratorsTest.kt

@@ -39,7 +39,7 @@ class IteratorsTest {
     }
 
     test fun plus() {
-        val iter = arrayListOf("foo", "bar").sequence()
+        val iter = arrayListOf("foo", "bar").asSequence()
         val iter2 = iter + "cheese"
         assertEquals(arrayListOf("foo", "bar", "cheese"), iter2.toList())
 
@@ -52,12 +52,12 @@ class IteratorsTest {
     test fun plusCollection() {
         val a = arrayListOf("foo", "bar")
         val b = arrayListOf("cheese", "wine")
-        val iter = a.sequence() + b.sequence()
+        val iter = a.asSequence() + b.asSequence()
         assertEquals(arrayListOf("foo", "bar", "cheese", "wine"), iter.toList())
 
         // lets use a mutable variable
-        var ml = arrayListOf("a").sequence()
-        ml += a.sequence()
+        var ml = arrayListOf("a").asSequence()
+        ml += a.asSequence()
         ml += "beer"
         ml += b
         ml += "z"
@@ -65,11 +65,11 @@ class IteratorsTest {
     }
 
     test fun requireNoNulls() {
-        val iter = arrayListOf<String?>("foo", "bar").sequence()
+        val iter = arrayListOf<String?>("foo", "bar").asSequence()
         val notNull = iter.requireNoNulls()
         assertEquals(arrayListOf("foo", "bar"), notNull.toList())
 
-        val iterWithNulls = arrayListOf("foo", null, "bar").sequence()
+        val iterWithNulls = arrayListOf("foo", null, "bar").asSequence()
         val notNull2 = iterWithNulls.requireNoNulls()
         fails {
             // should throw an exception as we have a null