In particular

The general rule is: when a type parameter T of a class C is declared out, it may occur only in out-position in the members of C

Kotlin thinks that value is a single KClass, instead of an array of KClass. Is it a known issue, or should i report it?

How does it "think" that?

I.e. can you give an example of the wrong behavior?

If I try to do @Import([String::class, Int::class]) it expects a KClass<*>, not an Array<KClass<out Any>> and it fails compilation

But java allows me to do @Import({String.class, Integer.class}) with no issues

seems to work if you do

@Import(value = [String::class, Integer::class])

Yep

@Mario Ruiz In Kotlin, you don't need the

[]

in this case, so you can just do

@Import(String::class, Int::class)

https://kotlinlang.org/docs/reference/annotations.html#arrays-as-annotation-parameters

If the

value

argument in Java has an array type, it becomes a

vararg

parameter in Kotlin

and returning 0 is awkward since that could be a valid result of rounding - you wouldn’t necessarily know something out of the ordinary happened unless you did some digging

Fair enough. The inconsistency just surprised me. My (really old) Java code was working fine but started crashing when converted to Kotlin in this case.

I feel you. I’d figure there are probably other examples of JB breaking with Java API expectations in the name of saner reasoning

That's reasonable assumption

Let's say I want to pass 2 callback functions to something. Is it better to have 2 lambda arguments or create an interface with the two functions and pass one argument with that interface?

One argument looks better, but an anonymous interface implementation at the caller site looks ugly (

object : Interface {...

)

Depends really. If you feel that type will be useful elsewhere or if it makes sense from a semantic point to group these lambdas into it, do it. If it's just for this particular function, passing individual lambdas is fine

Related reading: http://beust.com/weblog/2016/06/20/ad-hoc-polymorphism-in-kotlin/

how to delegate

socket

methods to

TorSrocket

?

class TorSocket @JvmOverloads constructor(val desination: String,
                                          port: Int,
                                          streamId: String? = null,
                                          numTries: Int = 5,
                                          tor: Tor? = null) : Socket() {
    
    private val socket = setup(desination, port, numTries, streamId, tor)

anyone here also a Swift developer? I would really like your feedback https://kotlinlang.slack.com/archives/C8B5U78DP/p1519438294000079

Hey guys, is POJO class in java similar to data class in Kotlin ?

@Chay https://kotlinlang.slack.com/archives/C0B8MA7FA/p1519454912000081

The compiler seems to be built on the intellij plugin platform and I wanted to use that as a reference for structuring my own compiler (for a different language).

There's a class with

RecursiveDescent

in the name, that's the parser. Maybe start from there and look at what it emits, and what other passes use those data structures?

Has anybody else gotten compiler errors with code like

prevMessage?.text += line

where prevMessage may be null and text as well as line are of type

String

?

IntelliJ doesn't show any error

interestingly

prevMessage?.apply { text += line }

works

hey guys im thinking about a new extension that can be useful to check nullability on two variables, do you think that it can be useful?

@Czar commented on @Daniel Loaiza’s file https://kotlinlang.slack.com/files/U9E6Q296F/F9DNUKY2V/pair_extension.kt: Maybe in a DSL which works with `Pair`s a lot, but I'd avoid it generally, problem here is that you create an unnecessary throw-away

Pair

object just to call the function.

@Czar commented on @Daniel Loaiza’s file https://kotlinlang.slack.com/files/U9E6Q296F/F9DNUKY2V/pair_extension.kt: I'd use something like this:

fun <T, U, R> ifNotNull(first: T?, second: U?, block: (T, U) -> R): R? =
	if (first != null && second != null) block(first, second) else null

println(ifNotNull("a", "b") { first, second -> first + second })