Hello, any Dokka experts here? I'm dealing with a huge monorepo that uses the Buck build system, and I'm trying to generate KDoc for just a tiny sliver of that codebase. I created a

build.gradle.kts

specifically for Dokka with a

sourceSet

containing just the subdirectory I'm interested in, and it generates documentation, but the problem is that any dependency outside of my

sourceSet

is shown as

<ERROR CLASS>

. Obviously, Dokka can't generate docs for these classes since it can't resolve them, but is there there any way to get these class names to appear as text rather than an error? Ideally, I'd be able to link these unresolved classes to a URL containing their source code, but even just getting the raw text name would be a huge improvement.

Will overriding of

equals()

for inline classes be available in the future?

I’m just learning about gradle “platforms” and was wondering if anyone aware of a community maintained gradle platform or similar that basically has every dependency you could ever want? Coming from the Haskell world we have https://www.stackage.org/ which basically gets rid of a huge amount of dependency hell.

Is there an annotation like

@Deprecated

but meaning specifically that a method call is pointless, because it returns

this

and has the same return type as the object it is called on? For instance,

String.toString() = this

would be a candidate for it.

message has been deleted

I know 1.5 isn't officially released yet, but I can get the artifact so I started migrating my project to it. However, anything added in 1.5 results in a unresolved reference. Is that expected until the full rollout of the release?

uuuh... can someone explain to me why

(19.999996 * 100.0).roundToInt().toDouble() / 100.0

is sometimes 20.0 and sometimes 0.0? this is really unexpected ^^

Hi there, is it possible to do this in Kotlin somehow? (it is just an example) I get error at call-site:

Unresolved reference: of

sealed class Sealed {
    
    // Is it possible to define a factory method or smart constructor here?
    fun of(n: Int): Sealed = if (n > 0) Foo("test") else Bar(42)
    
    data class Foo(val str: String) : Sealed()
    data class Bar(val num: Number) : Sealed()
}

and why is the above not possible? thank you!

General question for everyone: Is there a specific codebase that you love to go through to learn new things? For example from time to time I just go through the http4k-connect to see and learn how to integrate other systems in a kotlin idiomatic way. I'd love to learn about your recommendations!

Is there a good way to test a string against a series of regex without matching twice? Right now I have

for (line in lines) {
   if (Regex("#(.) A (.+)").matches(line)) {
       val m = Regex("#(.) A (.+)").matchEntire(line)
        ...
   } else if (Regex("#(.) B (.+)").matches(line)) {
       val m = Regex("#(.) B (.+)").matchEntire(line)
       ...
   }
}

(real code of course has regexes defined only once etc.). I now changed it to

for (line in lines) {
   val m1 = Regex("#(.) A (.+)").matchEntire(line)
   if (m1 != null) {
      ...
      continue
   }
   val m2 = Regex("#(.) B (.+)").matchEntire(line)
   if (m2 != null) {
      ...
      continue
   }
}

but that does not look too nice (esp. the need for repeated

continue

)

Given that

lateinit

can't go on primary constructor parameters, is there a less manual way of doing something like this (lateinited class fields that can be set through the constructor)?:

class Foo(x: String? = null) {
    lateinit var x: String
    
    init {
        if (x != null) this.x = x
    }
    
    fun show() = println("Foo: $x")
}

Hello Kotliners. Is there a way to give an actual name to callback functions so that I don’t have to implement a bunch of

invoke()

methods? For example:

class Whatever(val callbackNumber1: (SomeParameter) -> Unit, val callbackNumber2: () -> Unit)

So now when call that instance in another object, I would have something like this:

class AnotherObject : (SomeParameter) -> Unit , () -> Unit {
   private val whatever = Whatever(this, this)

   override fun invoke(){

   }

   override fun invoke(someParameter: SomeParameter){
    
   }
}

Or should I just stick to plain interfaces in this case?

I’m wondering why the if statement doesn’t expect a nullable Boolean type. What would be the disadvantage of allowing it? Consider this:

if (foo?.isNotEmpty() ?: false) { … }

That works, but it’s not really concise. Wouldn’t it be better (and safe) if we could just write

if (foo?.isNotEmpty()) { … }

Hey people, where can I discuss testing with Kotlin?

Hello guys, I am currently trying to connect our Kotlin Multiplatform Project to websockets. I would like to use ktor-websockets library to receive some updates from our backend but onfortunately when I run this code, nothing happens:

