Why does Kotlin allow the following?

try {
        foo()
    } catch (e: Exception) {
        //...
    } catch (e: RuntimeException) {
        //...
    }

The Java compiler rejects it because it knows that RuntimeException will never be caught as it appears after Exception. The Kotlin equivalent doesn't even trigger a warning in the IDE. Does the Kotlin plugin for IntelliJ IDEA have at least an option to turn on a warning for this?

I'm experimenting with writing a tree matching DSL in Kotlin. Anybody know if there's something similar out there already?

Why are reified types forbidden for catch parameters?

There was a page on Kotlin docs site that listed recommended version of libraries (like coroutines, ktor, etc.) for every kotlin version but I cannot find it now?

JetBrains' Kotlin learning materials & Effective Java & Atomic Kotlin 🧵

Hey guys, we are migrating from Ktor 1.6.x to 2.x.x and we found that in the previous version of the lib any unsuccessful http response (e.g. 404 error) would throw a

ClientRequestException

. However in 2.x, it seems that unsuccessful http responses are not throwing exceptions anymore. This is forcing us to check which status code we get on the response and throw our own custom NetworkError. I am wondering if there is anyone here that can have information on why is this done like that, we are thinking that may have something to do with the newly added retry functionality.

👋 Hello, team!

I was reading the article "EventListener is Like Logging, But Good", and I was particularly interested in the section that reads: “Create an abstract class

EventListener

. I prefer an abstract class over an interface here ’cause I want to introduce new functions in library upgrades without breaking compatibility.” I always thought even if you’ve got an interface, you can introduce new functions with default implementations which would let consumers not need to do anything in implementation of that interface. Am I missing something here?

is there an

import as

in kotlin? I need to use two classes that are called the same but different packages and I dont want my entire package name behind each usage of one or the other to differentiate

How to combine for example flows?

private fun <T1, T2, T3, T4, T5, T6, T7, R> combine(
    flow: Flow<T1>,
    flow2: Flow<T2>,
    flow3: Flow<T3>,
    flow4: Flow<T4>,
    flow5: Flow<T5>,
    flow6: Flow<T6>,
    flow7: Flow<T7>,
    transform: suspend (T1, T2, T3, T4, T5, T6, T7) -> R
): Flow<R> = combine(
    combine(flow, flow2, flow3, ::Triple),
    combine(flow4, flow5, flow6, ::Triple),
    combine(flow7)
) { t1, t2, t3 ->
    transform(
        t1.first,
        t1.second,
        t1.third,
        t2.first,
        t2.second,
        t2.third,
        t3.first,
    )
}

I want to create a type of history thing in my project, where the users actions are added to a list or some other array, and then the user can go back or forward. It should behave like how you can go back and forth in a file browser. I'm unsure how to represent this in code though. Any ideas?

object A {
    fun Server.wire() { TODO() }
}

object B {
    fun Server.wire() { TODO() }
}

how do I call wire from both object A and B considering they're both extension functions?

Server().apply {
    wire() // wire A
    wire() // wire B
}

is it possible to do something like

A::wire()

and

B::wire()

?

I have some basic questions about working with Coroutines and JVM

CompleteableFuture

interop I'm not very familiar with JVM-style asynchrony (mostly used async/await style languages) If I have a Java API which returns `CompleteableFuture`'s, is there a way to get them to run on coroutines instead of physical threads to reduce the overhead, or how do you generally work with these?

(Maybe my thinking/approach here is entirely wrong, too)

Am I right that implementing interfaces by delegation is restricted to constructor fields? I'd quite like to delegate to a method that returns an instance of the interface, as I can in Groovy.

how do I declare a static val in Kotlin?

good day everyone. got a coroutine question. I want to set the property value for each object in the list by calling the suspension function and setting the result:

coroutineScope {
            workflows.forEach {
                it.status = formWorkflowActivationStateManager.getCurrentState(it, companyId).toWorkflowStatus()
            }
        }

I’m wondering if the

coroutineScope

is enough to parallel those executions or if I need to use

async/await

?

Hi All, what would you recommend to learn Kotlin for someone who's been coding in Java with Spring for 5 years. I started the Kotlin Koans, Atomic Kotlin, and Kotlin courses in JetBrains Academy but none of those seems right to me. Is there any other option?

is it idiomatic to avoid the use of

this

when possible?

what's the best practice to implement transactions when dealing with coroutines ? Essentially I am launching some parallel tasks and want to rollback everything in case one fails

Hello. Is there something more elegant than the following to invoke each lambda in a list?

lambdas.forEach { it() }

Hello friends, I had a question about making a mobile application. For the basic structure of the application, which is just an idea and you want to turn it into an application, what steps should I go through? I mean, what questions should I ask myself about the idea and that How should I create a road map according to which I will start building the app so that I don't get interrupted when turning the idea into an app and don't change my decision for a sudden part? I don't mean the programming stage

Hello u work now with java and kotlin and want to know that when i run java app where is the code in memory or instruction set in jvm, My question where is my code in JVM?

Hi all, I am trying to make a

User

model object to be inserted into a database. I want to insert these into various databases using a Repository pattern, but the

User

has an

id

field that is generated differently for each database I use. Is there a way to defer the definition of the

id

type and a

generateId()

function until the actual creation of the

User

object in Kotlin? Thanks

Hi all, I wanted to know what is the meaning of the statement "If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either directly or indirectly through another secondary constructor(s)." in simple English.

why is it that when I have a

when

like this one

when (locationState) {
    !is LocationState.Set -> {}
    is LocationState.Disabled -> onLocationDisabled()
    is LocationState.NotGranted -> onLocationNotGranted()
    else -> Unit
}

all the conditions after the first

!is LocationState.Set

are now unreachable?

IntelliJ resolves the functions just fine, so why is gradle giving this error?

I wonder why

class

only implies

final

but

override

only implies

open

? Should "overridability" be `open`'s at all? I remember this is the only place where

final

is used.

class A // final

interface B {
    fun foo()
}

class C : B {
    override fun foo() // final
}

open class D : B {
    override fun foo() // OPEN
}

if it's final by default then

D.foo

should also just finalize overridability UNLESS you mark it

open

. Having both

open

and

final

is so inconsistent.