and that only works since C#7. before that you had to write

TResult value;
return map.TryGet(key, out value) ? value : null

and technically, your approach is not thread-safe 😛

I think this boils down to the fact that map serves two distinct purposes: - either you can gaurentee its keyset through some domain rule - your using it as a missable-cache of a kind, where its keys are not known through any rule IMHO the most sense would be to split these into two separate interfaces, but all of the java legacy effectively forbids that option, so I was hoping to play a few games with the runtime type and aliased types.

although, with kotlins ability to statically dispatch on generic types, I could do something like

data class Coordinate(val key: String, val value: Double)

fun myDomainFunctions(input: List<Coordinate>){
  
  val result = input["x3"]
}

operator fun List<Coordinate>.get(key: String): Double = //...

but then I'd have to carefully consider how the generic v-table

List.get(index: Int)

miight collide with such an extension function

also if I wanted to avoid copying (which I very much do, copies here will thrash the GC), I'd need a custom map implementation for

fun List<Coordinate>.asMap()

I think a named extension function is still the best way

readability is king

Has there been any recent revival or discussion about metaclasses? This idea: https://youtrack.jetbrains.com/issue/KT-3987

@danneu has left the channel

Has there been any more discussion about allowing set-only properties? https://youtrack.jetbrains.com/issue/KT-14663

Hey all, sorry if this has already been brought up but I couldn't find anything about this. I was wondering if that would be a good idea to add a keyword like

empty

(or something else) that could be added to an abstract class or an interface. The idea would be that adding the keyword would implement every method with an empty implementation. That would be particularly helpful when you want to implement only one method of an interface that has a lot of methods. E.g. :

class MyClass : MyInterface by empty MyInterface() {
  override fun onlyOneMethod() {
    //...
  }
}

Of course, it would return

null

for nullable object, 0 for numeric value, false for boolean and "" for String. For non-nullable objects return, an implementation would still be required. This keyword could also be used to create a new class :

empty class MyInterface()

I understand this can be easily achieved by generating an empty implementation of an interface through the IDE but this keyword would make the code less verbose

do you need this for testing? if yes, you can just use a mocking framework like mockito

I understand. sometimes the framework has empty implementaions ready, like

AnimatorListenerAdapter

you could cook something up with

java.lang.reflect.Proxy

, not sure how good the performance will be

I know but not always so as I said, it's still possible to generate empty implementation and use them in delegates but the code would look better if we could just use one keyword (IMHO) ==> but let's move this discussion in the thread 😉

here's a small prototype with

j.l.r.Proxy

interface I {
    fun int(): Int
    fun double(): Double
}

object Foo : I by proxy() {
    override fun double() = 1.0
}

fun main(args: Array<String>) {
    println(<http://Foo.int|Foo.int>())
    println(Foo.double())
}

inline fun <reified T> proxy() = proxy(T::class.java)

@Suppress("UNCHECKED_CAST")
fun <T> proxy(c: Class<T>): T {
    return Proxy.newProxyInstance(c.classLoader, arrayOf(c), { _, method, _ ->
        when (method.returnType) {
            Int::class.javaPrimitiveType, Int::class.javaObjectType -> 0
            Short::class.javaPrimitiveType, Short::class.javaObjectType -> 0.toShort()
            Char::class.javaPrimitiveType, Char::class.javaObjectType -> 0.toChar()
            Long::class.javaPrimitiveType, Long::class.javaObjectType -> 0.toLong()
            Float::class.javaPrimitiveType, Float::class.javaObjectType -> 0f
            Double::class.javaPrimitiveType, Double::class.javaObjectType -> 0.0
            else -> null
        }
    }) as T
}

As you said, it's not good for performances (specially on 🤖 ) and also it's a lot of boilerplate code and it won't take into account Non-Nullable return types

I’m against this feature. Better to implement own “Simple” implementation with dummy values instead language pollution with “empty” keyword and with so inflexible behaviour ( 0 for numeric value, false for boolean and “” for String). It just doesn’t worth it, IDE can generate such dummy implementation in one second by code generation and one more second to extract class to a separate file

sorry, but what is

reset()

for? https://youtrack.jetbrains.com/issue/KT-9327#comment=27-2325315

it's described in the proposal, see the "Motivation" section: https://github.com/Kotlin/KEEP/pull/73

after a

reset()

would then

isInitialized

return

false

?

yes

It would be nice if property aliasing were a language feature or stdlib extension function. For example, I frequently encounter scenarious where it would be convenient to expose properties nested inside a member as a property of the outside container. Like the following: https://stackoverflow.com/questions/45074596/delegate-property-to-another-property

Instead of writing

myClass.property1.nested.property2 = value

, I would like to expose

property2

as a delegated property of

myClass

, ie.

myClass.property2 = value

Well you can do that by writing your own setter and getter, but you probably know that already.

and you can write your own delegates

Right, but you need to define two functions, which just return the aliased property anyway. It seems like a common enough thing that this should be defined as extension functions on KProperties:

operator fun <T> KProperty0<T>.getValue(thisRef: Any?, property: KProperty<*>) = get()
operator fun <T> KMutableProperty0<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T) = set(value)

that way, you could just write

var propertyAlias by property1.nested::property2

With the custom getter and setter technique, you would need to write:

var propertyAlias
    get() = property1.nested.property2
    set(value) {
      property1.nested.property2 = value
    }

which is much more verbose