Can anyone explain why this snippet compiles (and executes) without errors? (

get

operator in kotlin is strictly typed)

fun main() {
    val intList: List<Int> = listOf(1, 2)
    val stringMap: Map<String, String> = mapOf("abc" to "xyz")
    val x = intList.associateWith { map[it] } // should be an error, because key is String, and not Int
    println(x)
}

Kotlin: 1.4.21

Is it possible to use

kotlinc

programatically? I’d like to compile a kotlin class from a kotlin source file in a JVM app at runtime.

Second question - I’d like to enforce, at compile time, that some compiled code does no I/O. Obviously I can control what dependencies are available to it, but is there a relatively easy way to (comprehensively!) exclude all Java & Kotlin stdlib classes that do I/O, directly or transitively, from compilation? I suspect no, but I do feel that being able to enforce at compile time a strong separation of concerns between code that does and does not do I/O would be useful.

When developing for JVM, I can run my code from the

main

function. When on multiplatform, is there a way to do the same thing for JS?

I’ve heard a rumor that the

when

statement can evaluate its cases in constant time, because the compiler will change the switch structure to a map. Does anyone know if this is true?

Has anyone thought about contributing a Kotlin pattern for git's function detection in diffs? https://github.com/git/git/blob/master/userdiff.c

How do you upsert a list of objects in Java or in Kotlin. What is the best practice or the best chain for something like upserting a setting. Scenario one match-id can have many settings and that can change.

data class Setting(val typeId: Int, val type: String, val isSubscribed: Boolean, val matchId: Int)

    val settings = mutableListOf(Setting(1, "Goal Notification", true, matchId = 123), Setting(2, "Half Time Notification", true, matchId = 567))

    //upsert?/
    val newSettings = settings.add(Setting(1, "Goal Notification", false, matchId = 123))

    val latestSettings = settings.filter { setting -> setting.typeId == 1 }.map {
        // add or update over here
    }

Hi! I have one question regarding lazy variables. Is something like that possible?

val myNotRequiredStuff : SomeClass by lazy { SomeClass(...) }
...
fun onDestroy() {
    myNotRequiredStuff.useIfCreated {
        myNotRequiredStuff.destroy()
    }
}

I am passing a pickle object from a python software through a TCP socket and receiving it in my kotlin application. Does anyone know how I could unpickle it to retrieve my data ?

After upgrading the IDE plugin to 1.4.21, the plugin now throws Gradle-related exceptions all the time and there is no code completion in .gradle-kts files anymore. After downgrading to 1.4.10 it works again. I cannot find a 1.4.20 release for 2020.3. Does anybody know a page where you can see all releases?

is it possible to declare a generic type that is kotlinx-serializable? something like. <T : “i am serializable”>

how can I use kotlin-reflect to get all subclasses of an abstract base class? the base class is NOT sealed

I have :

interface A<T>

I want to write a function that takes an

A

and a value of the same type. Intuitively, this would look like:

fun <T> foo(a: A<T>, v: T)

The problem is that if I call it this way:

val a: A<String> = ...
val v: Int = ...
foo(a, v)

It calls

foo<Any>(a, v)

, but I want it to call

foo<String>(a, v)

(and fail, because `v`'s type doesn't match what was expected by

a

). This function is fairly simple, so solutions using

reified

or other

inline

mechanism are not a problem, but I don't see how to do it.

Hi all, I want to define a kotlin function as a parameter for a class and I want that kotlin function to be able to have 0 or more arguments. Is there a way to do that? Ex:

class Builder (
private val function: (suspend () -> String) //Don't want to force Builder to have to provide a no argument function
)

Context: I used to be able to do this in RxJava with a Single. Moving to Coroutines / Flow.

Lets-Plot, in Kotlin You can understand a lot about data from metrics, checks, and basic statistics. However, as humans, we grasp trends and patterns way quicker when we see them with our own eyes. If there was ever a moment you wished you could easily and quickly visualize your data, and you were not sure how to do […]

What is the current opinion on error/exception throwing in Kotlin? For me I try to avoid it as best as I can because there are no checked exceptions and therefore no IDE or compile time safety whatsoever. I wrap any source of exception (like a library call that might throw an error) into a Result object to avoid having unexpected errors thrown in my face. This is especially interesting for libraries. How do I know that a certain call might throw an error? It is therefore curious to me why there is so much support for catching errors, while it is impossible to know which piece of code might actually throw an error, without prior knowledge of the code itself. For example, Flows support error catching, but there is no way to know which operation might throw an error. So what is the "best" option? Should I wrap any error in a result object directly from the source (by wrapping library calls in try/catch)? Or should I throw unchecked errors and hope for the best that someone/some code down the line will catch them? Is there any pattern in this that is advised?

Contentious question... What should I be using for testing & why?

I dont' actually think it's any code of mine in particular... the compiler is just producing a java.io.EOFException no matter what no

Every time I build I get a bunch of these types of warnings:

Parameter 'w' is never used, could be renamed to _

Is there a way to auto fix all of these kotlin warnings? I know in android-lint you can select a group of issues and hit the fix button all in one shot.

This message was deleted.

I have a two ranges that represents a timeline of some media (whole media is 0..30000, but I have a ranges like 0..15000 and 15001..30000). I also have a list of ranges how long user listened to some part of the media. Is there any function in stdlib that lets me easily calculate how long user spent in which range? Media ranges (0..30_000): 0..15_000 and 15_001..30_000 Listened ranges: (0..10_000), (5_000..15_000), (20_000..25_000) Result would be: For (0..15_000) range = 20_000 For (15_001..30_000) range = 5_000

Hello - I am upgrading a project from Kotlin 1.3.72 to 1.4.21. As part of this, I had some code of the form

val x = foo() ?: return moo

, where

foo(): T?

is a method returning a nullable generic

T?

. Now previously,

x

was of type

T

, however now the IDE is telling me that it is of type

T!!

. I can seemingly force it to be of type

T

, however can somebody explain what is going on here? I also can't find the relevant part of documentation that explains what

!!

means when postfixing a (possibly only generic?) type. Thanks!

Is there a concise way to check the next statement, sort of:

return when {
    cond1 -> try { something() } catch (e: Exception) { TODO() /* Goto cond2 */ }
    cond2 -> TODO()
    else -> throw RuntimeException("Whatever reason")
}

What is a nice Kotlin way of copying data from a ByteArrayOutputStream in chunks to an OutputStream? the non-chunked way seems to be

outputStream.use { out -> baos.writeTo(out) }

also I realize it can probably be done via reflection, but want to avoid that

Is it possible to get something like

code .

In shell which opens VSCode in the current directory but for intellij? Like

intellij .

That launches intellij for the current dir - create or open if not exists the project

is there a collection method that returns all elements of a list before the last time a predicate is true? something like

[1,2,3,4,5,4,6].takeUntilLast { it == 4}

results in

[1,2,3,4,5,4]

What's the nicest + efficient way to do a map of some collections into sets, and flatten into a union of those sets? Right now I'm thinking:

val finalSet = whateverlist.fold(mutableSetOf()) { acc, element ->
    val individualSet = someCode(element)
    acc.apply { addAll(individualSet) }
}

I'd expect this to be a little faster than some of the other approaches (e.g. reduce with regular Set and

union

)

I'm making a library that can make use of annotations, where it should get user-defined functions and classes annotated. I know how to define annotations and their target, but I'm lost when it comes to processing them. There seems to be kapt, Dagger and some others, but which one should I be using?