e.g.

() -> Unit

is

Function0<Unit>

It's not that clear what you want, are you looking for currying?

@karelpeeters no, I’m trying to avoid using

()

What does that mean? Why?

because I want to know what the actual type, like

() -> Unit

is

Function0<Unit>

Ah okay, now I get it. That would be

Function1<LiveNavigator, Unit>

.

the Decompiler didn’t show the generic part, it is in the metadata which I couldn’t understand sadly

They're the same thing behind the scenes.

pretty sure

(LiveNavigator) -> Unit

will make

LiveNavigator

as

it

while

LiveNavigator.() -> Unit

make

LiveNavigator

as

this

. I have seen a lamba have both

it

and

this

as the same time (maybe something like LiveNavigator.(Int) -> Unit)

Indeed, but in the end

it

vs

this

is just a name, there's no actual

this

object that the function is being invoked on. This is what I mean by "syntax sugar". The second example function then becomes

Function2<LineNavigator, Int, Unit>

.

but when declare a

Function2<LineNavigator, Int, Unit>

I don’t get

this

as

LineNavigator

and

it

as

Int

(but get

lamba { navigator, value -> } instead

) how can I do this?

I don't think you can do that, just use the standard

() -> Unit

notation instead. Why do you want to avoid it?

Because I want things to be explicit

What? How is

Function1<X, Y>

more explicit then

(X) -> Y

? The latter is way more readable.