Awesome, thanks for the info!

In scala you can import object members, is there something like that in Kotlin?

does

import myObject.*

work?

no, if

myObject

is not a package or enum

@orangy: thank you

Because rules are not clear at all. E.g. what to do with

equals

that is there?

Scala seems to import

equals

.

You get a conflict error when you try to use it

You must fully qualify, or noop the import

You’re right (I should only trust scalac, not editor highlighter :))

A message I received from a workmate this morning on how awesome Kotlin is, would love to help in any way possible.

"we need to figure out a way to super uber promote kotlin in the Java community; I don’t know what that means exactly but I haven’t like a language this much ever, period, hands down
and the more I work with it the more I like it
there are only a few oddities around inline and crossinline that I find hard to grok but otherwise, it’s near perfect"

He’s also one of the best engineers I know, so that means a lot coming form him 🙂

Another newbie question 🙄 Data classes don’t seem to like Arrays (because of default equals method), plus Arrays cannot be created with type parameter value

fun <T> newArray(t: T): Array<T> = Array(1, {t})

.

Is there alternative? I’m tempted to use MutableList but something like an array would make more sense (e.g. it can’t change size).

@Dmitry Kandalov: not sure what you are asking. Use a custom

equals

in your data class if you want a deep comparison for structures.

also this works

inline fun <reified T> newArray1(t: T): Array<T> = Array(1, {t})

@voddan: thank you, I didn’t know about

reified

. Yes, custom

equals

will work but it feels like writing java.

kotlin is supposed to feel like java

IMO it is a good thing

i think a List there would be fine

List is immutable so it can’t change size either.

I'm pretty sure that the

List

interface in Kotlin is actually just a wrapper around

ArrayList

that doesn't give you access to the mutation methods

But I also assume that they pass in an initial capacity to the

ArrayList

when constructing it, which definitely makes it efficient enough that almost nobody will have to worry about explicitly using an Array

I have warnings that are located in 4 files, and every build of the project after a minor change in 5th file (like a change

<=

to

>

in the body of non-inline method) I see all these warnings on "compileDevDebugKotlin" step of the gradle. Is that mean that the incremental compilation doesn't work for me?

and maybe there is an option to see all files that are compiling, and files that skipped due to the incremental compilation

Kotlin feels like Java should feel if it had actually evolved instead of becoming mired down like it has been. 🙂

'Alternate History Java'

Yeah, the fact that it also feels a lot like C# is no coincidence. I've always considered C# "what Java could be if we didn't care about backwards-compatibility back to the Ice Age", and now I consider Kotlin to be that

It's been a while since I used C#, but I remember I liked the language, but couldn't stand the standard library

If only we could have Kotlin without type-erasure...