Hello, I have the

KotlinCompileDaemon

which sometimes take 300% of the CPU or throws with a

GC overhead limit exceeded

. What kind of infos can I provide / tools I can use to open a useful bug report on kotl.in/issue?

I’m curious, what was the design decision that made

1..4

return you a list, but

4..1

doesn’t return anything. One would expect

4..1

equals

(1..4).reversed()

.

I have about 20 annotations that need to be exactly like that but I want to avoid code duplication

No shortcuts in K. Code does not have to be concise, it has to be readable in the long run for the team maintaining it.

If you are using readonly in this case, then I would probably go with

someSet = someSet.withOrWithout(someFlag, someElement)

.

i mean if you really want to you could use the strategy pattern, which is often used for dealing with repetitive conditionals , https://sourcemaking.com/design_patterns/strategy

better example would be something like BMIComputer, where there are different ways to compute a value.. the ground transport is not really a strategy it’s a type problem…

What is a good channel to ask about potential odd behaviors/bugs derived from using

reified

type args?

This message was deleted.

Should

val b: Byte = 3
when(b) { 1 -> {} }

compile? It currently fails with the message “Incompatible types, Int and Byte” because it treats 1 as an int literal, and there’s no way to specify byte literals. Asking here before I file a ticket (it also fails for Shorts).

Is it just me or code completion on kotlin seems slower? (AS3.0 C3)

Thanks. For some reason I felt like it may be possible for some reason. Which is confusing because at the same time it doesn't make sense. I was hoping to use it for statements like

"foo" = bar()

It's overloading the invoke( () -> { }) operator with a trailing clojure.... Which may be confusing in itself so opinions are welcome

If you're going to be doing that kind of stuff, you may just want to not use an argument:

val name = item.name
when {
    name == "john" -> { ... }
    name.startsWith("Mary") -> { ... }
    name.contains("Fred") -> { ... }
}

If I have

class Bar
class Baz: Bar
class Foo<T: Bar>() {
  fun input(t: T)
  fun returnT(): T
}

Then

class Other(val foo: Foo<Bar>)
class Impl(foo: Foo<Baz>): Other(foo)

Impl generates:

[TYPE_MISMATCH] Type mismatch: inferred type is Foo<Baz> but Foo<Bar> was expected

How can I overcome this issue?

I’ve not used Kotln Delegation before since I don’t fully comprehend what it’s useful for. Is it correct to state that delegation allows you to delegate execution in the same way that a proxy can delegate execution to 1 or more implementations of a class ?

Are there some kind of JVM annotations for this purpose, or is explicit type selection not supported?

is it a known issue?

Hi guys! What do you think about languages with tagged unions aka sum types? Did you managed to use such a language? Kotlin has something that reminds me them: sealed classes, but they look very verbose and I am not sure if they are useful as tagged unions… (I have to check this, my Kotlin experience is too short)

shouldn’t those classes be

open class

for spring annotations to work ?

If I use the Kotlin annotations, it doesn't work...if not, everything is OK...

I’ve tried Spring Boot on one project, managed to quickly build something with it, then came in some requirements which Spring Boot simply couldn’t do in a nice way and I was stuck. Getting SSL-offloading to working on a Spring Boot project simply didn’t seem possible at the time. Eventually ditched Spring Boot and made the switch to VertX

Why does

Array

have an inline constructor; when the compiler says this is disallowed in my own code?

i've thought about bootstrapping a new ASL-licensed one since pircbotx is GPL'd and jibbler has basically vanished so can't be persuaded to relicense pircbot itself.

There is no difference between

check

and

require

in kotlin

Preconditions.kt

😕

Looks like there is no simple solution, you say

!!

is ugly and can make bad, for me the hidden assumptions make my new and shiny Kotlin app throw NPE… (and I was supposed to see NPE ever again). Maybe

T!

types should have yet another dot-like operator, so it would be special and everyone could tell "aha, this is Java, nulls allowed".

Hi, I just published this guide to all the resources I could find for someone learning Kotlin: https://superkotlin.com/resources-learn-kotlin/ It is part of a new website I have launched to help promoting our favorite language. I was hoping you could help me get the voice out

Hey guys, I'm trying out LWJGL and I came accross this piece of code: (https://github.com/Zi0P4tch0/LWJGL-Kotlin-Example/blob/ed8e30bcb0ad5f99a01a4f501461457a0bd9d36f/src/main/kotlin/com/example/Engine.kt#L47). I don't really understand why there's a "kotlin." in front of every type, why is that necessary? It doesn't compile without it, I get the error "Object must be declared abstract or implement abstract base class member public abstract operator fun invoke(p0: Long, p1: Int, p2: Int, p3: Int, p4: Int): Unit defined in org.lwjgl.glfw.GLFWKeyCallback". The definition of the "invoke" method can be found here: (https://github.com/LWJGL/lwjgl3-generated/blob/894ed035ec3037975a344cf719936159a632967b/java/org/lwjgl/glfw/GLFWKeyCallbackI.java#L41)