Add samples for partition

(cherry picked from commit 7bb7c86)

libraries/stdlib/common/src/generated/_Arrays.kt

@@ -14687,6 +14687,8 @@ public fun <T : Any> Array<T?>.requireNoNulls(): Array<T> {
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()
@@ -14705,6 +14707,8 @@ public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<Li
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>> {
     val first = ArrayList<Byte>()
@@ -14723,6 +14727,8 @@ public inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<B
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List<Short>, List<Short>> {
     val first = ArrayList<Short>()
@@ -14741,6 +14747,8 @@ public inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>> {
     val first = ArrayList<Int>()
@@ -14759,6 +14767,8 @@ public inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>> {
     val first = ArrayList<Long>()
@@ -14777,6 +14787,8 @@ public inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<L
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>> {
     val first = ArrayList<Float>()
@@ -14795,6 +14807,8 @@ public inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>> {
     val first = ArrayList<Double>()
@@ -14813,6 +14827,8 @@ public inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<Li
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>> {
     val first = ArrayList<Boolean>()
@@ -14831,6 +14847,8 @@ public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<
  * Splits the original array into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Arrays.Transformations.partitionArrayOfPrimitives
  */
 public inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>> {
     val first = ArrayList<Char>()

libraries/stdlib/common/src/generated/_Collections.kt

@@ -2212,6 +2212,8 @@ public inline fun <T> Iterable<T>.minusElement(element: T): List<T> {
  * Splits the original collection into pair of lists,
  * where *first* list contains elements for which [predicate] yielded `true`,
  * while *second* list contains elements for which [predicate] yielded `false`.
+ * 
+ * @sample samples.collections.Iterables.Operations.partition
  */
 public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()

libraries/stdlib/common/src/generated/_Sequences.kt

@@ -1698,6 +1698,8 @@ public inline fun <T> Sequence<T>.minusElement(element: T): Sequence<T> {
  * while *second* list contains elements for which [predicate] yielded `false`.
  *
  * The operation is _terminal_.
+ * 
+ * @sample samples.collections.Sequences.Transformations.partition
  */
 public inline fun <T> Sequence<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()

libraries/stdlib/common/src/generated/_Strings.kt

@@ -1486,6 +1486,8 @@ public fun <R> CharSequence.chunkedSequence(size: Int, transform: (CharSequence)
  * Splits the original char sequence into pair of char sequences,
  * where *first* char sequence contains characters for which [predicate] yielded `true`,
  * while *second* char sequence contains characters for which [predicate] yielded `false`.
+ * 
+ * @sample samples.text.Strings.partition
  */
 public inline fun CharSequence.partition(predicate: (Char) -> Boolean): Pair<CharSequence, CharSequence> {
     val first = StringBuilder()
@@ -1504,6 +1506,8 @@ public inline fun CharSequence.partition(predicate: (Char) -> Boolean): Pair<Cha
  * Splits the original string into pair of strings,
  * where *first* string contains characters for which [predicate] yielded `true`,
  * while *second* string contains characters for which [predicate] yielded `false`.
+ * 
+ * @sample samples.text.Strings.partition
  */
 public inline fun String.partition(predicate: (Char) -> Boolean): Pair<String, String> {
     val first = StringBuilder()

libraries/stdlib/samples/test/samples/collections/arrays.kt

@@ -146,6 +146,13 @@ class Arrays {
             val array = arrayOf(1 to 'a', 2 to 'b', 3 to 'c')
             assertPrints(array.unzip(), "([1, 2, 3], [a, b, c])")
         }
+
+        @Sample
+        fun partitionArrayOfPrimitives() {
+            val array = intArrayOf(1, 2, 3, 4, 5)
+            val partition = array.partition { it % 2 == 0 }
+            assertPrints(partition, "([2, 4], [1, 3, 5])")
+        }
     }
 
     class ContentOperations {

libraries/stdlib/samples/test/samples/collections/iterables.kt

@@ -71,5 +71,18 @@ class Iterables {
             val result = listA.zip(listB) { a, b -> "$a$b" }
             assertPrints(result, "[a1, b2, c3]")
         }
+
+        @Sample
+        fun partition() {
+            data class Person(val name: String, val age: Int) {
+                override fun toString(): String {
+                    return "$name - $age"
+                }
+            }
+
+            val list = listOf(Person("Tom", 18), Person("Andy", 32), Person("Sarah", 22))
+            val result = list.partition { it.age < 30 }
+            assertPrints(result, "([Tom - 18, Sarah - 22], [Andy - 32])")
+        }
     }
 }

libraries/stdlib/samples/test/samples/collections/sequences.kt

@@ -228,6 +228,13 @@ class Sequences {
             val result = sequenceA.zip(sequenceB) { a, b -> "$a/$b" }
             assertPrints(result.take(4).toList(), "[a/1, b/3, c/7, d/15]")
         }
+
+        @Sample
+        fun partition() {
+            val sequence = sequenceOf(1, 2, 3, 4, 5)
+            val result = sequence.partition { it % 2 == 0 }
+            assertPrints(result, "([2, 4], [1, 3, 5])")
+        }
     }
 
 }

libraries/stdlib/samples/test/samples/text/strings.kt

@@ -170,6 +170,13 @@ class Strings {
         assertPrints(result, "{b=98, o=111, n=110, e=101,  =32, j=106, u=117, r=114, é=233}")
     }
 
+    @Sample
+    fun partition() {
+        val string = "Hello"
+        val result = string.partition { it == 'l' }
+        assertPrints(result, "(ll, Heo)")
+    }
+
     @Sample
     fun stringToByteArray() {
         val charset = Charsets.UTF_8

libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt

@@ -580,6 +580,12 @@ object Generators : TemplateGroupBase() {
             while *second* list contains elements for which [predicate] yielded `false`.
             """
         }
+        sample(when (family) {
+                CharSequences, Strings -> "samples.text.Strings.partition"
+                ArraysOfObjects, ArraysOfPrimitives -> "samples.collections.Arrays.Transformations.partitionArrayOfPrimitives"
+                Sequences -> "samples.collections.Sequences.Transformations.partition"
+                else -> "samples.collections.Iterables.Operations.partition"
+        })
         sequenceClassification(terminal)
         returns("Pair<List<T>, List<T>>")
         body {