Add foldIndexed and reduceIndexed groups of functions

- foldIndexed, foldRightIndexed, reduceIndexed and reduceRightIndexed have been added, in line with filterIndexed etc.;
- Test cases added appropriately for the new functions.

libraries/stdlib/test/collections/ArraysTest.kt

@@ -619,6 +619,38 @@ class ArraysTest {
 
 
 
+    @test fun reduceIndexed() {
+        expect(-1) { intArrayOf(1, 2, 3).reduceIndexed { index, a, b -> index + a - b } }
+        expect(-1.toLong()) { longArrayOf(1, 2, 3).reduceIndexed { index, a, b -> index + a - b } }
+        expect(-1F) { floatArrayOf(1F, 2F, 3F).reduceIndexed { index, a, b -> index + a - b } }
+        expect(-1.0) { doubleArrayOf(1.0, 2.0, 3.0).reduceIndexed { index, a, b -> index + a - b } }
+        expect('2') { charArrayOf('1', '3', '2').reduceIndexed { index, a, b -> if (a > b && index == 1) a else b } }
+        expect(true) { booleanArrayOf(true, true, false).reduceIndexed { index, a, b -> a && b || index == 2 } }
+        expect(false) { booleanArrayOf(true, true).reduceIndexed { index, a, b -> a && b && index != 1 } }
+        expect(1.toByte()) { byteArrayOf(3, 2, 1).reduceIndexed { index, a, b -> if (index != 2) (a - b).toByte() else a.toByte() } }
+        expect(1.toShort()) { shortArrayOf(3, 2, 1).reduceIndexed { index, a, b -> if (index != 2) (a - b).toShort() else a.toShort() } }
+
+        assertTrue(assertFails {
+            intArrayOf().reduceIndexed { index, a, b -> a + b }
+        } is UnsupportedOperationException)
+    }
+
+    @test fun reduceRightIndexed() {
+        expect(1) { intArrayOf(1, 2, 3).reduceRightIndexed { index, a, b -> index + a - b } }
+        expect(1.toLong()) { longArrayOf(1, 2, 3).reduceRightIndexed { index, a, b -> index + a - b } }
+        expect(1F) { floatArrayOf(1F, 2F, 3F).reduceRightIndexed { index, a, b -> index + a - b } }
+        expect(1.0) { doubleArrayOf(1.0, 2.0, 3.0).reduceRightIndexed { index, a, b -> index + a - b } }
+        expect('2') { charArrayOf('1', '3', '2').reduceRightIndexed { index, a, b -> if (a > b && index == 0) a else b } }
+        expect(true) { booleanArrayOf(true, true, false).reduceRightIndexed { index, a, b -> a && b || index == 1 } }
+        expect(false) { booleanArrayOf(true, true).reduceRightIndexed { index, a, b -> a && b && index != 0 } }
+        expect(1.toByte()) { byteArrayOf(3, 2, 1).reduceRightIndexed { index, a, b -> if (index != 1) (a - b).toByte() else a.toByte() } }
+        expect(1.toShort()) { shortArrayOf(3, 2, 1).reduceRightIndexed { index, a, b -> if (index != 1) (a - b).toShort() else a.toShort() } }
+
+        assertTrue(assertFails {
+            intArrayOf().reduceRightIndexed { index, a, b -> a + b }
+        } is UnsupportedOperationException)
+    }
+
     @test fun reduce() {
         expect(-4) { intArrayOf(1, 2, 3).reduce { a, b -> a - b } }
         expect(-4.toLong()) { longArrayOf(1, 2, 3).reduce { a, b -> a - b } }

libraries/stdlib/test/collections/CollectionTest.kt

@@ -79,6 +79,63 @@ class CollectionTest {
         }
     }
 
+    @test fun foldIndexed() {
+        expect(42) {
+            val numbers = listOf(1, 2, 3, 4)
+            numbers.foldIndexed(0) { index, a, b -> index * (a + b) }
+        }
+
+        expect(0) {
+            val numbers = arrayListOf<Int>()
+            numbers.foldIndexed(0) { index, a, b -> index * (a + b) }
+        }
+
+        expect("11234") {
+            val numbers = listOf(1, 2, 3, 4)
+            numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b }
+        }
+    }
+
+    @test fun foldIndexedWithDifferentTypes() {
+        expect(10) {
+            val numbers = listOf("a", "ab", "abc")
+            numbers.foldIndexed(1) { index, a, b -> a + b.length + index }
+        }
+
+        expect("11223344") {
+            val numbers = listOf(1, 2, 3, 4)
+            numbers.foldIndexed("") { index, a, b -> a + b + (index + 1) }
+        }
+    }
+
+    @test fun foldIndexedWithNonCommutativeOperation() {
+        expect(4) {
+            val numbers = listOf(1, 2, 3)
+            numbers.foldIndexed(7) { index, a, b -> index + a - b }
+        }
+    }
+
+    @test fun foldRightIndexed() {
+        expect("12343210") {
+            val numbers = listOf(1, 2, 3, 4)
+            numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index }
+        }
+    }
+
+    @test fun foldRightIndexedWithDifferentTypes() {
+        expect("12343210") {
+            val numbers = listOf(1, 2, 3, 4)
+            numbers.foldRightIndexed("") { index, a, b -> "" + a + b + index }
+        }
+    }
+
+    @test fun foldRightIndexedWithNonCommutativeOperation() {
+        expect(-4) {
+            val numbers = listOf(1, 2, 3)
+            numbers.foldRightIndexed(7) { index, a, b -> index + a - b }
+        }
+    }
+
     @test fun fold() {
         // lets calculate the sum of some numbers
         expect(10) {
@@ -160,6 +217,32 @@ class CollectionTest {
         assertEquals(listOf("something"), pair.second, "pair.second")
     }
 
+    @test fun reduceIndexed() {
+        expect("123") {
+            val list = listOf("1", "2", "3", "4")
+            list.reduceIndexed { index, a, b -> if (index == 3) a else a + b }
+        }
+
+        //        TODO replace with more accurate version when KT-5987 will be fixed
+        //        failsWith(javaClass<UnsupportedOperationException>()) {
+        assertFails {
+            run { arrayListOf<Int>().reduceIndexed { index, a, b -> a + b } }
+        }
+    }
+
+    @test fun reduceRightIndexed() {
+        expect("234") {
+            val list = listOf("1", "2", "3", "4")
+            list.reduceRightIndexed { index, a, b -> if (index == 0) b else a + b }
+        }
+
+        //        TODO replace with more accurate version when KT-5987 will be fixed
+        //        failsWith(javaClass<UnsupportedOperationException>()) {
+        assertFails {
+            run { arrayListOf<Int>().reduceRightIndexed { index, a, b -> a + b } }
+        }
+    }
+
     @test fun reduce() {
         expect("1234") {
             val list = listOf("1", "2", "3", "4")