diff --git a/libraries/stdlib/src/generated/ArraysFromIterables.kt b/libraries/stdlib/src/generated/ArraysFromIterables.kt
index 1e62db468ae..f3b4db871ee 100644
--- a/libraries/stdlib/src/generated/ArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <T, C: MutableCollection<in T>> Array<T>.filterTo(result: C, p
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun <T> Array<T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+    val first = ArrayList<T>()
+    val second = ArrayList<T>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt b/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
index c05eecec537..70609b187d6 100644
--- a/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/BooleanArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Boolean>> BooleanArray.filterTo(result:
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean) : Pair<List<Boolean>, List<Boolean>> {
+    val first = ArrayList<Boolean>()
+    val second = ArrayList<Boolean>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/ByteArraysFromIterables.kt b/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
index 5d6452ce1a0..9b3c7a53bb8 100644
--- a/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ByteArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Byte>> ByteArray.filterTo(result: C, pre
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun ByteArray.partition(predicate: (Byte) -> Boolean) : Pair<List<Byte>, List<Byte>> {
+    val first = ArrayList<Byte>()
+    val second = ArrayList<Byte>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/CharArraysFromIterables.kt b/libraries/stdlib/src/generated/CharArraysFromIterables.kt
index 0cbdc30025b..9d539c9f34a 100644
--- a/libraries/stdlib/src/generated/CharArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/CharArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Char>> CharArray.filterTo(result: C, pre
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun CharArray.partition(predicate: (Char) -> Boolean) : Pair<List<Char>, List<Char>> {
+    val first = ArrayList<Char>()
+    val second = ArrayList<Char>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt b/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
index 6f425180dce..678bbb0b0d6 100644
--- a/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/DoubleArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Double>> DoubleArray.filterTo(result: C,
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun DoubleArray.partition(predicate: (Double) -> Boolean) : Pair<List<Double>, List<Double>> {
+    val first = ArrayList<Double>()
+    val second = ArrayList<Double>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/FloatArraysFromIterables.kt b/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
index 92df196b3b6..d2db0e884a9 100644
--- a/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/FloatArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Float>> FloatArray.filterTo(result: C, p
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun FloatArray.partition(predicate: (Float) -> Boolean) : Pair<List<Float>, List<Float>> {
+    val first = ArrayList<Float>()
+    val second = ArrayList<Float>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/IntArraysFromIterables.kt b/libraries/stdlib/src/generated/IntArraysFromIterables.kt
index 1c4c6e187b3..0412cd6d8e5 100644
--- a/libraries/stdlib/src/generated/IntArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/IntArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Int>> IntArray.filterTo(result: C, predi
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun IntArray.partition(predicate: (Int) -> Boolean) : Pair<List<Int>, List<Int>> {
+    val first = ArrayList<Int>()
+    val second = ArrayList<Int>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/IteratorsFromIterables.kt b/libraries/stdlib/src/generated/IteratorsFromIterables.kt
index f80e55a0f11..7add95fb920 100644
--- a/libraries/stdlib/src/generated/IteratorsFromIterables.kt
+++ b/libraries/stdlib/src/generated/IteratorsFromIterables.kt
@@ -83,6 +83,24 @@ public inline fun <T, C: MutableCollection<in T>> Iterator<T>.filterTo(result: C
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun <T> Iterator<T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+    val first = ArrayList<T>()
+    val second = ArrayList<T>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/LongArraysFromIterables.kt b/libraries/stdlib/src/generated/LongArraysFromIterables.kt
index 40067e7e15d..8928763bff3 100644
--- a/libraries/stdlib/src/generated/LongArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/LongArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Long>> LongArray.filterTo(result: C, pre
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun LongArray.partition(predicate: (Long) -> Boolean) : Pair<List<Long>, List<Long>> {
+    val first = ArrayList<Long>()
+    val second = ArrayList<Long>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/generated/ShortArraysFromIterables.kt b/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
index 60badffa36e..04944674279 100644
--- a/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
+++ b/libraries/stdlib/src/generated/ShortArraysFromIterables.kt
@@ -84,6 +84,24 @@ public inline fun <C: MutableCollection<Short>> ShortArray.filterTo(result: C, p
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun ShortArray.partition(predicate: (Short) -> Boolean) : Pair<List<Short>, List<Short>> {
+    val first = ArrayList<Short>()
+    val second = ArrayList<Short>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/src/kotlin/Iterables.kt b/libraries/stdlib/src/kotlin/Iterables.kt
index dbbed96f227..1bb064c181d 100644
--- a/libraries/stdlib/src/kotlin/Iterables.kt
+++ b/libraries/stdlib/src/kotlin/Iterables.kt
@@ -75,6 +75,24 @@ public inline fun <T, C: MutableCollection<in T>> Iterable<T>.filterTo(result: C
     return result
 }
 
+/**
+ * Partitions this collection into a pair of collection
+ *
+ * @includeFunctionBody ../../test/CollectionTest.kt partition
+ */
+public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+    val first = ArrayList<T>()
+    val second = ArrayList<T>()
+    for (element in this) {
+        if (predicate(element)) {
+            first.add(element)
+        } else {
+            second.add(element)
+        }
+    }
+    return Pair(first, second)
+}
+
 /**
  * Returns a list containing all elements which do not match the given *predicate*
  *
diff --git a/libraries/stdlib/test/CollectionTest.kt b/libraries/stdlib/test/CollectionTest.kt
index 08e7bdd4a03..315cf933aef 100644
--- a/libraries/stdlib/test/CollectionTest.kt
+++ b/libraries/stdlib/test/CollectionTest.kt
@@ -156,6 +156,14 @@ class CollectionTest {
         }
     }
 
+    test fun partition() {
+        val data = arrayList("foo", "bar", "something", "xyz")
+        val pair = data.partition{it.size == 3}
+
+        assertEquals(arrayList("foo", "bar", "xyz"), pair.first, "pair.first")
+        assertEquals(arrayList("something"), pair.second, "pair.second")
+    }
+
     test fun reduce() {
         expect("1234") {
             val list = arrayList("1", "2", "3", "4")