Methods with a single argument are always good candidates for extension methods

problem resolved without answering the question simple smile

Yes, if you aren’t used to extensions - it’s not your first instinct

But once you get used to them...

Coming from ObjC - it is a common ‘instinct’

I wonder if you could make an IDEA inspection that's not too intrusive

Oh, I saw just C/C+= 😄

i raised an issue a while back because - being, statically dispatched, they didn’t quite behave as I expected.

thank you dmitry.petrov

Another question related, when using

when { “Hello”.isNotEmpty() -> ... }

how does "when" react ? like a “if” ?

Yes, exactly.

👍

@romaric: as kotlin is open-source you can deeply check how

when

is translated: https://github.com/JetBrains/kotlin/blob/8497931455797c945a3244943e79018e00642191/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/WhenTranslator.java#L70

...except that's a JS back-end simple smile

yes it’s not fairly the same

corresponding piece of JVM back-end: https://github.com/JetBrains/kotlin/tree/master/compiler/backend/src/org/jetbrains/kotlin/codegen/when

Hey, I'm interested in how we get the KProperty Type. It's not really clear in the docs.

what do you mean?

So I'm writing delegated operators for Android's

SharedPref

,

setValue

,

getValue

etc.

The property could be of many type (String,Int,Long, etc). Just wondering inside of the

setValue

what is the way to determine the type of the underlying type of KProperty?

Struggling to explain what I mean, I'll do a code snippit.

it’s not possible

at least without depending on

kotlin-reflect

So for example, you would need reflect for this to work:

operator fun <V : Any?> SharedPreferences.setValue(thisRef: Any?, property: KProperty<*>, value: V?) {
    val name = getPrefName(thisRef, property)
    edit()
            .apply {
                when (property.returnType) {
                    String::class -> putString(name, value as String)
                    Int::class -> putInt(name, value as Int)
                    Float::class -> putFloat(name, value as Float)
                    Long::class -> putLong(name, value as Long)
                }
            }
            .apply()
}

Is that right? Is there a better way to do this?

does that compile ? 🤔

yes.

Just thought there might be a "smarter" way to do it?

Maybe just use operator overloading with static dispatch if you know the type at compile time?

@dalexander: you mean:

operator fun SharedPreferences.setValue(thisRef: Any?, property: KProperty<*>, value: String?) {
    val name = getPrefName(thisRef, property)
    edit().putString(name, value).apply()
}

operator fun SharedPreferences.setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
    val name = getPrefName(thisRef, property)
    edit().putInt(name, value).apply()
}