Question to the stdlib pros: why is there no extension function

Number.toBigDecimal()

? I struggle with this a lot as there are specific functions

Int.toBigDecimal()

and so on, even for the real tricky cases like

Double.toBigDecimal()

which does the "right" thing using the String constructor of

BigDecimal

rather than the double constructor which may lead to real spooky results... So in my code, I write my own extension function:

fun Number.toBigDecimal(): BigDecimal = when(this) {
    is Short -> this.toBigDecimal()
    is Int -> this.toBigDecimal()
    .......
}

This is highly repetitive and error prone... so, why is this function just missing from the standard lib?

I might've asked this exact question before, so apologies. Why is the internal encoding of

Result

the way that it is? There is a potentially more efficient encoding where you leave failures unboxed, leave most successes unboxed, and only box successes that happen to be throwable. In other words, having the internal encoding be a union of

Throwable | (R - Throwable) | SuccessfulThrowable<R>

Why doesn't

KInterface

exist in

kotlin.reflect

? Its interesting that

KClass

has a boolean property

isFun

, that shows whether the class is a functional interface... Could this be related?

hello, everyone! I am curious to know when Base64 will stop being a

@ExperimentalEncodingApi

. I created some time ago a wrapper for android.util.Base64 which uses Java Base 64 for JVM tests and I wonder if I could fully replace it with the Kotlin version for KMP compatibility without having to change it later

Is there any resource where i can watch for stdlib release notes history?

is it possible to design a recursive default function on an interface to operate on the super type until it "hits" itself? I'm thinking something like this (semi-pseudocode):

interface Foo {
    val selfValue: String

    fun doSomething(): String {
        if (this::class == Foo::class) {
            return "Foo"
        } else {
            return "${super.doSomething()}.$selfValue"
        }
    }
}

The Java API has a constructor that allows you to pass an initial String or CharSequence to initialize it with a sensible initial capacity, e.g.:

val str = StringBuilder("The value of your purchase is ").apply {
    ...do things...
    append(things)
}.toString()

This would be neater if

buildString

had an overload that takes a

String

or

CharSequence

parameter. Without it, we would have to do the above, or the even worse:

val str = buildString("The value of your purchase is ".length + 16) {
    append("The value of your purchase is ")
    ...do things...
    append(things)
}

Has anyone ever made a request for such a function and what was the outcome?

Hello folks, I am trying to benchmark the sequence API vs the stream API vs simple transformations. I am seeing some weird results that the stream API is always the slowest no matter the scenario (even for short circuit). Here is the repo: https://github.com/GeorgePap-719/StreamAllocationBenchmark

Could we get a

TreeMap

in the standard library?

With the new atomic types in the stdlib, is it still necessary to apply the atomicfu plugin? I guess the one from

kotlin

and not the one from

Kotlinx

is still necessary.

We have a sum function for all the primitive types, but not for `BigDecimal`:

listOf(1, 2, 3).sum()
listOf(1.toBigDecimal(), 2.toBigDecimal()).sum()  // Error
listOf(1.toBigDecimal(), 2.toBigDecimal()).sumOf { it }  // OK

Since there is already a

sumOf

function specialized for

BigDecimal

, why isn't there a

sum

function for it too?

Is my guess correct, that there is no left/right versions of binary search in kotlin that can deal with duplicates, the way it's supported in python (

bisect_left

,

bisect_right

)? Sad java Collections legacy

I'm surprised there isn't a

IntRange.size

… Am I missing something?

Wonder why standard library doesn’t have binarySearch variant for arrays?

`Flow`s have a wonderful catch extension, and I wonder if a similar functionality could be added to `Sequence`s? The following implementation appears to work as expected:

fun <T> Sequence<T>.catch(action: suspend SequenceScope<T>.(Throwable) -> Unit): Sequence<T> {
    return sequence {
       try {
          forEach { yield(it) }
       } catch (t: Throwable) {
          action(t)
       }
    }
}

Is the implementation correct? If so, could it be added to stdlib?

The bitwise

and

or

or

operators are in package

kotlin.experimental

