e.g. `() -> Unit` is `Function0<Unit>`

# announcements

[Tuan Kiet]

e.g. () -> Unit is Function0<Unit>

[karelpeeters]

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

[Tuan Kiet]

@karelpeeters no, I’m trying to avoid using ()

[karelpeeters]

What does that mean? Why?

[Tuan Kiet]

because I want to know what the actual type, like () -> Unit is Function0<Unit>

[karelpeeters]

Ah okay, now I get it. That would be Function1<LiveNavigator, Unit>.

[karelpeeters]

You can check things like this easily using Show Kotlin Bytecode and then Decompile.

[Tuan Kiet]

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

[Tuan Kiet]

I believe Function1<LiveNavigator, Unit> is (LiveNavigator) -> Unit not LiveNavigator.() -> Unit

[Tuan Kiet]

or I’m wrong? maybe?

[karelpeeters]

They're the same thing behind the scenes.

[karelpeeters]

And even in the language itself, you can just pass a (X) -> Unit to something that expects a X.() -> Unit and the other way around, in the end it's all syntax sugar.

[Tuan Kiet]

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)

[karelpeeters]

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>.

[Tuan Kiet]

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?

[karelpeeters]

I don't think you can do that, just use the standard () -> Unit notation instead. Why do you want to avoid it?

[Tuan Kiet]

Because I want things to be explicit

[Tuan Kiet]

It turn out you be be explicit with (LiveNavigator) -> Unit but not with LiveNavigator.() -> Unit

[karelpeeters]

What? How is Function1<X, Y> more explicit then (X) -> Y? The latter is way more readable.

[karelpeeters]

Just look at the Function1 interface as an implementation detail you shouldn't worry about.