Rename sequence() extension to asSequence()

libraries/stdlib/src/generated/_Sequences.kt

@@ -12,10 +12,10 @@ import java.util.Collections // TODO: it's temporary while we have java.util.Col
 /**
  * Returns a sequence from the given collection
  */
-public fun <T> Array<out T>.sequence(): Sequence<T> {
+public fun <T> Array<out T>.asSequence(): Sequence<T> {
     return object : Sequence<T> {
         override fun iterator(): Iterator<T> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -23,10 +23,10 @@ public fun <T> Array<out T>.sequence(): Sequence<T> {
 /**
  * Returns a sequence from the given collection
  */
-public fun BooleanArray.sequence(): Sequence<Boolean> {
+public fun BooleanArray.asSequence(): Sequence<Boolean> {
     return object : Sequence<Boolean> {
         override fun iterator(): Iterator<Boolean> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -34,10 +34,10 @@ public fun BooleanArray.sequence(): Sequence<Boolean> {
 /**
  * Returns a sequence from the given collection
  */
-public fun ByteArray.sequence(): Sequence<Byte> {
+public fun ByteArray.asSequence(): Sequence<Byte> {
     return object : Sequence<Byte> {
         override fun iterator(): Iterator<Byte> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -45,10 +45,10 @@ public fun ByteArray.sequence(): Sequence<Byte> {
 /**
  * Returns a sequence from the given collection
  */
-public fun CharArray.sequence(): Sequence<Char> {
+public fun CharArray.asSequence(): Sequence<Char> {
     return object : Sequence<Char> {
         override fun iterator(): Iterator<Char> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -56,10 +56,10 @@ public fun CharArray.sequence(): Sequence<Char> {
 /**
  * Returns a sequence from the given collection
  */
-public fun DoubleArray.sequence(): Sequence<Double> {
+public fun DoubleArray.asSequence(): Sequence<Double> {
     return object : Sequence<Double> {
         override fun iterator(): Iterator<Double> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -67,10 +67,10 @@ public fun DoubleArray.sequence(): Sequence<Double> {
 /**
  * Returns a sequence from the given collection
  */
-public fun FloatArray.sequence(): Sequence<Float> {
+public fun FloatArray.asSequence(): Sequence<Float> {
     return object : Sequence<Float> {
         override fun iterator(): Iterator<Float> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -78,10 +78,10 @@ public fun FloatArray.sequence(): Sequence<Float> {
 /**
  * Returns a sequence from the given collection
  */
-public fun IntArray.sequence(): Sequence<Int> {
+public fun IntArray.asSequence(): Sequence<Int> {
     return object : Sequence<Int> {
         override fun iterator(): Iterator<Int> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -89,10 +89,10 @@ public fun IntArray.sequence(): Sequence<Int> {
 /**
  * Returns a sequence from the given collection
  */
-public fun LongArray.sequence(): Sequence<Long> {
+public fun LongArray.asSequence(): Sequence<Long> {
     return object : Sequence<Long> {
         override fun iterator(): Iterator<Long> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -100,10 +100,10 @@ public fun LongArray.sequence(): Sequence<Long> {
 /**
  * Returns a sequence from the given collection
  */
-public fun ShortArray.sequence(): Sequence<Short> {
+public fun ShortArray.asSequence(): Sequence<Short> {
     return object : Sequence<Short> {
         override fun iterator(): Iterator<Short> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -111,10 +111,10 @@ public fun ShortArray.sequence(): Sequence<Short> {
 /**
  * Returns a sequence from the given collection
  */
-public fun <T> Iterable<T>.sequence(): Sequence<T> {
+public fun <T> Iterable<T>.asSequence(): Sequence<T> {
     return object : Sequence<T> {
         override fun iterator(): Iterator<T> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -122,10 +122,10 @@ public fun <T> Iterable<T>.sequence(): Sequence<T> {
 /**
  * Returns a sequence from the given collection
  */
-public fun <K, V> Map<K, V>.sequence(): Sequence<Map.Entry<K, V>> {
+public fun <K, V> Map<K, V>.asSequence(): Sequence<Map.Entry<K, V>> {
     return object : Sequence<Map.Entry<K, V>> {
         override fun iterator(): Iterator<Map.Entry<K, V>> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -133,7 +133,7 @@ public fun <K, V> Map<K, V>.sequence(): Sequence<Map.Entry<K, V>> {
 /**
  * Returns a sequence from the given collection
  */
-public fun <T> Sequence<T>.sequence(): Sequence<T> {
+public fun <T> Sequence<T>.asSequence(): Sequence<T> {
     return this
 }
 
@@ -142,17 +142,17 @@ deprecated("Migrate to using Sequence<T> and respective functions")
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Stream<T>.stream(): Stream<T> {
+public fun <T> Stream<T>.asStream(): Stream<T> {
     return this
 }
 
 /**
  * Returns a sequence from the given collection
  */
-public fun String.sequence(): Sequence<Char> {
+public fun String.asSequence(): Sequence<Char> {
     return object : Sequence<Char> {
         override fun iterator(): Iterator<Char> {
-            return this@sequence.iterator()
+            return this@asSequence.iterator()
         }
     }
 }
@@ -160,9 +160,122 @@ public fun String.sequence(): Sequence<Char> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
+public fun <T> Array<out T>.sequence(): Sequence<T> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun BooleanArray.sequence(): Sequence<Boolean> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun ByteArray.sequence(): Sequence<Byte> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun CharArray.sequence(): Sequence<Char> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun DoubleArray.sequence(): Sequence<Double> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun FloatArray.sequence(): Sequence<Float> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun IntArray.sequence(): Sequence<Int> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun LongArray.sequence(): Sequence<Long> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun ShortArray.sequence(): Sequence<Short> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun <T> Iterable<T>.sequence(): Sequence<T> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun <K, V> Map<K, V>.sequence(): Sequence<Map.Entry<K, V>> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun <T> Sequence<T>.sequence(): Sequence<T> {
+    return this
+}
+
+
+/**
+ * Returns a stream from the given collection
+ */
+deprecated("Use asStream() instead")
+public fun <T> Stream<T>.stream(): Stream<T> {
+    return this
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
+public fun String.sequence(): Sequence<Char> {
+    return asSequence()
+}
+
+/**
+ * Returns a sequence from the given collection
+ */
+deprecated("Use asSequence() instead")
 public fun <T> Array<out T>.stream(): Stream<T> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<T> {
         override fun iterator(): Iterator<T> {
             return sequence.iterator()
@@ -173,9 +286,9 @@ public fun <T> Array<out T>.stream(): Stream<T> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun BooleanArray.stream(): Stream<Boolean> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Boolean> {
         override fun iterator(): Iterator<Boolean> {
             return sequence.iterator()
@@ -186,9 +299,9 @@ public fun BooleanArray.stream(): Stream<Boolean> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun ByteArray.stream(): Stream<Byte> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Byte> {
         override fun iterator(): Iterator<Byte> {
             return sequence.iterator()
@@ -199,9 +312,9 @@ public fun ByteArray.stream(): Stream<Byte> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun CharArray.stream(): Stream<Char> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Char> {
         override fun iterator(): Iterator<Char> {
             return sequence.iterator()
@@ -212,9 +325,9 @@ public fun CharArray.stream(): Stream<Char> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun DoubleArray.stream(): Stream<Double> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Double> {
         override fun iterator(): Iterator<Double> {
             return sequence.iterator()
@@ -225,9 +338,9 @@ public fun DoubleArray.stream(): Stream<Double> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun FloatArray.stream(): Stream<Float> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Float> {
         override fun iterator(): Iterator<Float> {
             return sequence.iterator()
@@ -238,9 +351,9 @@ public fun FloatArray.stream(): Stream<Float> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun IntArray.stream(): Stream<Int> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Int> {
         override fun iterator(): Iterator<Int> {
             return sequence.iterator()
@@ -251,9 +364,9 @@ public fun IntArray.stream(): Stream<Int> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun LongArray.stream(): Stream<Long> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Long> {
         override fun iterator(): Iterator<Long> {
             return sequence.iterator()
@@ -264,9 +377,9 @@ public fun LongArray.stream(): Stream<Long> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun ShortArray.stream(): Stream<Short> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Short> {
         override fun iterator(): Iterator<Short> {
             return sequence.iterator()
@@ -277,9 +390,9 @@ public fun ShortArray.stream(): Stream<Short> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun <T> Iterable<T>.stream(): Stream<T> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<T> {
         override fun iterator(): Iterator<T> {
             return sequence.iterator()
@@ -290,9 +403,9 @@ public fun <T> Iterable<T>.stream(): Stream<T> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun <K, V> Map<K, V>.stream(): Stream<Map.Entry<K, V>> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Map.Entry<K, V>> {
         override fun iterator(): Iterator<Map.Entry<K, V>> {
             return sequence.iterator()
@@ -303,9 +416,9 @@ public fun <K, V> Map<K, V>.stream(): Stream<Map.Entry<K, V>> {
 /**
  * Returns a sequence from the given collection
  */
-deprecated("Use sequence() instead")
+deprecated("Use asSequence() instead")
 public fun String.stream(): Stream<Char> {
-    val sequence = sequence()
+    val sequence = asSequence()
     return object : Stream<Char> {
         override fun iterator(): Iterator<Char> {
             return sequence.iterator()

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

@@ -33,17 +33,21 @@ public fun <T> streamOf(progression: Progression<T>): Stream<T> = object : Strea
 /**
  * Creates a sequence that returns all values from this iterator. The sequence is constrained to be iterated only once.
  */
-public fun <T> Iterator<T>.sequence(): Sequence<T> {
+public fun <T> Iterator<T>.asSequence(): Sequence<T> {
     val iteratorSequence = object : Sequence<T> {
-        override fun iterator(): Iterator<T> = this@sequence
+        override fun iterator(): Iterator<T> = this@asSequence
     }
     return iteratorSequence.constrainOnce()
 }
 
+deprecated("Use asSequence() instead.")
+public fun <T> Iterator<T>.sequence(): Sequence<T> = asSequence()
+
+
 /**
  * Creates a sequence that returns the specified values.
  */
-public fun <T> sequenceOf(vararg elements: T): Sequence<T> = elements.sequence()
+public fun <T> sequenceOf(vararg elements: T): Sequence<T> = elements.asSequence()
 
 /**
  * Creates a sequence that returns all values in the specified [progression].

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(null, { listOf<Int>().asSequence().min<Int>() })
-        expect(2, { listOf(2, 3).sequence().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(null, { listOf<Int>().asSequence().max<Int>() })
-        expect(3, { listOf(2, 3).sequence().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(null, { listOf<Int>().asSequence().minBy<Int, Int> { it } })
-        expect(3, { listOf(2, 3).sequence().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(null, { listOf<Int>().asSequence().maxBy<Int, Int> { it } })
-        expect(2, { listOf(2, 3).sequence().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()
+        var ml = arrayListOf("a").asSequence()
-        ml += a.sequence()
+        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

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

@@ -8,12 +8,12 @@ fun sequences(): List<GenericFunction> {
     templates add f("stream()") {
         include(Maps)
         exclude(Sequences)
-        deprecate { "Use sequence() instead" }
+        deprecate { "Use asSequence() instead" }
         doc { "Returns a sequence from the given collection" }
         returns("Stream<T>")
         body {
             """
-            val sequence = sequence()
+            val sequence = asSequence()
             return object : Stream<T> {
                 override fun iterator(): Iterator<T> {
                     return sequence.iterator()
@@ -25,6 +25,24 @@ fun sequences(): List<GenericFunction> {
     }
 
     templates add f("sequence()") {
+        include(Maps)
+        exclude(Sequences)
+        deprecate { "Use asSequence() instead" }
+        doc { "Returns a sequence from the given collection" }
+        returns("Sequence<T>")
+        body {
+            """
+            return asSequence()
+            """
+        }
+
+        body(Sequences) {
+            """
+            return this
+            """
+        }
+    }
+    templates add f("asSequence()") {
         include(Maps)
         exclude(Sequences)
         doc { "Returns a sequence from the given collection" }
@@ -33,7 +51,7 @@ fun sequences(): List<GenericFunction> {
             """
             return object : Sequence<T> {
                 override fun iterator(): Iterator<T> {
-                    return this@sequence.iterator()
+                    return this@asSequence.iterator()
                 }
             }
             """
@@ -47,4 +65,5 @@ fun sequences(): List<GenericFunction> {
     }
 
     return templates
-}
+}
+