kotlinlang #announcements

kotlin
import io.github.commandertvis.command.command
import org.bukkit.command.CommandSender

data class MyArgs(val int: Int)

command<MyArgs, CommandSender>("plugin", "command", MyArgs::class) {

}

Iaroslav Postovalov

02/26/2019, 3:49 PM

That looks weird in this context

Marc Knaup

02/26/2019, 3:50 PM

Why?

Iaroslav Postovalov

02/26/2019, 3:52 PM

subjectively

Nikky

02/27/2019, 9:33 AM

as asked this in #reflect already, but is there any way to remove a internal modifier fro ma library at runtime? a reflection call using a instance of something that is internal errors somewhere in native code, probably because of the

internal

modifier

hho

02/27/2019, 9:38 AM

I don't think so. AFAIK

internal

is actually compiled to

public

, but with mangled names.

hho

02/27/2019, 9:39 AM

[at least on the JVM … I don't know about native]

aerialist

02/27/2019, 2:01 PM

Hi All, Is there any public roadmap for Kotlin?

hho

02/27/2019, 2:16 PM

I don't think so. The closest is probably the chapter "Future" of @abreslavs Talk at KotlinConf 2018:

https://youtu.be/PsaFVLr8t4E?t=2025▾

elect

02/27/2019, 2:20 PM

talking about Compiler API, any news about it recently?

Marc Knaup

02/27/2019, 2:28 PM

#compiler

👍 1

Andrey Tarasevich

02/28/2019, 9:11 AM

HI everyone I'm seeing some Kotlin compiler behaviour, which seems to me a bit strange or at least looks like a compiler is too smart with type inference. Here are two functions and some class that holds

Map<,>

. First function compiles, although there was no explicit cast of

immutable

MutableMap

. Second function throws compiler error. Is this a desired behaviour?

Copy code

class Foo(val map : Map<Int, String>)
fun test1() {
    val foo = Foo(mutableMapOf(1 to "1"))
    val mutable = foo.map as MutableMap // cast is first
    val immutable =  foo.map

    mutable[0] = "1"
    immutable[0] = "1" // no error, looks like compiler infers "immutable=foo.map" as MutableMap
}

fun test2() {
    val foo = Foo(mutableMapOf(1 to "1"))
    val immutable =  foo.map
    val mutable = foo.map as MutableMap // cast is second

    mutable[0] = "12"
    immutable[0] = "12" // compiler error
}

karelpeeters

02/28/2019, 9:14 AM

In the first one,

foo.map

is smartcast to

MutableMap

, and then

val immutable = foo.map

is mutable too of course. In the second one

foo.map

is smartcast too, but the compiler doesn't go back and check all previous expressions and change their types.

sitepodmatt

02/28/2019, 9:21 AM

ah these is smart casting was reading it wrong

🙂 1

Andrey Tarasevich

02/28/2019, 9:22 AM

Thanks! I was just a bit confused with compiler been a bit too smart)

serebit

02/28/2019, 7:13 PM

Ah good, bugfixes 😄 Always good to see

Michael Al-Iskalachi

02/28/2019, 11:34 PM

Hi all, new to the channel! where can I post Kotlin job opportunities? thanks 🙂

jacob

02/28/2019, 11:37 PM

#hiring but make sure to check the room description first for the job ad requirements

Michael Al-Iskalachi

02/28/2019, 11:59 PM

Thank you @jacob

amadeu01

03/01/2019, 12:55 PM

I tried to put on programs arguments

amadeu01

03/01/2019, 12:55 PM

image.png

elect

03/01/2019, 1:05 PM

Copy code

inline infix fun <reified C>VkDevice.allocateCommandBuffers(allocateInfo: VkCommandBufferAllocateInfo): C = 
            when(C::class) {
                Array<VkCommandBuffer>::class -> Array(count) { .. } as C
                ArrayList<VkCommandBuffer>::class -> ArrayList<VkCommandBuffer>(count)  as C // error

On the second line the compiler complains:

Only classes are allowed on the left hand side of a class literal

elect

03/01/2019, 1:13 PM

ArrayList<VkCommandBuffer>::javaclass

doesnt complain, but it doesnt work though