Provide dropLast and takeLastWhile methods. Optimize special cases of drop/take/dropLast/takeLast (when n is equal to zero or size of collection).

libraries/stdlib/test/collections/ArraysJVMTest.kt

@@ -233,6 +233,24 @@ class ArraysJVMTest {
         }
     }
 
+    test fun dropLast() {
+        expect(listOf(), { intArrayOf().dropLast(1) })
+        expect(listOf(), { intArrayOf(1).dropLast(1) })
+        expect(listOf(1), { intArrayOf(1).dropLast(0) })
+        expect(listOf(2), { intArrayOf(2, 3).dropLast(1) })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLast(1) })
+        expect(listOf(2.toByte()), { byteArrayOf(2, 3).dropLast(1) })
+        expect(listOf(2.toShort()), { shortArrayOf(2, 3).dropLast(1) })
+        expect(listOf(2.0f), { floatArrayOf(2f, 3f).dropLast(1) })
+        expect(listOf(2.0), { doubleArrayOf(2.0, 3.0).dropLast(1) })
+        expect(listOf(true), { booleanArrayOf(true, false).dropLast(1) })
+        expect(listOf('a'), { charArrayOf('a', 'b').dropLast(1) })
+        expect(listOf("a"), { arrayOf("a", "b").dropLast(1) })
+        fails {
+            listOf(1).dropLast(-1)
+        }
+    }
+
     test fun dropWhile() {
         expect(listOf(), { intArrayOf().dropWhile { it < 3 } })
         expect(listOf(), { intArrayOf(1).dropWhile { it < 3 } })
@@ -247,6 +265,20 @@ class ArraysJVMTest {
         expect(listOf("b", "a"), { arrayOf("a", "b", "a").dropWhile { it < "b" } })
     }
 
+    test fun dropLastWhile() {
+        expect(listOf(), { intArrayOf().dropLastWhile { it < 3 } })
+        expect(listOf(), { intArrayOf(1).dropLastWhile { it < 3 } })
+        expect(listOf(2, 3), { intArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(3000000000000), { longArrayOf(3000000000000, 2000000000000).dropLastWhile { it < 3000000000000 } })
+        expect(listOf(2.toByte(), 3.toByte()), { byteArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(2.toShort(), 3.toShort()), { shortArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
+        expect(listOf(2f, 3f), { floatArrayOf(2f, 3f, 1f).dropLastWhile { it < 3 } })
+        expect(listOf(2.0, 3.0), { doubleArrayOf(2.0, 3.0, 1.0).dropLastWhile { it < 3 } })
+        expect(listOf(true, false), { booleanArrayOf(true, false, true).dropLastWhile { it } })
+        expect(listOf('a', 'b'), { charArrayOf('a', 'b', 'a').dropLastWhile { it < 'b' } })
+        expect(listOf("a", "b"), { arrayOf("a", "b", "a").dropLastWhile { it < "b" } })
+    }
+
     test fun take() {
         expect(listOf(), { intArrayOf().take(1) })
         expect(listOf(), { intArrayOf(1).take(0) })
@@ -293,8 +325,22 @@ class ArraysJVMTest {
         expect(listOf(2f), { floatArrayOf(2f, 3f, 1f).takeWhile { it < 3 } })
         expect(listOf(2.0), { doubleArrayOf(2.0, 3.0, 1.0).takeWhile { it < 3 } })
         expect(listOf(true), { booleanArrayOf(true, false, true).takeWhile { it } })
-        expect(listOf('a'), { charArrayOf('a', 'b', 'a').takeWhile { it < 'b' } })
-        expect(listOf("a"), { arrayOf("a", "b", "a").takeWhile { it < "b" } })
+        expect(listOf('a'), { charArrayOf('a', 'c', 'b').takeWhile { it < 'c' } })
+        expect(listOf("a"), { arrayOf("a", "c", "b").takeWhile { it < "c" } })
+    }
+
+    test fun takeLastWhile() {
+        expect(listOf(), { intArrayOf().takeLastWhile { it < 3 } })
+        expect(listOf(1), { intArrayOf(1).takeLastWhile { it < 3 } })
+        expect(listOf(1), { intArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(2000000000000), { longArrayOf(3000000000000, 2000000000000).takeLastWhile { it < 3000000000000 } })
+        expect(listOf(1.toByte()), { byteArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(1.toShort()), { shortArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
+        expect(listOf(1f), { floatArrayOf(2f, 3f, 1f).takeLastWhile { it < 3 } })
+        expect(listOf(1.0), { doubleArrayOf(2.0, 3.0, 1.0).takeLastWhile { it < 3 } })
+        expect(listOf(true), { booleanArrayOf(true, false, true).takeLastWhile { it } })
+        expect(listOf('b'), { charArrayOf('a', 'c', 'b').takeLastWhile { it < 'c' } })
+        expect(listOf("b"), { arrayOf("a", "c", "b").takeLastWhile { it < "c" } })
     }
 
     test fun filter() {

libraries/stdlib/test/collections/CollectionTest.kt

@@ -273,6 +273,17 @@ class CollectionTest {
         assertEquals(listOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
     }
 
+    test fun dropLast() {
+        val coll = listOf("foo", "bar", "abc")
+        assertEquals(coll, coll.dropLast(0))
+        assertEquals(emptyList<String>(), coll.dropLast(coll.size()))
+        assertEquals(emptyList<String>(), coll.dropLast(coll.size() + 1))
+        assertEquals(listOf("foo", "bar"), coll.dropLast(1))
+        assertEquals(listOf("foo"), coll.dropLast(2))
+
+        fails { coll.dropLast(-1) }
+    }
+
     test fun dropLastWhile() {
         val coll = listOf("Foo", "bare", "abc" )
         assertEquals(coll, coll.dropLastWhile { false })
@@ -283,16 +294,43 @@ class CollectionTest {
 
     test fun take() {
         val coll = listOf("foo", "bar", "abc")
+        assertEquals(emptyList<String>(), coll.take(0))
         assertEquals(listOf("foo"), coll.take(1))
         assertEquals(listOf("foo", "bar"), coll.take(2))
+        assertEquals(coll, coll.take(coll.size()))
+        assertEquals(coll, coll.take(coll.size() + 1))
+
+        fails { coll.take(-1) }
     }
 
     test fun takeWhile() {
         val coll = listOf("foo", "bar", "abc")
+        assertEquals(emptyList<String>(), coll.takeWhile { false })
+        assertEquals(coll, coll.takeWhile { true })
         assertEquals(listOf("foo"), coll.takeWhile { it.startsWith("f") })
         assertEquals(listOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
     }
 
+    test fun takeLast() {
+        val coll = listOf("foo", "bar", "abc")
+
+        assertEquals(emptyList<String>(), coll.takeLast(0))
+        assertEquals(listOf("abc"), coll.takeLast(1))
+        assertEquals(listOf("bar", "abc"), coll.takeLast(2))
+        assertEquals(coll, coll.takeLast(coll.size()))
+        assertEquals(coll, coll.takeLast(coll.size() + 1))
+
+        fails { coll.takeLast(-1) }
+    }
+
+    test fun takeLastWhile() {
+        val coll = listOf("foo", "bar", "abc")
+        assertEquals(emptyList<String>(), coll.takeLastWhile { false })
+        assertEquals(coll, coll.takeLastWhile { true })
+        assertEquals(listOf("abc"), coll.takeLastWhile { it.startsWith("a") })
+        assertEquals(listOf("bar", "abc"), coll.takeLastWhile { it[0] < 'c' })
+    }
+
     test fun copyToArray() {
         val data = listOf("foo", "bar")
         val arr = data.toTypedArray()