client.webSocket(
    port = 80,
    method = HttpMethod.Get,
    host = "<https://uat-betws.sts.pl>",
    path = "/ticket?token=eyJzdWIiOiI0ZmY5Y2E1Mi02ZmEwLTRiYWYtODlhYS0wODM1NGE2MTU0YjYiLCJpYXQiOjE2MTk4MDAwNzgsImV4cCI6MTYxOTgwMzY3OH0.oIaXH-nFDpMklp4FSJWMtsM7ECSIfuNF99tTQxiEALM"
)
{
    for (message in incoming) {
        message as? Frame.Text ?: continue
        val receivedText = message.readText()
        println(receivedText)
    }
    // Consume all incoming websockets on this url
    this.incoming.consumeAsFlow().collect {
        logger.d("Received ticket status websocket of type ${it.frameType.name}")
        if (it is Frame.Text) {
            Json.decodeFromString<TicketStatusResponse>(it.readText())
        }
    }
}

Does somebody have any experience with ktor-websockets library? There is almost no documentation so maybe I am doing something wrong. Thank you

This message was deleted.

Also general kotlin question from a relative newbie: several months in, I still feel like I don’t fully grok kotlin’s position on the function of exceptions. There is this blog post: https://elizarov.medium.com/kotlin-and-exceptions-8062f589d07 that seems to be basically saying that you should only use exceptions where you’d use assert() (ie, to signal logic errors), and most of the time you shouldn’t be catching exceptions --- ie, try/catch blocks are a code smell. There are some obvious … exceptions to that rule (such as, catching exceptions thrown by java code), but --- fair enough, error states should be signaled through special return values, either null or a special instance of a sealed class. … but then I go out into the world, and I don’t see that pattern being followed. For instance, ktor (which a number of blog posts have nudged me towards as a good sane default http client for kotlin) by default uses exceptions to signal http error codes. IE --- rather than exceptions indicating a bug, ktor throws exceptions to indicate that a potentially expected error has occurred. I’m fine with this pattern, too! But it makes it hard to see what I should adopt in my own code.

class Thing(parameter: Int) : List<Int> by property { //unresolved reference: property
	val property = listOf(parameter)
}

why isn't this allowed?

Is there anything particular that drives up the kotlin compiler memory usage that one should look out for? I am generating code using Kotlinpoet and I am struggling with very high memory usage during compilation (I had the similar problem in an earlier project with 1.3.x, but back then it was enough to just give it more memory -- now that doesn't solve it due to a higher number of classes). The code generated is not deep (so no big nested if-s or anything, but 3 methods, a number of static variabled defined in the companion object. I guess the most risky might be a data class that has about 20000 different uses. It is currently just over 600 such classes, and they are in the same package -- would splitting up the packages help?

i know this is the wrong slack for this, but whatever happened to java modules? i feel like nobody uses them or cares about them.

Hi everyone! Don't know if this is the right place to ask, but do any of you have any experience with writing iOS app in Kotlin, particularly with Jetpack Compose?

why does

const

need to be specified explicitly? can't the compiler check automatically if the keyword is applicable ? or is there a scenario where you wouldn't want its optimizations ?

Where is the appropriate place to report code completion (AS) issues?

fun (String.() -> Unit).test() {
    "anything to demonstrate the point".apply {
        // no code completion for "this" -> "this@test"
        "something".this()
    }
}

is there a way to make a

Map

that's guaranteed to be exhaustive, so the return type of

get()

isn't nullable? (similar to how

when

can skip

else

when it's exhaustive)

Why does this work:

data class TestContainer(
	val body: Any?
)

operator fun TestContainer?.compareTo(b: TestContainer?): Int = this?.body.let { aBody ->
    b?.body.let { bBody ->
        when {
            aBody is Boolean && bBody is Boolean -> {
                val aBoolean: Boolean = aBody
                val bBoolean: Boolean = bBody
                return aBoolean.compareTo(bBoolean)
            }
            else -> -1
        }
    }
}

fun main() {
	println("Comparison: ${TestContainer(true) < TestContainer(false)}")
}

But the following yields ClassCastException at runtime on JVM?

data class TestContainer(
	val body: Any?
)

operator fun TestContainer?.compareTo(b: TestContainer?): Int = this?.body.let { aBody ->
    b?.body.let { bBody ->
        when {
            aBody is Boolean && bBody is Boolean -> aBody.compareTo(bBody)
            else -> -1
        }
    }
}

fun main() {
	println("Comparison: ${TestContainer(true) < TestContainer(false)}")
}

Error is

Exception in thread "main" java.lang.ClassCastException: java.lang.Boolean cannot be cast to java.lang.Number

I'd expect the two to be equivalent due to smart cast?

Has anyone had this problem? I can't find the

MainClass

in the jar I generated with

Gradle

package

ummm…. is this a bug?

Is 1.5.0 still not officially released? Stuck on IDEA plugin updates?

What is the simplest/best

Regex

that will never find/match any input string? Seems that each regex engine out there has a different best practice for making an ‘impossible’ regex.