Any issues with adding a

chunked

(or

chunkedBy

) which takes a predicate instead of an Int? Something like

fun <T> List<T>.chunkedBy(predicate: (T) -> Boolean): List<List<T>> =
    fold(mutableListOf(mutableListOf<T>())) { acc, item ->
        if (predicate(item)) {
            acc.add(mutableListOf())
        } else {
            acc.last().add(item)
        }
        acc
    }

Does

inline val

actually make a difference?

inline val ButWhy get() = "?"

val Difference get() = "?"

I've been doing a lot of libc interaction lately and dealing with bitmasks is quite painful in Kotlin. Furthermore, figuring out how to expose an API to work with bitmasks is even more challenging. For example the

statx

system call defines a bitmask for attributes of a file you'd like to get. I've come up with the following abstraction around this but am not pleased with it because it requires an additional allocation.

public value class FileStatusRequest internal constructor(internal val bitMask: UInt)

@FileRequestDsl public class FileStatusRequestBuilder internal constructor() {

    private var bitMask: UInt = 0u

    public fun requestFileSize() { bitMask = bitMask or STATX_SIZE }

    public fun requestBlocksOccupied() { bitMask = bitMask or STATX_BLOCKS }

    public fun build(): FileStatusRequest = FileStatusRequest(bitMask)
}

Swift has the

OptionSet

protocol which could abstract bitmask operations quite nicely. A Kotlin equivalent might look like the following.

value class FileStatusRequest(internal var bitMask: UInt) : OptionSet<FileStatusTrait> {
  
  override fun insert(trait: FileStatusTrait) { bitMask = bitMask or trait.statxMask }
  override fun remove(trait: FileStatusTrait) { bitMask = bitMask and trait.statxMask.inv() }
}

enum class FileStatusTrait(internal val statxMask: UInt) { ... }

Has the stdlib team considered something like

OptionSet

as a means of wrangling (mainly) bitmasks?

If we could redesign kotlin, what names for numeric primitives would you prefer? 1️⃣ Java-like (current):

Int

,

UInt

,

Long

,

Short

,

Float

,

Double

2️⃣ Rust-like:

I32

,

U32

,

I64

,

I16

,

F32

,

F64

3️⃣ Mixed:

Int32

,

UInt32

,

Int64

,

Int16

,

Float32

,

Float64

🧵 Other?

Hello, I have a question about using Java 9's immutable collection factory functions in Kotlin. I want to make an immutable list (as opposed to a read-only view of a list), mainly for defensive purposes, but when I use

List.of

IntelliJ warns me that it "should be replaced with [the] Kotlin function"

listOf

. If I understand correctly, these two functions are actually very different; is there something I am missing? Is this a false positive?

Does anyone know if there’s any plans yet for kotlin to introduce a type of value class (i know that keyword exists, but it’s for a single value inline class) that’s kind of like a data class, but without the backward compatibliity issues? Ideally it would follow the same rules (must have at least 1 val/var in the constructor, etc…) but generate only toStrings, equals and hashCode. And more importantly NOT generate the

copy

and destructuring functions which can cause backward compatibility issues in libraries.

Just noticed - there's no

List<T>.take(n: Int): List<T>

only

Iterable<T>.take(n: Int): List<T>

which constructs a new ArrayList and copies elements in. Wouldn't this be more efficient on a List, as it could just return a view?

fun List<T>.take(n: Int): List<T> = subList(0, n)

(And of course the same for

drop

)

I’m working with

OpenEndRange

and I’d like to understand the rational for why

ComparableOpenEndRange.equals

specifically checks if the

other

instance is

ComparableOpenEndRange

.

override fun equals(other: Any?): Boolean {
        return other is ComparableOpenEndRange<*> && (isEmpty() && other.isEmpty() ||
                start == other.start && endExclusive == other.endExclusive)
    }

My use case is that I have a custom implementation of

OpenEndRange<LocalDateTime>

which I want to be equitable against

ComparableOpenEndRange

. My implementation of equals checks for this

override fun equals(other: Any?): Boolean = when (other) {
        is LocalTimePeriod -> other.start == start && other.timeZone == timeZone && other.duration == duration
        is OpenEndRange<*> -> other.start == start && other.endExclusive == endExclusive
        else -> false
    }

And therefore equality checking works when my implementation is on the left side of the

==

operator. However when a comparable open range is on the left hand side of the operator, because my custom impl is not an instance of

ComparableOpenEndRange

, the equality check fails. I believe this is an oversight in the stdlib but I’m wondering if this is by design? If so, what is the rationale?

Hey Guys, I was trying to solve a bug in a application here and I noticed something that seems weird to me. Basically I had this code in my application:

fun DownloadManager.isAudiobookCompleted(isbn: String): Boolean {
    return currentDownloads
        .filter { it.audiobookIsbn == isbn }
        .all { it.state == Download.STATE_COMPLETED }
}

Very intuitive where I want to return true, but was buggy. So I went to see why and just realized how the .all works:

/**
 * Returns `true` if all elements match the given [predicate].
 * 
 * @sample samples.collections.Collections.Aggregates.all
 */
public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean {
    if (this is Collection && isEmpty()) return true
    for (element in this) if (!predicate(element)) return false
    return true
}

Basically when the list isEmpty, it returns true. Is't it wrong? I mean, for me it should return true only match the predicate, and if the list is empty for sure don't match the predicate...

Is there an issue that I can follow to track the progress of stabilizing unsigned arrays? I've searched YouTrack briefly and couldn't find it but I'd be surprised if there is none.

