and will

distinctBy { <http://it.id|it.id> }

be more efficient over distinct() for those object having an id field?

Does anyone know why

kotlin-stdlib

is published without the gradle metadata? https://repo1.maven.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.7.0-RC2/

Is there a reason the Base64 support in 1.8.20 doesn't have an option to omit padding? The RFC allows it (https://www.rfc-editor.org/rfc/rfc4648#section-3.2) and some other specifications like OAuth PKCE require it (https://www.rfc-editor.org/rfc/rfc7636#section-3).

I need to deduplicate a list of data classes by a particular property of the data class. I have this, but it feels like a roundabout way of doing it:

list.groupBy { it.property }.map { (_, list) -> list.first() }

Is there a simpler way? This is something I would normally solve with

.toSet()

, except I only want to consider one property of the data class, not the entire item.

Hi everyone, As far back as I remember (Kotlin 1.3.40 or so?) the Contracts API has been part of the standard library, most notably in

Preconditions.kt

as part of the implementation of

check{,NotNull}

and

require{,NotNull}

et al. Today I discovered I can write similar blocks in my own code like this as long as I opt-in for `@ExperimentalContracts`:

fun checkSomeType(value: SomeSuperType) {
    contract {
        returns() implies (value is SomeType)
    }

    check(value is SomeType) {
        "error"
    }
}

My question is multi-faceted. Has the contracts API always been "experimental"? If so, what's left for it to become "stable" given how long it's been around? If not, is it marked "experimental" because it's becoming part of the public standard library API?

Is there a function to create a

Comparable

from a

Comparator

? If there is none, I think it would be a nice addition, to make this possible:

class Foo(…) : Comparable<Foo> by fooComparator.asComparable() {

    companion object {
        private val fooComparator = compareBy({…}, {…}) // use the stdlib convenience functions for comparators
    }
}

Otherwise, it's not possible to reuse these convenience functions

Hello! Trying to find multiplatform solution for formatting floating point numbers to String and found this https://youtrack.jetbrains.com/issue/KT-21644/Add-utility-function-for-formatting-of-decimal-numbers-to-Kotlin-common-library . Just wonder if there are not too much cases where it is needed that this issue is still in open state for 5 years? Or is there any blockers?

Hi everyone, I have a sealed type that I'm working with that maintains a mapping of extra attributes that in the context of my application will be subject to create/update/delete operations by a user through a form interface and each subtype has their own default attributes that aren't proper properties in this case because those are subject to removal by the user as well. More in 🧵.

I started to use unsigned integers and I was surprised that I cannot use them where a

Number

is expected (in my case it was a generic function with a type parameter

<T: Number>

). I have checked the corresponding KEEP and found this:

Number

is an abstract class in Kotlin, and inline classes are not allowed to extend other classes, therefore unsigned types can't be inherited from

Number

class.

We haven't found compelling use cases to circumvent this limitation specially for the unsigned types.

My questions: 1. Is it really "good enough" to have non-unified "number" handling in Kotlin? 2. Why is

Number

an

abstract class

and not an

interface

? It has only some abstract functions, nothing else. Thanks.

How do I express in a contract that a condition is true inside a lambda? As in, I want to combine the power of

returns

with

callsInPlace

. For instance, I have an inline higher-order function that takes an

enabled: Boolean

parameter, and it only calls the block passed to it if

enabled

is true. How do I say that

enabled

is

true

inside of the

block

? E.g.:

@OptIn(ExperimentalContracts::class)
inline fun runIf(condition: Boolean, block: () -> Unit) {
    contract { 
        callsInPlace(block, InvocationKind.AT_MOST_ONCE)
    }
    if(condition) block()
}

fun main() {
    val test: String? = "Hello"
    runIf(test != null) {
        test.length
    }
}

Yes that example is stupid, but my use-case provides parameters to

block

and hence it can't just return a

Boolean

Why is there a isNullOrEmpty for Array<Int> but not for IntArray in stdlib?

Is there a more efficient

Set<Char>

implementation than

setOf(' ', '\n', ...)

for checking if an input character is in a particular set of characters?

I'd like to see extension methods like

equals

,

hashCode

, and

toString

for collections that each take a lambda, so you can specify a specific field that you want to check for equality or a substitute method to determine if two elements are equal, and so on. I don't think there's a simple way to write the

equals

currently without involving sequences (preventing inlining), ensuring same size and then

all

on indices and manually comparing (which is how I expect a method to be implemented, edit: that requires efficient random access, using the iterators directly would be required), or mapping each list to the desired field to compare or hash or whatnot (which means creating two unnecessary intermediate collections).

Is

AutoCloseable

set to be stable in 1.9? I saw that the JVM-specific typealias will be stable in 1.9, but does that mean the other platforms will be stable as well? It's 2.0 per https://youtrack.jetbrains.com/issue/KT-55777/Unresolved-kotlin.AutoCloseable-in-JVM#focus=Comments-27-7285243.0-0

Salut! https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm.optionals/java.util.-optional/ These docs don't reflect the actual functions in the source code: https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/jdk8/src/kotlin/jvm/optionals/Optionals.kt What is the right way to report and fix this?

In order to improve creating scripts without IDE support, adding this

typealias File = java.io.File

to the kotlin stdlib in the jvm part would be great, so we don't have to remember to add the import. But I don't know if there are plans to add a real multiplatform

File

to the stdlib "soon"

What's up with this behavior:

fun main() {
    val x = Double.NaN
    println(x == x)
    println(listOf(x) == listOf(x))
}

This prints

false
true

Currently when I do

object Stuff

and call

toString()

on it, it includes hex. I recall there were some news about nicer toString for objects, but I can't find them now, maybe someone remembers?

Do not know if this is the correct forum. Is there any example of calling the embedded compiler from code?

Useful potential method:

joinToString

, but instead of a

transform

lambda, it takes

build: StringBuilder.(T) -> Unit

. That avoids creating intermediate strings for each element if multiple

append

calls would be more efficient.

joinToString

not being inline has been a (rather mild) inconvenience for me. Is there a reason why it isn't? I know that the stdlib is using a default value of

null

for the transform lambda, but couldn't it just use

it.toString()

?

I doubt that this is possible, but I thought Id ask anyway! Value classes come with a default toString that results in `Count(value=5)`; is it possible to somehow override these defaults to instead just print the value (5) instead?

with the introduction of a lot of

orNull

functions in mind, I was unpleasantly surprised there is no such thing as

List<T>.indexOfFirstOrNull

Is there a roadmap of experimental stdlib features published anywhere? I’m hoping to find out when

OpenEndRange

might be stabilized

isn't there a function to sort in place an

IntArray

with a given comparator? I see only

sortedWith

, which returns a new sorted list

Is there any good reason for the lack of

mapOfNotNull

in stdlib to build a map from a list of nullable pairs from which only non-null pairs will be taken? There are two other functions (

listOfNotNull

and

setOfNotNull

) here and it seems quite reasonable to have a similar function for maps for the sake of consistency. I know that you can just write your own implementation, but it’s unlikely that you will do it most optimal and correct way (just for example, you should probably not forget about inlined

mapOfNotNull() = emptyMap()

, and etc).

I'm mourning the fact that there's no sumOf for float values. Does anyone know why that is, considering that alternatives exist for so many other number types? I've added it myself locally - so really just curious 🙏🏽

I am quite surprised that there isn’t a

runningReduceRight

and `runningFoldRight`/`scanRight` for symmetry with the

reduce

and

reduceRight

/

fold

and

foldRight

functions. Is there a technical reason behind this? I often find myself ad-hoc-ing

foldRight

to be a

scanRight

for LeetCode and other competitive programming problems.

Since when can you do this with secondary constructors? Whats the feature called?

@JvmInline
value class Token(
    private val value: String,
) {


    constructor() : this("1337") { 
     // **THIS**
     println(value) 
    }
}