? 🤔 https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.experimental/and.html

Hello, is there a reason we got new

AtomicLong

and friends in Kotlin 2.1.20, but still no KMP-compatible

Lock

? I have a use case where I need to ensure a

Map

is edited with no concurrent modifications, and using

kotlinx.coroutines.sync.Mutex

has undesired consequences on the exposed API, and is also overkill.

I noted that in C#, the following LINQ code:

veryLargeList.Order().Take(10).ToList();

Does a Quickselect/partial Quicksort to avoid having to sort the entire array. Is there any chance that Kotlin Sequences can be optimized in the same way?

veryLargeList.asSequence().sorted().take(10).toList()

Hello! Is there an allocation-free, KMP equivalent of Java's

System.nanoTime()

? I want to measure small things (at high frequency), without the measurement affecting the measurement too much.

Clock.System.now()

returns a newly allocated

Instant

, and

TimeSource.Monotonic.markNow()

returns a value class wrapping

ValueTimeMarkReading

, which I think is also not just a primitive but a full allocated object. And

measureTime

uses the latter function…

Any way to make this work? 🙂

package aggregate.common

abstract class Keyed(
    val key: String,
) {
    // Does not compile, Id is value class that wraps String 
    constructor(id: Id) : this(
        key = id.value,
    )

    constructor(keyed: Keyed) : this(
        key = keyed.key,
    )
}

Are there plans to make

Uuid

and

Instant

@Serializable

?

I wonder why we don't have

Uuid.parseOrNull()

This message was deleted.

I keep getting warnings about

timestampOffset

always being 0 here, but its not the case. Compiler bug?

var minTimestamp: Long? = null
var maxTimestamp: Long? = null

journal.trainings.fastForEach { training ->
    val timestamp = training.timestamp.millis

    minTimestamp = minTimestamp?.coerceAtMost(timestamp) ?: timestamp
    maxTimestamp = maxTimestamp?.coerceAtLeast(timestamp) ?: timestamp

    ..
}

val timestampOffset = minTimestamp ?: 0L
val timeSpan = (maxTimestamp ?: timestampOffset) - timestampOffset // "Value of 'timestampOffset' is always zero"

Why doesn't

sortedSetOf()

return

SortedSet

? Currently it returns

TreeSet

, which isn't wrong but feels like it's an unnecessary implementation detail exposure edit: found https://youtrack.jetbrains.com/issue/KT-20972

Has it ever been considered to allow concatenation of `Regex`es that contain different options? A decent number of times, I've had a case where I want to build a regex that is composed mostly of constants, but with a lot of characters that would require escaping. For a very simplified example, it would be very handy if, instead of:

Regex("""java\.lang\.ArrayIndexOutOfBoundsException: Index \d+ out of bounds for length \d+""")

I could write:

Regex("java.lang.ArrayIndexOutOfBoundsException: ", RegexOption.LITERAL) + Regex("""Index \d+ out of bounds for length \d+""")

Hi, I'm wondering why

ReentrantReadWriteLock.write

in

Locks.kt

is marked as

InlineOnly

. Is it to forbid Java from calling it? But what's reason behind it?

listOf(1, 2, 3).containsAll(listOf(2, 2))

returns true. What's the best alternative that will tell me correctly that the first list doesn't, in fact, contain all the elements of the second list? I want to consider the amount of items.

Why

Long.toHexString()

produces a different string comparing to Java one? There are extra

0

padding

Can someone explain to me how this is possible? I mean, it makes sense, A and B are different types, but theyre still value classes.

sealed interface BranchIdentifier {
    val key: String
}

@JvmInline
value class A(override val key: String) : BranchIdentifier

@JvmInline
value class B(override val key: String) : BranchIdentifier

fun main() {
    val collection = mutableSetOf<BranchIdentifier>()
    collection.add(A("5"))
    collection.add(B("5"))
    println(collection.size) // Prints 2
    println(collection.contains(A("5"))) // true
    println(collection.contains(B("5"))) // true
    println(collection.remove(A("5"))) // true
    println(collection.contains(B("5"))) // true
    println(collection.size) // 1
}