Wonder why Kotlin is taking off while Clojure didn't so much... I personally really like Kotlin features, and don't find it bloated. BTW, I really like inline methods, and noinline can be useful for all the real world tricky use cases

Don't think adding so much information in the error is needed since the stacktrace shows you the code where it crashed, which helps knowing why

Why doesn't the Android framework use enums instead? Those could be checked exhaustively.. Or wrapped in sealed classes or....

I doubt you could measure a performance difference even if you tried. The amount of code is obviously a matter of opinion.. but really.. how many enum types are there in Android that you actually use? 10 ? 100 ?

Don't use ints!

What about

auto intefaces

? So you can write class. declare that it implements auto interface, and kotlin will generate interface using public members.

All discussion in this channel should begin with a use-case or proposal instead of a question.

😉

To get rid of the

.toByte()

you can just call

.map()

To get rid of the many

0xFF

then I guess you can specify it in Longs

0xFF_FF_FF_FF_FF_FF_FF

and convert to bytes. Im not sure additional syntex is needed.. seems a util package for bits and bytes could take care of most of it

“ffff000000000000”.hexStringToByteArray()

Not yet. That's just an idea how that could possibly be designed / implemented in Kotlin. Rather shallow one so far.

I don’t see much improvement that sigils make w.r.t top-level functions. They definitely make tooling trickier. Writing

Regex("haba")

instead of

~r/haba/

is only slightly more verbose, but way more readable. The only potential issue that one can see here is performance, e.g. that the function is being invoked at run-time, but there’s a much less intrusive way to solve that: https://youtrack.jetbrains.com/issue/KT-14652

@rrader

constexpr

functions are not macros. The key insight here is that you don’t really need macros most of the time. Macros is like hammer. You can do a lot of things with it, but most of the problems you encounter (inlining debug functions and generating compile-time constants are two good examples here) can (and should be) solved with more targeted features, because those narrower features get a nice tooling automatically without you having to write IDE plugin every time.

of course we can do a lot without any macros, but also we can do a lot without inline functions 😉

Is there an existing proposal for an exhaustive when in a non return block?

kotlin makes important things explicit

what about recursively destructuration?

fun a() = Pair(0 to 1, 2 to 3)

    fun b() {
        val ((a, b), (c, d)) = a()
    }

Also applies here @johnl

At the expense of sounding completely ignorant, why is not implicitly initializing the nullable properties a good thing?

Kotlin’s design principle of making important things explicit

than please make that all function have throws in function declaration like in Java

I dont recall if I already asked this, but why `inner class`es cannot have `companion object`s?

I propose adding underscore support for unused method parameters. Use-case is the same as for lambdas, e. g.

object SomeDeserializer : com.google.gson.JsonDeserializer<Something> {
    override fun deserialize(json: JsonElement, _: Type?, _: JsonDeserializationContext?): Something {
        return Something(json.get("whatever").asString)
    }
}

Something like

if ((val localVal = nullableExpr) != null && localVal.property = "x") {  do something with localVal }

?

This message was deleted.

so, I'm starting to use sealed classes a lot, they're really handy, but it has come up twice now that I would like to access a sealed classes instances via reflection, but no such API exists. Any chance I could get some method support for retrieving the subclasses of a sealed type via reflection?

what is the future of annotation processing in kotlin? will it be still as slow and use Java as an intermediate generation language? Will it be possible to generate kotlin directly somehow? Or will there be other machineries to allow some kind of metaprogramming? Maybe there are already some proposals related to this?

i filed a suggestion for Smart Cast, anybody got thoughts or feedback? https://youtrack.jetbrains.com/issue/KT-18023

@edenman What kind of vars are those? Why are they nullable? Have you tried using

lateinit

? Can you share some code?

Escaping and string interpolation are two different things. Personally, I use interpolation in raw strings all the time (for example, when building complex regex patterns).

hah, heres a super awesome piece of code almost certainly created by a merge conflict:

catch (exception: AssertionError) {
            <http://eventBus.post|eventBus.post>(ControlFlowInterruptedEvent())
            return optimizationModel?.id ?: NullUUID
        }
        catch (exception: AssertionError) {
            <http://eventBus.post|eventBus.post>(ControlFlowInterruptedEvent())
            return optimizationModel!!.id
        }

Can ask the compiler to make this illegal? Would it ever be useful to catch the same type like this?

Did you guys think about “copy-constructors” for data classes? 😉