what about a

removeLast

on

ArrayList

?

I need to get the sorted frequency of distinct elements in a List. This seems to do what I need:

myList.groupingBy { it }.eachCount().toList().sortedBy { it.second }

Is there any shorter and/or more efficient way of doing this? Maybe some shortcut for

groupingBy { it }

?

would it be feasible to have a

Range

on enums?

I have a list of

data class A(val b: B)

, and a

Comparator<B>

, how can I sort the list with this comparator?

sortedWith()

won’t work because the comparator type doesn’t match.

sortedBy()

allows me to select the inner value

b

, but then doesn’t let me choose my comparator.

The expression

(1 .. 10 step 2)

returns an IntProgression,

('a' .. 'z' step 2)

returns a CharProgression, and there are equivalents for many built in types, but not for user-defined types. Could the stdlib define the

step

function for

ClosedRange<T>

, to return a new stdlib type

Progression<T>

.?

How do you think would it be useful to have an extension function that takes first N elements in a SortedMap? Something like this:

fun <K, V> SortedMap<K, V>.take(count: Int): SortedMap<K, V> {
    if (size <= count) return this
    val found = keys.elementAt(count)
    return headMap(found)
}

also, it is possible to implement

drop

function in the same fashion My case was to take a snapshot of the original tree of depth N.

Is it possible to deprecate a function only for Kotlin? Imagine that I have a function in Java

public static boolean isEmpty(@Nullable CharSequence str) {
	return str == null || str.length() == 0;
}

And I would like to deprecate it for Kotlin users. I can change it to use an stdlib function

@JvmStatic
@Deprecated("Use `isNullOrEmpty`", replaceWith = ReplaceWith("str.isNullOrEmpty()"))
fun isEmpty(str: CharSequence?): Boolean = str.isNullOrEmpty()

and it will warn Kotlin users and guide them towards the stdlib function, however it will also show as

@deprecated

for Java, where it is still needed (

isNullOrEmpty

is

InlineOnly

). Is it possible to show as deprecated only for Kotlin?

How can I refactor this to instead use

kotlin.time.Duration

? I thought this would be simple (it probably still is) but my first attempt didnt result in the behavior I was expecting, and Im not 100% clear on why that is (code for that in 🧵).

fun round(
    duration: Long,
    period: Long = 1000,
): Long {
    val half = period / 2
    return (duration + half) / period * period
}

Does

Array.sliceArray

return a view on the original array, and if not, is there a way to do that?

Whats the best way of converting of converting a List to an immutable list? If I do

driveActivities = drivingActivities.toImmutableList()

The compiler complains because

toImuutableList()

return a

List

I can use

driveActivities = drivingActivities.toPersistentList()

but it somehow feels like I'm leaking Impl details?

Anyone else uses something like this:

fun <T> MutableCollection<T>.addNotNull(elem: T?): Boolean {
    return if (elem !== null) add(elem) else false
}

I find it keeps my code more clean than all the

if (elem !== null) { collection.add(elem) }

boilerplate statements. I was always surprised it doesn’t come with stdlib already (or I couldn’t find it).

Is there a straightforward way to build the Kotlin Std lib for a custom Kotlin target ( https://kotlinlang.slack.com/archives/C7L3JB43G/p1678229027628949 )?

When will it be possible to use ContextReceivers in the shared code? I am expecting this will happen with the new K2 compiler, but at the moment it looks like the K2 compiler is only available for JVM and JS (and hence not for Native or Wasm): https://kotlinlang.org/docs/whatsnew-eap.html#how-to-enable-the-kotlin-k2-compiler Will the upcoming K2-Beta (which I guess will be available in Kotlin 1.9.0) allow the usage of ContextReceivers in the shared code?

Is there a Gradle task available in the Kotlin code base for building the Common module of the Kotlin Std lib?

I'm trying to use

@Deprecated

with

ReplaceWith

, but it doesn't use all the imports. One of the imports is related to the expression used in ReplaceWith, the other is added for a top level extension function which would retrofit the old deprecated usage. But the other one is not automatically included by IDE, when replacing. Is that by design or am I encountering some bug?

Since inline functions cannot use non-public properties etc, what strategy can we use to avoid exposing those properties

inline fun <reified T: Enum<T>> Foo.enumBar(name: String): Bar<T?> = this.propertyToHide.toBar(name)

Shouldn’t this be allowed since we are implementing

FooWrapper

(which is allowed) and

FooWrapper

already extends

Foo

?

sealed interface Foo

interface FooWrapper: Foo {
    val wrappedFoo: Foo
}

// other module

class FooWrapperImpl(
    override val wrappedFoo: Foo,
): FooWrapper, Foo by wrappedFoo // Inheritance of sealed classes or interfaces from different module is prohibited

Recently I needed a

forEachWithNext

, analogous to

zipWithNext

. Could be a nice addition to stdlib. Here's an impl based on `zipWithNext`:

inline fun <T> Iterable<T>.forEachWithNext(block: (a: T, b: T) -> Unit) {
    val iterator = iterator()
    if (!iterator.hasNext()) return
    var current = iterator.next()
    while (iterator.hasNext()) {
        val next = iterator.next()
        block(current, next)
        current = next
    }
}

Is there any utility for turning a hierarchy Kotlin data classes into code. Want to fetch some data from an API, and turn it into executable code for test fixtures.

Hello! Does stdlib contains multiplatform String.format(string, args) function?