diff --git a/libraries/stdlib/src/generated/ArraysFromIterables.kt b/libraries/stdlib/src/generated/ArraysFromIterables.kt
index 71a736dae05..cc83bce78b8 100644
--- a/libraries/stdlib/src/generated/ArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun <T> Array<T>.forEach(operation: (T) -> Unit) : Unit = for (ele
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun <T> Array<T>.fold(initial: T, operation: (T, T) -> T): T {
+public inline fun <T,R> Array<T>.fold(initial: R, operation: (R, T) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun <T> Array<T>.fold(initial: T, operation: (T, T) -> T): T {
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun <T> Array<T>.foldRight(initial: T, operation: (T, T) -> T): T = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <T,R> Array<T>.foldRight(initial: R, operation: (T, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt b/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
index f75ce70c6f8..44926bd5e36 100644
--- a/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun BooleanArray.forEach(operation: (Boolean) -> Unit) : Unit = fo
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun BooleanArray.fold(initial: Boolean, operation: (Boolean, Boolean) -> Boolean): Boolean {
+public inline fun <R> BooleanArray.fold(initial: R, operation: (R, Boolean) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun BooleanArray.fold(initial: Boolean, operation: (Boolean, Boole
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun BooleanArray.foldRight(initial: Boolean, operation: (Boolean, Boolean) -> Boolean): Boolean = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/ByteArraysFromIterables.kt b/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
index 0fe8550286e..b236ebb2bb3 100644
--- a/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun ByteArray.forEach(operation: (Byte) -> Unit) : Unit = for (ele
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun ByteArray.fold(initial: Byte, operation: (Byte, Byte) -> Byte): Byte {
+public inline fun <R> ByteArray.fold(initial: R, operation: (R, Byte) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun ByteArray.fold(initial: Byte, operation: (Byte, Byte) -> Byte)
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun ByteArray.foldRight(initial: Byte, operation: (Byte, Byte) -> Byte): Byte = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/CharArraysFromIterables.kt b/libraries/stdlib/src/generated/CharArraysFromIterables.kt
index 4a5cd5356c8..7cd3209e271 100644
--- a/libraries/stdlib/src/generated/CharArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/CharArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun CharArray.forEach(operation: (Char) -> Unit) : Unit = for (ele
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun CharArray.fold(initial: Char, operation: (Char, Char) -> Char): Char {
+public inline fun <R> CharArray.fold(initial: R, operation: (R, Char) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun CharArray.fold(initial: Char, operation: (Char, Char) -> Char)
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun CharArray.foldRight(initial: Char, operation: (Char, Char) -> Char): Char = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> CharArray.foldRight(initial: R, operation: (Char, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt b/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
index 2f6abba77d7..28972b2e32a 100644
--- a/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun DoubleArray.forEach(operation: (Double) -> Unit) : Unit = for
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun DoubleArray.fold(initial: Double, operation: (Double, Double) -> Double): Double {
+public inline fun <R> DoubleArray.fold(initial: R, operation: (R, Double) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun DoubleArray.fold(initial: Double, operation: (Double, Double)
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun DoubleArray.foldRight(initial: Double, operation: (Double, Double) -> Double): Double = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/FloatArraysFromIterables.kt b/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
index 1db7ed09464..9d5aa8c5727 100644
--- a/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun FloatArray.forEach(operation: (Float) -> Unit) : Unit = for (e
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun FloatArray.fold(initial: Float, operation: (Float, Float) -> Float): Float {
+public inline fun <R> FloatArray.fold(initial: R, operation: (R, Float) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun FloatArray.fold(initial: Float, operation: (Float, Float) -> F
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun FloatArray.foldRight(initial: Float, operation: (Float, Float) -> Float): Float = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/IntArraysFromIterables.kt b/libraries/stdlib/src/generated/IntArraysFromIterables.kt
index bb9cdf9b1ee..55184397069 100644
--- a/libraries/stdlib/src/generated/IntArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/IntArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun IntArray.forEach(operation: (Int) -> Unit) : Unit = for (eleme
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun IntArray.fold(initial: Int, operation: (Int, Int) -> Int): Int {
+public inline fun <R> IntArray.fold(initial: R, operation: (R, Int) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun IntArray.fold(initial: Int, operation: (Int, Int) -> Int): Int
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun IntArray.foldRight(initial: Int, operation: (Int, Int) -> Int): Int = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> IntArray.foldRight(initial: R, operation: (Int, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/IteratorsFromIterables.kt b/libraries/stdlib/src/generated/IteratorsFromIterables.kt
index 0cdb895c2bd..38a929c81eb 100644
--- a/libraries/stdlib/src/generated/IteratorsFromIterables.kt
+++ b/libraries/stdlib/src/generated/IteratorsFromIterables.kt
@@ -150,7 +150,7 @@ public inline fun <T> Iterator<T>.forEach(operation: (T) -> Unit) : Unit = for (
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun <T> Iterator<T>.fold(initial: T, operation: (T, T) -> T): T {
+public inline fun <T,R> Iterator<T>.fold(initial: R, operation: (R, T) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -161,7 +161,7 @@ public inline fun <T> Iterator<T>.fold(initial: T, operation: (T, T) -> T): T {
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun <T> Iterator<T>.foldRight(initial: T, operation: (T, T) -> T): T = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <T,R> Iterator<T>.foldRight(initial: R, operation: (T, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/LongArraysFromIterables.kt b/libraries/stdlib/src/generated/LongArraysFromIterables.kt
index 496c35357e4..1a973905971 100644
--- a/libraries/stdlib/src/generated/LongArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/LongArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun LongArray.forEach(operation: (Long) -> Unit) : Unit = for (ele
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun LongArray.fold(initial: Long, operation: (Long, Long) -> Long): Long {
+public inline fun <R> LongArray.fold(initial: R, operation: (R, Long) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun LongArray.fold(initial: Long, operation: (Long, Long) -> Long)
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun LongArray.foldRight(initial: Long, operation: (Long, Long) -> Long): Long = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> LongArray.foldRight(initial: R, operation: (Long, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/generated/ShortArraysFromIterables.kt b/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
index 6981473f6ac..54d6a153345 100644
--- a/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
@@ -151,7 +151,7 @@ public inline fun ShortArray.forEach(operation: (Short) -> Unit) : Unit = for (e
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun ShortArray.fold(initial: Short, operation: (Short, Short) -> Short): Short {
+public inline fun <R> ShortArray.fold(initial: R, operation: (R, Short) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -162,7 +162,7 @@ public inline fun ShortArray.fold(initial: Short, operation: (Short, Short) -> S
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun ShortArray.foldRight(initial: Short, operation: (Short, Short) -> Short): Short = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/src/kotlin/Iterables.kt b/libraries/stdlib/src/kotlin/Iterables.kt
index af32fc11812..7a33be874ed 100644
--- a/libraries/stdlib/src/kotlin/Iterables.kt
+++ b/libraries/stdlib/src/kotlin/Iterables.kt
@@ -142,7 +142,7 @@ public inline fun <T> Iterable<T>.forEach(operation: (T) -> Unit) : Unit = for (
  *
  * @includeFunctionBody ../../test/CollectionTest.kt fold
  */
-public inline fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {
+public inline fun <T,R> Iterable<T>.fold(initial: R, operation: (R, T) -> R): R {
     var answer = initial
     for (element in this) answer = operation(answer, element)
     return answer
@@ -153,7 +153,7 @@ public inline fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {
  *
  * @includeFunctionBody ../../test/CollectionTest.kt foldRight
  */
-public inline fun <T> Iterable<T>.foldRight(initial: T, operation: (T, T) -> T): T = reverse().fold(initial, {x, y -> operation(y, x)})
+public inline fun <T,R> Iterable<T>.foldRight(initial: R, operation: (T, R) -> R): R = reverse().fold(initial, {x, y -> operation(y, x)})
 
 
 /**
diff --git a/libraries/stdlib/test/CollectionTest.kt b/libraries/stdlib/test/CollectionTest.kt
index 90f65113a23..b911275c423 100644
--- a/libraries/stdlib/test/CollectionTest.kt
+++ b/libraries/stdlib/test/CollectionTest.kt
@@ -135,6 +135,18 @@ class CollectionTest {
         }
     }
 
+    test fun foldWithDifferentTypes() {
+        expect(7) {
+            val numbers = arrayList("a", "ab", "abc")
+            numbers.fold(1){ a, b -> a + b.size}
+        }
+
+        expect("1234") {
+            val numbers = arrayList(1, 2, 3, 4)
+            numbers.fold(""){ a, b -> a + b}
+        }
+    }
+
     test fun foldWithNonCommutativeOperation() {
         expect(1) {
             val numbers = arrayList(1, 2, 3)
@@ -149,6 +161,13 @@ class CollectionTest {
         }
     }
 
+    test fun foldRightWithDifferentTypes() {
+        expect("1234") {
+            val numbers = arrayList(1, 2, 3, 4)
+            numbers.foldRight(""){ a, b -> "" + a + b}
+        }
+    }
+
     test fun foldRightWithNonCommutativeOperation() {
         expect(-5) {
             val numbers = arrayList(1, 2, 3)