standard library: 'sum' function added (KT-3714, KT-3843, KT-3126)

libraries/stdlib/src/generated/_Arrays.kt

@@ -408,3 +408,45 @@ public inline fun <T> Array<out T>.withIndices() : Iterator<Pair<Int, T>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun Array<Byte>.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Array<Short>.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Array<Int>.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Array<Long>.sum() : Long {
+    return fold(0.toLong(), {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Array<Float>.sum() : Float {
+    return fold(0.toFloat(), {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Array<Double>.sum() : Double {
+    return fold(0.0, {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_ByteArrays.kt

@@ -381,3 +381,10 @@ public inline fun ByteArray.withIndices() : Iterator<Pair<Int, Byte>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun ByteArray.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_DoubleArrays.kt

@@ -381,3 +381,10 @@ public inline fun DoubleArray.withIndices() : Iterator<Pair<Int, Double>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun DoubleArray.sum() : Double {
+    return fold(0.0, {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_FloatArrays.kt

@@ -381,3 +381,10 @@ public inline fun FloatArray.withIndices() : Iterator<Pair<Int, Float>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun FloatArray.sum() : Float {
+    return fold(0.toFloat(), {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_IntArrays.kt

@@ -381,3 +381,10 @@ public inline fun IntArray.withIndices() : Iterator<Pair<Int, Int>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun IntArray.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_Iterables.kt

@@ -376,3 +376,31 @@ public inline fun <T> Iterable<T>.withIndices() : Iterator<Pair<Int, T>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun Iterable<Int>.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Iterable<Long>.sum() : Long {
+    return fold(0.toLong(), {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Iterable<Float>.sum() : Float {
+    return fold(0.toFloat(), {a,b -> a+b})
+}
+
+/**
+ * Sums up the elements
+ */
+public fun Iterable<Double>.sum() : Double {
+    return fold(0.0, {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_LongArrays.kt

@@ -381,3 +381,10 @@ public inline fun LongArray.withIndices() : Iterator<Pair<Int, Long>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun LongArray.sum() : Long {
+    return fold(0.toLong(), {a,b -> a+b})
+}
+

libraries/stdlib/src/generated/_ShortArrays.kt

@@ -381,3 +381,10 @@ public inline fun ShortArray.withIndices() : Iterator<Pair<Int, Short>> {
     return IndexIterator(iterator())
 }
 
+/**
+ * Sums up the elements
+ */
+public fun ShortArray.sum() : Int {
+    return fold(0, {a,b -> a+b})
+}
+

libraries/stdlib/test/ArraysJVMTest.kt

@@ -58,4 +58,14 @@ class ArraysJVMTest {
             intArray().reduceRight { a, b -> a + b}
         }
     }
+
+    test fun sum() {
+        expect(0) { intArray().sum() }
+        expect(14) { intArray(2, 3, 9).sum() }
+        expect(3.0) { doubleArray(1.0, 2.0).sum() }
+        expect(200) { byteArray(100, 100).sum() }
+        expect(50000) { shortArray(20000, 30000).sum() }
+        expect(3000000000000) { longArray(1000000000000, 2000000000000).sum() }
+        expect(3.0) { floatArray(1.0, 2.0).sum() }
+    }
 }

libraries/stdlib/test/ArraysTest.kt

@@ -101,6 +101,16 @@ class ArraysTest {
         assertEquals(false, arr[1])
     }
 
+    test fun sum() {
+        expect(0) { array<Int>().sum() }
+        expect(14) { array(2, 3, 9).sum() }
+        expect(3.0) { array(1.0, 2.0).sum() }
+        expect(200) { array<Byte>(100, 100).sum() }
+        expect(50000) { array<Short>(20000, 30000).sum() }
+        //TODO: uncomment when toLong() will be supported
+        //expect(3000000000000) { array<Long>(1000000000000, 2000000000000).sum() }
+        expect(3.0) { array<Float>(1.0, 2.0).sum() }
+    }
     /*
 
     TODO FIXME ASAP: These currently fail on JS due to missing upto() method on numbers

libraries/stdlib/test/CollectionTest.kt

@@ -414,6 +414,14 @@ class CollectionTest {
         expect(arrayList(2, 3, 1)) { list }
     }
 
+    test fun sum() {
+        expect(0) { ArrayList<Int>().sum() }
+        expect(14) { arrayListOf(2, 3, 9).sum() }
+        expect(3.0) { arrayListOf(1.0, 2.0).sum() }
+        expect(3000000000000) { arrayListOf<Long>(1000000000000, 2000000000000).sum() }
+        expect(3.0) { arrayListOf<Float>(1.0, 2.0).sum() }
+    }
+
     class IterableWrapper<T>(collection : Iterable<T>) : Iterable<T> {
         private val collection = collection