I'm guessing the following is impossible, but I figured it can't hurt to ask:

class Foo(val title: String = *the name of the field storing the instance of this class*)

val foo = Foo()

So, in this case "foo"

you could probably do something incredibly cursed with reflection and traversing the call stack, but I definitely wouldn’t recommend it

yep. i figured that much

If you do it with delegates it's only semi-cursed:

data class Foo(val title: String) {
    companion object {
        operator fun provideDelegate(thisRef: Any, prop: KProperty<*>): ReadOnlyProperty<Any, Foo> {
            val foo = Foo(prop.name)
            return object: ReadOnlyProperty<Any, Foo> {
                override fun getValue(thisRef: Any, property: KProperty<*>) = foo
            }
        }
    }
}

class Test {
    val test by Foo
}

fun main() {
    println(Test().test) //"Foo(title=test)"
}

That's really cool.

Or if you want it to work outside of classes too:

data class Foo(val title: String) {
    companion object {
        operator fun invoke(): ReadOnlyProperty<Nothing?, Foo> {
            return object: ReadOnlyProperty<Nothing?, Foo> {
                var foo: Foo? = null
                override fun getValue(thisRef: Nothing?, property: KProperty<*>) =
                        foo ?: Foo(property.name).also { foo = it }
            }
        }
    }
}

fun main() {
    val test by Foo()
    println(test)   //"Foo(title=test)"
}

i actually didn't know that

by

was an overridable operator

More cursed because of nullability and

Nothing?

haha, yay! most of my experience with delegates is stuff like

class MySpecialList<T>(val data: MutableList<T>) : MutableList<T> by data {
     override fun add(element: T): Boolean {
          foo(element)
          return (this as MutableList<T>).add(element)
     } 
}

So I'm writing a compiler based on SSA form, think low level, something like

x = add(2, 3)
y = add(x, 2)

ah

So

y.operands == setOf(x, 2)

and

x.users = setOf(y)

that seems like something i'm really interested in, since i wanted to expand the Units of Measurement library port to Kotlin called Physikal so that it could handle conversion of types involving math operators, e.g.

val mass = <http://4.kg|4.kg>
val volume = 1.m * <http://3.cm|3.cm> * 5.dm
val density = mass / volume

That looks like valid Kotlin to me 😒imple_smile:

it is. i'd have to think for a bit why you'd want some compiler trickery

Still looks okay to me, define

val inch = 1.inch

and

val sqInch = inch * inch

oh, i think when i talked to the folks that made the port, they wanted you to be able to forgo the

.

val acceleration = 52m/s/s

Yeah that's great until you want the atomic mass unit

u

.

i'd also be interested in learning how do mess with the compiler so i could add stuff like swift's

until

operator:

println(5..<8)
// 5, 6, 7

and unbounded ranges:

println(6..) // 6, 7, 8, 9, 10, 11, 12, ...

that i could use in indexing:

println(foo[..4])

That's not possible right now, wasn't there a question about this in #language-proposals a while ago?

i don't know. i've never been to that channel. didn't know it existed. now i know i've been posting some of my ideas for the language in the wrong channel...

found it