Is there a particular reason why

lazy

and

{

have to be on the same line?

message has been deleted

I don't see a lot of features I want on this list, surprisingly. Tells volumes about how well designed the language currently is. The trailing commas and SAM conversions would probably be my first picks

array literals are definitely my #1 choice. unsigned and value types (for a efficient complex type) would be useful

the real immutability support would be great. i really like that in swift

So what you basically want is to spread the arg before you call the func?

@bmsantos thanks, but what I meant is of that class exactly like from the question:

qux.getClass().equals(Foo.class)

, was just wondering if there was a simpler way in Kotlin - i guess something like

qux.javaClass === Foo::javaClass

is the shortest it can be - but I'm confused if it should be

===

or

==

. I guess from the java code, it should be

==

(update: nope, that doesn't work - see reply thread)

Huh. Are typealiases not usable from Java?

Hmm. I have a class, e. g.

class Something<X : Serializable>

. In Java, within a class with unbound

T

type parameter,

public void do(Something<T> something)

is an error (since only

Something<T & Serializable>

can exist in this context), but

Something<? extends T>

is OK. In Kotlin, both

Something<T>

and

Something<out T>

are errors. Is it by Kotlin design? Or a Java bug? 🙃

hello! IDE keeps telling me this:

Outdated Kotlin Runtime
			Your version of Kotlin runtime in 'kotlin-runtime-1.0.2' library is 1.0.2, while plugin version is 1.1.1-release-Studio2.3-1.

I checked all my gradle dependencies - no

1.0.2

there,

1.1.1

in all places. My project is also using features of

1.1.1

and compiles fine. How do I track down what causes this warning?

what you want is a data class, but, minus the copy() method (or perhaps more helpfully with copy made also private)

Will be any movement to standarize the language (ISO) or making a committee with other partners (Google, Oracle, Red Hat, etc.)? As I see it, Kotlin language is the best option for general purpose programming over the JVM (well, not only the JVM) And I don't miss features in the language itself. Instead, If it is supported by more companies, the developers/companies adoption will be faster, what do you think?

any handy shortcut for identity function? so far i’ve been using

{ it -> it }

@lupajz this is what i ment

class MutableLazy<T>(val supplier : ()-> T) {

   private val mutableOption = MutableOption.empty<T>()

   fun getValue() = mutableOption.ifNotPresentCompute(supplier).get()

   fun setValue(value : T) = mutableOption.take(value)

   fun isInitialized() =  mutableOption.isPresent
}

inline operator fun <T> MutableLazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = getValue()

inline operator fun <T> MutableLazy<T>.setValue(thisRef: Any?, property: KProperty<*>, t: T) {
   setValue(t)
}

var something : String by MutableLazy {
   log("computing this value")
   "default value"
}

fun main(args: Array<String>) {

   something = "manually set value" // comment/uncomment this line...
   println(something)
}

Consider mutable option just like normal option except not immutable... I can simply replace it with any synchronized wrapper of single generic value...

using mockito-kotlin (https://github.com/nhaarman/mockito-kotlin) how can I mock the method:

public <T> ResponseEntity<T> exchange(RequestEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)

i know in Android is not possible, but i guess should work for JUnit

Hi, does anyone know why kotlin's

lazy

implementations all extend

Serializable

?

Works fine if you do this: val parcelList = ParcelableUtils.createBooleanArrayList(parcel) as ArrayList<Boolean?> to force it, but the IDE thinks that the stuff on the right is a useless cast.

So this is a doc error maybe? https://github.com/kotlin/kotlinx.html/wiki/Streaming

How is kotlins parser implemented

@vach

fun <T> mutableLazy(initializer: () -> T): ReadWriteProperty<Any?, T> = MutableLazy<T>(initializer)

private class MutableLazy<T>(val initializer : ()-> T): ReadWriteProperty<Any?, T> {

   private var value: T? = null
   private var initialized = false

   override fun getValue(thisRef: Any?, property: KProperty<*>): T {
       if(!initialized) {
           value = initializer()
       }
       return value as T
   }

   override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
       this.value = value
       initialized = true
   }
}

wow xtend is not trivial to google for. you just get penis enlargement results

I believe "returns the same result over invocations" can be interpreted as "returns the same result if the externally visible state of object isn't changed"

general Gradle tip, if you just add your dependency with the version

+

(so

org.jetbrains.kotlin:kotlin-gradle-plugin:+

), it'll get the latest version for you, and then Android Studio/IntelliJ will give you a warning + hotfix to change it to hardcode in the latest version. There are lots of articles detailing why actually using

+

is not recommended, but using it to quickly sync + replace it with the actual latest version is good IMO

Hi, is there a commercial support for Kotlin?

By the way, which is better — Java way with None and Some declared as one class (Optional), or Scala way with sealed class (actually, three classes instead of one)? I have single-class Either implementation, bit it has extra flag which says whether it is left or right.

It can't know you want that and not

B<Bar>

or

B<String>