I have a `List<*> that I want to make a map out of based on the objects

id

. These `id`s are unique. I know I can use

groupBy

to create a map but that results in

Map<Long, List<*>>

when I would much rather have

Map<Long, *>

. Is there a nice idiomatic way to do this in :kotlin:?

Ah, don't know how I missed that in the docs. Huge thanks! Also for future reference, this didn't seem like a great channel to post this in, but I couldn't find anything else for just generic language questions. Is there some other place I should know about?

I just stumbled upon this post on /r/kotlin: https://www.reddit.com/r/Kotlin/comments/axnr0o/negative_zero_00_is_equal_to_zero_sometimes/ Why does this happen? Is it a bug?

println(-0.0 == 0.0) // true
println("${-0.0 == 0.0}") // false

Is it possible to create a function overload with the suspend modifier without changing packages? I would like to create something like

fun foo(fn: () -> Unit) {}
suspend fun foo(fn: suspend () -> Unit) {}

but in the same package

How do you guys solve function overloads with different generics? Is there any way of doing this without creating one overload for every possibility?

fun foo<A>(a: A) {}
fun foo<A, B>(a: A, b: B){}
fun foo<A,B,C>(a: A, b: B, c: C) { }
...
until foo<125> types

Hello. Can someone please help me understand the difference between, and use-cases for, konan and kotlin-multiplatform plugins. I've spent most of a day looking at the docs and tutorials and samples but I'm still confused. I've also seen one suggestion from a contributor to JetBrains repos that konan is deprecated, and multiplatform should be used, but I can't find any official source backing that assertion.

Hello, everyone!

is there a way to tell a kotlin ByteArray that it needs to be cast to an array of bytes for an overloaded vararg byte?

no. the representations in memory are not the same. you need to do something like

Array(bytes.size) { bytes[it] }

to box. i don't think there's built-in array boxing functions

how to stop rewatching?

What is the rule for the accessibility of constructor arguments within the

init

block? If there’s more than one constructor, you can’t access any arguments? Or is it something different?

looking for someone who is familiar with https://github.com/orangy/squash

Is there any hard and fast rule of when to declare functions as inline and when not declare inline

Does anyone use some kind of generic Result (Success / Error) monad for error modeling?

It is good practice to get rid of exceptions and model your errors. Either is a great way of doing so. Using sealed classes for errors: You can ‘nest’ sealed classes, have nested, yet exhaustive hierarchies

otherwise you might just stick with boolean

(0.0).equals(-0.0)  // false
(0.0) == (-0.0)     // true

Does anyone can explain it?

Hi! Is it possible to map a MutableMap<String, String> into a MutableMap<String, Float> using a method like

mapValues

?

Is anyone using kotlin with scala ? I am planing to eventually migrate 10 Million LOC from scala to kotlin. I know that the interoperability with scala isn't good. But just wanted to know if any one has experienced some hurdles/extreme pain points in doing so

How to make

hi

also display

: String

(hint, not typed)?

alt + enter -> Show property type hints

i’m wondering if there’s a clever way to chunk a list of Ints based on the delta between the first and last elements. i.e. chunks should be created such that (lastElement - firstElement <= X).

originalList = listOf(1, 2, 3, 4, 5, 10, 11, 14, 15, 19, 22);
chunks = originalList.chunkMaxDifference(5);
chunks = ((1, 2, 3, 4, 5), (10, 11, 14, 15), (19, 22))

i came up with this, but i wonder if there’s a better way:

fun List<Int>.chunkMaxDifference(maxDifference: Int): List<List<Int>> {
    val chunks = mutableListOf<List<Int>>()
    if (this.isEmpty()) {
        return chunks
    }
    var currentChunk = mutableListOf<Int>(first())
    chunks.add(currentChunk)
    // Ignore the first value which we already put in the current chunk
    subList(1, size).forEach {
        if (it - currentChunk.first() > maxDifference) {
            currentChunk = mutableListOf(it)
            chunks.add(currentChunk)
        } else {
            currentChunk.add(it)
        }
    }
    return chunks
}

I really miss IntelliJ's extract method object refactoring in Kotlin. Are there plans to support this?

It seems like

list + element

copies the whole list and adds an element. Are there any plan to create truly immutable lists so that plus operator uses old list with pointer to new element?

Is there any Kotlin'ish way to use default values of function and constructor parameters programmatically or is this only possible with reflection and relying on the internals of the synthetic overloads (which also only works on the JVM)?

class Test(val a: Int = 1, val b: Int = 2, val c: Int = 3)

fun test() {
	var a: Int? = null
	var b: Int? = null
	var c: Int? = null
	if (someCondition) a = somethingNonNull
	if (someCondition) b = somethingNonNull
	if (someCondition) c = somethingNonNull

	Test(
		a = a ?: howToUseDefaultValue, // ??
		b = b ?: howToUseDefaultValue, // ??
		c = c ?: howToUseDefaultValue // ??
	)
}

is

@Throws

annotation worth anything in practise?

is it worth calling the asSequence funtion like this

kinesisEvent.records.asSequence()

before calling foreach in this example:

// event: List<KinesisEvent.KinesisEventRecord>

 event.records.forEach {
            try {
                val putRecordsRequest = PutRecordsRequest()
                putRecordsRequest.streamName = "test-stream" 
                val putRecordsRequestEntryList = ArrayList<PutRecordsRequestEntry>()
                for (i in 0..499) {
                    val putRecordsRequestEntry = PutRecordsRequestEntry()
                    putRecordsRequestEntry.data = it.kinesis.data
                    putRecordsRequestEntry.partitionKey = it.kinesis.partitionKey
                    putRecordsRequestEntryList.add(putRecordsRequestEntry)
                }
                putRecordsRequest.setRecords(putRecordsRequestEntryList)
                val putRecordsResult = kinesisClient.putRecords(putRecordsRequest)

            } catch (e: InterruptedException) {
                //log error here
            }

maybe a question for someone from jetbrains, unless somebody else knows the answer. But why is it that we only have 5

component

extension properties on a collection, but with a data class we generate

componentN

up until (what i'm assuming, couldn't find documentation on it) we reach the limit of functions that can be created in a class on the JVM?

Shame. On the upside, it’s all perf wins optimizing code from there 😄