A modern programming language that makes developers happier.

kotlinlang

reflect_on_lambda_body_.kt

You could get the java class of the lambda and then use a bytecode analyzing library to look for an invocation bytecode and look at which method is being invoked.

Thanks <@U589QURRQ> do you have any recoomendation concerning such a library? I’ve never worked with bytecode directly.

<https://asm.ow2.io/> is pretty much the standard

However, the question is if this is really necessary. Does it have to be a lambda?

I’m building a visualization library and it would make it more convenient. See 2nd example in <https://github.com/holgerbrandl/kravis#iterators> for an example, where I’d like to apply it. If possible the axis labels should be determined from the lambdas such as `{ heightCm }`. Currently the user has to specify them again.

Okay, I see. You could require users to pass in a reference instead:
`ggplot(x = Person::heightCm)`

That’s a good idea as well. Though, it involves duplication of the type in case of multiple attributes, that’s why I also still like the lambda-style syntax.

Is there any way to reduce is to something like `x = ::conservation`? The type context is known because of refied generics.

In other  words, can i use a property reference without prefixing it with the type itself?

```
import krangl.SleepPattern
import krangl.sleepPatterns
import kravis.GGPlot
import kravis.ggplot
import kotlin.reflect.KProperty1

inline fun &lt;reified T&gt; Iterable&lt;T&gt;.buildPlot(
     x: KProperty1&lt;T, *&gt;,
     y: KProperty1&lt;T, *&gt;
): GGPlot {
    val map = map { x.get(it) to y.get(it) }

    // later convert data to actual plot

    return ggplot()
}

val basePlot = sleepPatterns.buildPlot(
    x = SleepPattern::conservation,
    y = SleepPattern::bodywt
)

// nicer but not legit:

val basePlot = sleepPatterns.buildPlot(
    x = ::conservation,
    y = ::bodywt
)
```

I don't think that is possible, unless you have a reference to the class available. In that case you could do this:
```
fun &lt;T : Any&gt; buildPlot(referenceExtractor: (T).() -&gt; KProperty0&lt;*&gt;) = TODO()
```
Called like this:
```
buildPlot&lt;MyClass&gt; { ::propertyOfMyClass }
```
But that then requires an instance of `MyClass` inside `buildPlot` to call the lambda. And it is really just starting to bend the language in ways it's not designed to go

Actually, since it’s an extension on `Iterable&lt;T&gt;` I have tons of instances of T. It’s a great solution which I would have never found myself, thanks a lot.  :slightly_smiling_face:

Unfortunately not. Don't have the money and/or time. Still a poor apprentice :smile: