diff --git a/libraries/stdlib/common/src/generated/_UArrays.kt b/libraries/stdlib/common/src/generated/_UArrays.kt index 2af2461d8ba..fc75a602cda 100644 --- a/libraries/stdlib/common/src/generated/_UArrays.kt +++ b/libraries/stdlib/common/src/generated/_UArrays.kt @@ -1383,6 +1383,530 @@ public inline fun UShortArray.singleOrNull(predicate: (UShort) -> Boolean): USho return single } +/** + * Returns a list containing all elements except first [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UIntArray.drop(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return takeLast((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except first [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun ULongArray.drop(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return takeLast((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except first [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UByteArray.drop(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return takeLast((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except first [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UShortArray.drop(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return takeLast((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except last [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UIntArray.dropLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return take((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except last [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun ULongArray.dropLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return take((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except last [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UByteArray.dropLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return take((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except last [n] elements. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UShortArray.dropLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + return take((size - n).coerceAtLeast(0)) +} + +/** + * Returns a list containing all elements except last elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.dropLastWhile(predicate: (UInt) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return take(index + 1) + } + } + return emptyList() +} + +/** + * Returns a list containing all elements except last elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.dropLastWhile(predicate: (ULong) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return take(index + 1) + } + } + return emptyList() +} + +/** + * Returns a list containing all elements except last elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.dropLastWhile(predicate: (UByte) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return take(index + 1) + } + } + return emptyList() +} + +/** + * Returns a list containing all elements except last elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.dropLastWhile(predicate: (UShort) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return take(index + 1) + } + } + return emptyList() +} + +/** + * Returns a list containing all elements except first elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.dropWhile(predicate: (UInt) -> Boolean): List { + var yielding = false + val list = ArrayList() + for (item in this) + if (yielding) + list.add(item) + else if (!predicate(item)) { + list.add(item) + yielding = true + } + return list +} + +/** + * Returns a list containing all elements except first elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.dropWhile(predicate: (ULong) -> Boolean): List { + var yielding = false + val list = ArrayList() + for (item in this) + if (yielding) + list.add(item) + else if (!predicate(item)) { + list.add(item) + yielding = true + } + return list +} + +/** + * Returns a list containing all elements except first elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.dropWhile(predicate: (UByte) -> Boolean): List { + var yielding = false + val list = ArrayList() + for (item in this) + if (yielding) + list.add(item) + else if (!predicate(item)) { + list.add(item) + yielding = true + } + return list +} + +/** + * Returns a list containing all elements except first elements that satisfy the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.drop + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.dropWhile(predicate: (UShort) -> Boolean): List { + var yielding = false + val list = ArrayList() + for (item in this) + if (yielding) + list.add(item) + else if (!predicate(item)) { + list.add(item) + yielding = true + } + return list +} + +/** + * Returns a list containing only elements matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.filter(predicate: (UInt) -> Boolean): List { + return filterTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.filter(predicate: (ULong) -> Boolean): List { + return filterTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.filter(predicate: (UByte) -> Boolean): List { + return filterTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.filter(predicate: (UShort) -> Boolean): List { + return filterTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.filterIndexed(predicate: (index: Int, UInt) -> Boolean): List { + return filterIndexedTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.filterIndexed(predicate: (index: Int, ULong) -> Boolean): List { + return filterIndexedTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.filterIndexed(predicate: (index: Int, UByte) -> Boolean): List { + return filterIndexedTo(ArrayList(), predicate) +} + +/** + * Returns a list containing only elements matching the given [predicate]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.filterIndexed(predicate: (index: Int, UShort) -> Boolean): List { + return filterIndexedTo(ArrayList(), predicate) +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UIntArray.filterIndexedTo(destination: C, predicate: (index: Int, UInt) -> Boolean): C { + forEachIndexed { index, element -> + if (predicate(index, element)) destination.add(element) + } + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > ULongArray.filterIndexedTo(destination: C, predicate: (index: Int, ULong) -> Boolean): C { + forEachIndexed { index, element -> + if (predicate(index, element)) destination.add(element) + } + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UByteArray.filterIndexedTo(destination: C, predicate: (index: Int, UByte) -> Boolean): C { + forEachIndexed { index, element -> + if (predicate(index, element)) destination.add(element) + } + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + * @param [predicate] function that takes the index of an element and the element itself + * and returns the result of predicate evaluation on the element. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UShortArray.filterIndexedTo(destination: C, predicate: (index: Int, UShort) -> Boolean): C { + forEachIndexed { index, element -> + if (predicate(index, element)) destination.add(element) + } + return destination +} + +/** + * Returns a list containing all elements not matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.filterNot(predicate: (UInt) -> Boolean): List { + return filterNotTo(ArrayList(), predicate) +} + +/** + * Returns a list containing all elements not matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.filterNot(predicate: (ULong) -> Boolean): List { + return filterNotTo(ArrayList(), predicate) +} + +/** + * Returns a list containing all elements not matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.filterNot(predicate: (UByte) -> Boolean): List { + return filterNotTo(ArrayList(), predicate) +} + +/** + * Returns a list containing all elements not matching the given [predicate]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.filterNot(predicate: (UShort) -> Boolean): List { + return filterNotTo(ArrayList(), predicate) +} + +/** + * Appends all elements not matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UIntArray.filterNotTo(destination: C, predicate: (UInt) -> Boolean): C { + for (element in this) if (!predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements not matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > ULongArray.filterNotTo(destination: C, predicate: (ULong) -> Boolean): C { + for (element in this) if (!predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements not matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UByteArray.filterNotTo(destination: C, predicate: (UByte) -> Boolean): C { + for (element in this) if (!predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements not matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UShortArray.filterNotTo(destination: C, predicate: (UShort) -> Boolean): C { + for (element in this) if (!predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UIntArray.filterTo(destination: C, predicate: (UInt) -> Boolean): C { + for (element in this) if (predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > ULongArray.filterTo(destination: C, predicate: (ULong) -> Boolean): C { + for (element in this) if (predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UByteArray.filterTo(destination: C, predicate: (UByte) -> Boolean): C { + for (element in this) if (predicate(element)) destination.add(element) + return destination +} + +/** + * Appends all elements matching the given [predicate] to the given [destination]. + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun > UShortArray.filterTo(destination: C, predicate: (UShort) -> Boolean): C { + for (element in this) if (predicate(element)) destination.add(element) + return destination +} + /** * Returns a list containing elements at indices in the specified [indices] range. */ @@ -1555,6 +2079,310 @@ public fun UShortArray.sliceArray(indices: IntRange): UShortArray { return UShortArray(storage.sliceArray(indices)) } +/** + * Returns a list containing first [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UIntArray.take(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + if (n >= size) return toList() + if (n == 1) return listOf(this[0]) + var count = 0 + val list = ArrayList(n) + for (item in this) { + if (count++ == n) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun ULongArray.take(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + if (n >= size) return toList() + if (n == 1) return listOf(this[0]) + var count = 0 + val list = ArrayList(n) + for (item in this) { + if (count++ == n) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UByteArray.take(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + if (n >= size) return toList() + if (n == 1) return listOf(this[0]) + var count = 0 + val list = ArrayList(n) + for (item in this) { + if (count++ == n) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UShortArray.take(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + if (n >= size) return toList() + if (n == 1) return listOf(this[0]) + var count = 0 + val list = ArrayList(n) + for (item in this) { + if (count++ == n) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing last [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UIntArray.takeLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + val size = size + if (n >= size) return toList() + if (n == 1) return listOf(this[size - 1]) + val list = ArrayList(n) + for (index in size - n until size) + list.add(this[index]) + return list +} + +/** + * Returns a list containing last [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun ULongArray.takeLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + val size = size + if (n >= size) return toList() + if (n == 1) return listOf(this[size - 1]) + val list = ArrayList(n) + for (index in size - n until size) + list.add(this[index]) + return list +} + +/** + * Returns a list containing last [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UByteArray.takeLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + val size = size + if (n >= size) return toList() + if (n == 1) return listOf(this[size - 1]) + val list = ArrayList(n) + for (index in size - n until size) + list.add(this[index]) + return list +} + +/** + * Returns a list containing last [n] elements. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +public fun UShortArray.takeLast(n: Int): List { + require(n >= 0) { "Requested element count $n is less than zero." } + if (n == 0) return emptyList() + val size = size + if (n >= size) return toList() + if (n == 1) return listOf(this[size - 1]) + val list = ArrayList(n) + for (index in size - n until size) + list.add(this[index]) + return list +} + +/** + * Returns a list containing last elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.takeLastWhile(predicate: (UInt) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return drop(index + 1) + } + } + return toList() +} + +/** + * Returns a list containing last elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.takeLastWhile(predicate: (ULong) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return drop(index + 1) + } + } + return toList() +} + +/** + * Returns a list containing last elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.takeLastWhile(predicate: (UByte) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return drop(index + 1) + } + } + return toList() +} + +/** + * Returns a list containing last elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.takeLastWhile(predicate: (UShort) -> Boolean): List { + for (index in lastIndex downTo 0) { + if (!predicate(this[index])) { + return drop(index + 1) + } + } + return toList() +} + +/** + * Returns a list containing first elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UIntArray.takeWhile(predicate: (UInt) -> Boolean): List { + val list = ArrayList() + for (item in this) { + if (!predicate(item)) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun ULongArray.takeWhile(predicate: (ULong) -> Boolean): List { + val list = ArrayList() + for (item in this) { + if (!predicate(item)) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UByteArray.takeWhile(predicate: (UByte) -> Boolean): List { + val list = ArrayList() + for (item in this) { + if (!predicate(item)) + break + list.add(item) + } + return list +} + +/** + * Returns a list containing first elements satisfying the given [predicate]. + * + * @sample samples.collections.Collections.Transformations.take + */ +@SinceKotlin("1.3") +@ExperimentalUnsignedTypes +@kotlin.internal.InlineOnly +public inline fun UShortArray.takeWhile(predicate: (UShort) -> Boolean): List { + val list = ArrayList() + for (item in this) { + if (!predicate(item)) + break + list.add(item) + } + return list +} + /** * Reverses elements in the array in-place. */ diff --git a/libraries/stdlib/test/collections/UnsignedArraysTest.kt b/libraries/stdlib/test/collections/UnsignedArraysTest.kt index 2e1747f29cb..14428bbba31 100644 --- a/libraries/stdlib/test/collections/UnsignedArraysTest.kt +++ b/libraries/stdlib/test/collections/UnsignedArraysTest.kt @@ -823,4 +823,104 @@ class UnsignedArraysTest { ) } + @Test + fun drop() { + expect(listOf(1.toUByte())) { ubyteArrayOf(1).drop(0) } + expect(listOf()) { ushortArrayOf().drop(1) } + expect(listOf()) { uintArrayOf(1).drop(1) } + expect(listOf(3uL)) { ulongArrayOf(2, 3).drop(1) } + assertFails { + uintArrayOf(2).drop(-1) + } + } + + @Test + fun dropLast() { + expect(listOf()) { ubyteArrayOf().dropLast(1) } + expect(listOf()) { ushortArrayOf(1).dropLast(1) } + expect(listOf(1u)) { uintArrayOf(1).dropLast(0) } + expect(listOf(2uL)) { ulongArrayOf(2, 3).dropLast(1) } + assertFails { + ulongArrayOf(1).dropLast(-1) + } + } + + @Test + fun dropWhile() { + expect(listOf(3.toUByte(), 1.toUByte())) { ubyteArrayOf(2, 3, 1).dropWhile { it < 3 } } + expect(listOf()) { ushortArrayOf().dropWhile { it < 3 } } + expect(listOf()) { uintArrayOf(1).dropWhile { it < 3 } } + expect(listOf(3uL, 1uL)) { ulongArrayOf(2, 3, 1).dropWhile { it < 3 } } + } + + @Test + fun dropLastWhile() { + expect(listOf(2.toUByte(), 3.toUByte())) { ubyteArrayOf(2, 3, 1).dropLastWhile { it < 3 } } + expect(listOf()) { ushortArrayOf().dropLastWhile { it < 3 } } + expect(listOf()) { uintArrayOf(1).dropLastWhile { it < 3 } } + expect(listOf(2uL, 3uL)) { ulongArrayOf(2, 3, 1).dropLastWhile { it < 3 } } + } + + @Test + fun take() { + expect(listOf()) { ubyteArrayOf().take(1) } + expect(listOf()) { ushortArrayOf(1).take(0) } + expect(listOf(1u)) { uintArrayOf(1).take(1) } + expect(listOf(2uL)) { ulongArrayOf(2, 3).take(1) } + assertFails { + ubyteArrayOf(1).take(-1) + } + } + + @Test + fun takeLast() { + expect(listOf()) { ubyteArrayOf().takeLast(1) } + expect(listOf()) { ushortArrayOf(1).takeLast(0) } + expect(listOf(1u)) { uintArrayOf(1).takeLast(1) } + expect(listOf(3uL)) { ulongArrayOf(2, 3).takeLast(1) } + assertFails { + ushortArrayOf(1).takeLast(-1) + } + } + + @Test + fun takeWhile() { + expect(listOf(2.toUByte())) { ubyteArrayOf(2, 3, 1).takeWhile { it < 3 } } + expect(listOf()) { ushortArrayOf().takeWhile { it < 3 } } + expect(listOf(1u)) { uintArrayOf(1).takeWhile { it < 3 } } + expect(listOf(2uL)) { ulongArrayOf(2, 3, 1).takeWhile { it < 3 } } + } + + @Test + fun takeLastWhile() { + expect(listOf()) { ubyteArrayOf().takeLastWhile { it < 3 } } + expect(listOf(1.toUShort())) { ushortArrayOf(1).takeLastWhile { it < 3 } } + expect(listOf(1u)) { uintArrayOf(2, 3, 1).takeLastWhile { it < 3 } } + expect(listOf(1uL)) { ulongArrayOf(2, 3, 1).takeLastWhile { it < 3 } } + } + + @Test + fun filter() { + expect(listOf(3.toByte())) { byteArrayOf(2, 3).filter { it > 2 } } + expect(listOf()) { ushortArrayOf().filter { it > 2 } } + expect(listOf()) { uintArrayOf(1).filter { it > 2 } } + expect(listOf(3uL)) { ulongArrayOf(2, 3).filter { it > 2 } } + } + + @Test + fun filterIndexed() { + expect(listOf(2, 5, 8)) { ubyteArrayOf(2, 4, 3, 5, 8).filterIndexed { index, value -> index % 2 == (value % 2).toInt() } } + expect(listOf()) { ushortArrayOf().filterIndexed { i, v -> i > v.toInt() } } + expect(listOf(2, 5, 8)) { uintArrayOf(2, 4, 3, 5, 8).filterIndexed { index, value -> index % 2 == (value % 2).toInt() } } + expect(listOf(2, 5, 8)) { ulongArrayOf(2, 4, 3, 5, 8).filterIndexed { index, value -> index % 2 == (value % 2).toInt() } } + } + + @Test + fun filterNot() { + expect(listOf(2.toUByte())) { ubyteArrayOf(2, 3).filterNot { it > 2 } } + expect(listOf()) { ushortArrayOf().filterNot { it > 2 } } + expect(listOf(1u)) { uintArrayOf(1).filterNot { it > 2 } } + expect(listOf(2uL)) { ulongArrayOf(2, 3).filterNot { it > 2 } } + } + } \ No newline at end of file diff --git a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt index dbff3a18daa..4d702b3f317 100644 --- a/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt +++ b/libraries/tools/binary-compatibility-validator/reference-public-api/kotlin-stdlib-runtime-merged.txt @@ -2311,6 +2311,14 @@ public final class kotlin/collections/UArraysKt { public static final fun contentToString-GBYM_sE ([B)Ljava/lang/String; public static final fun contentToString-QwZRm1k ([J)Ljava/lang/String; public static final fun contentToString-rL5Bavg ([S)Ljava/lang/String; + public static final fun drop-PpDY95g ([BI)Ljava/util/List; + public static final fun drop-nggk6HY ([SI)Ljava/util/List; + public static final fun drop-qFRl0hI ([II)Ljava/util/List; + public static final fun drop-r7IrZao ([JI)Ljava/util/List; + public static final fun dropLast-PpDY95g ([BI)Ljava/util/List; + public static final fun dropLast-nggk6HY ([SI)Ljava/util/List; + public static final fun dropLast-qFRl0hI ([II)Ljava/util/List; + public static final fun dropLast-r7IrZao ([JI)Ljava/util/List; public static final fun fill-2fe2U9s ([IIII)V public static synthetic fun fill-2fe2U9s$default ([IIIIILjava/lang/Object;)V public static final fun fill-EtDCXyQ ([SSII)V @@ -2391,6 +2399,14 @@ public final class kotlin/collections/UArraysKt { public static final fun sumOfUInt ([Lkotlin/UInt;)I public static final fun sumOfULong ([Lkotlin/ULong;)J public static final fun sumOfUShort ([Lkotlin/UShort;)I + public static final fun take-PpDY95g ([BI)Ljava/util/List; + public static final fun take-nggk6HY ([SI)Ljava/util/List; + public static final fun take-qFRl0hI ([II)Ljava/util/List; + public static final fun take-r7IrZao ([JI)Ljava/util/List; + public static final fun takeLast-PpDY95g ([BI)Ljava/util/List; + public static final fun takeLast-nggk6HY ([SI)Ljava/util/List; + public static final fun takeLast-qFRl0hI ([II)Ljava/util/List; + public static final fun takeLast-r7IrZao ([JI)Ljava/util/List; public static final fun toTypedArray--ajY-9A ([I)[Lkotlin/UInt; public static final fun toTypedArray-GBYM_sE ([B)[Lkotlin/UByte; public static final fun toTypedArray-QwZRm1k ([J)[Lkotlin/ULong; diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt index f0231aa0421..ee8aedcc542 100644 --- a/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt @@ -39,7 +39,7 @@ object Filtering : TemplateGroupBase() { val f_drop = fn("drop(n: Int)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { val n = "\$n" doc { @@ -115,7 +115,7 @@ object Filtering : TemplateGroupBase() { """ } - body(ArraysOfObjects, ArraysOfPrimitives) { + body(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) { """ require(n >= 0) { "Requested element count $n is less than zero." } return takeLast((size - n).coerceAtLeast(0)) @@ -125,7 +125,7 @@ object Filtering : TemplateGroupBase() { val f_take = fn("take(n: Int)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { val n = "\$n" doc { @@ -185,7 +185,7 @@ object Filtering : TemplateGroupBase() { """ } - body(ArraysOfObjects, ArraysOfPrimitives) { + body(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) { """ require(n >= 0) { "Requested element count $n is less than zero." } if (n == 0) return emptyList() @@ -204,7 +204,7 @@ object Filtering : TemplateGroupBase() { } val f_dropLast = fn("dropLast(n: Int)") { - include(Lists, ArraysOfObjects, ArraysOfPrimitives, CharSequences, Strings) + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned, CharSequences, Strings) } builder { val n = "\$n" @@ -234,7 +234,7 @@ object Filtering : TemplateGroupBase() { } val f_takeLast = fn("takeLast(n: Int)") { - include(Lists, ArraysOfObjects, ArraysOfPrimitives, CharSequences, Strings) + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned, CharSequences, Strings) } builder { val n = "\$n" doc { @@ -262,7 +262,7 @@ object Filtering : TemplateGroupBase() { """ } - body(ArraysOfObjects, ArraysOfPrimitives) { + body(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) { """ require(n >= 0) { "Requested element count $n is less than zero." } if (n == 0) return emptyList() @@ -299,9 +299,10 @@ object Filtering : TemplateGroupBase() { val f_dropWhile = fn("dropWhile(predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { """ @@ -355,9 +356,10 @@ object Filtering : TemplateGroupBase() { val f_takeWhile = fn("takeWhile(predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { """ @@ -406,9 +408,11 @@ object Filtering : TemplateGroupBase() { } val f_dropLastWhile = fn("dropLastWhile(predicate: (T) -> Boolean)") { - include(Lists, ArraysOfObjects, ArraysOfPrimitives, CharSequences, Strings) + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned, CharSequences, Strings) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } + doc { """ Returns a list containing all elements except last elements that satisfy the given [predicate]. @@ -462,9 +466,11 @@ object Filtering : TemplateGroupBase() { } val f_takeLastWhile = fn("takeLastWhile(predicate: (T) -> Boolean)") { - include(Lists, ArraysOfObjects, ArraysOfPrimitives, CharSequences, Strings) + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned, CharSequences, Strings) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } + doc { """ Returns a list containing last elements satisfying the given [predicate]. @@ -528,9 +534,10 @@ object Filtering : TemplateGroupBase() { val f_filter = fn("filter(predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { "Returns a ${f.mapResult} containing only ${f.element.pluralize()} matching the given [predicate]." } returns("List") @@ -555,9 +562,10 @@ object Filtering : TemplateGroupBase() { val f_filterTo = fn("filterTo(destination: C, predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences) + include(CharSequences, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { "Appends all ${f.element.pluralize()} matching the given [predicate] to the given [destination]." } typeParam("C : TCollection") @@ -583,9 +591,10 @@ object Filtering : TemplateGroupBase() { val f_filterIndexed = fn("filterIndexed(predicate: (index: Int, T) -> Boolean)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { """ @@ -627,9 +636,10 @@ object Filtering : TemplateGroupBase() { val f_filterIndexedTo = fn("filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean)") { includeDefault() - include(CharSequences) + include(CharSequences, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { """ @@ -652,9 +662,10 @@ object Filtering : TemplateGroupBase() { val f_filterNot = fn("filterNot(predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences, Strings) + include(CharSequences, Strings, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { "Returns a list containing all elements not matching the given [predicate]." } returns("List") @@ -680,9 +691,10 @@ object Filtering : TemplateGroupBase() { val f_filterNotTo = fn("filterNotTo(destination: C, predicate: (T) -> Boolean)") { includeDefault() - include(CharSequences) + include(CharSequences, ArraysOfUnsigned) } builder { inline() + specialFor(ArraysOfUnsigned) { inlineOnly() } doc { "Appends all elements not matching the given [predicate] to the given [destination]." } typeParam("C : TCollection")