Greater order capabilities in Kotlin — Underneath the hood. | by Shangeeth Sivan | Jan, 2023 | Bros Tech

Let’s take a look at a easy operate with a operate sort parameter in Kotlin. For simplicity, I’ve created this methodology that accepts two parameters:

• title of the occasion chain sort
• completionListener of the Sort operate that returns Unit.

enjoyable insertEvent(eventName: String, completionListener: () -> Unit) 
eventRepository.insert(eventName) // Think about this a delayed occasion
completionListener.invoke()

Let’s convert it to Kotlin bytecode and decompile it to the Java model.

Instruments -> Kotlin -> Present Bytecode -> Decompile (Find out how to Hyperlink)

public last void insertEvent(@NotNull String eventName, @NotNull Function0 completionListener) 
Intrinsics.checkNotNullParameter(eventName, "eventName");
Intrinsics.checkNotNullParameter(completionListener, "completionListener");
this.eventRepository.insert(eventName);
completionListener.invoke();

Let’s break down every parameter:

• title of the occasion – the info sort continues to be a string and is annotated with the @NonNull annotation in Java; this parameter appears simple.
• completionListener – the info sort seems bizarre, it is known as Function0 ?? 🤔

What’s Function0? Should you do a management click on on Function0, you’ll navigate to Capabilities.kt

Let’s have a look at what Capabilities.kt incorporates:

public interface Function0<out R> : Perform<R> 
public operator enjoyable invoke(): R
public interface Function1<in P1, out R> : Perform<R> 
public operator enjoyable invoke(p1: P1): R
public interface Function2<in P1, in P2, out R> : Perform<R> 
public operator enjoyable invoke(p1: P1, p2: P2): R

.
.
.

function0 it is nothing greater than an interface with methodology name that has 0 parameters.

function1 is one other interface with name methodology which has 1 parameter

function2 is one other interface with name methodology which has 2 parameters
and proceed to Function22

Underneath that hood, our larger order operate completionListener has been outmoded by Function0 by Kotlin. If you understand a bit about generics, it’s best to be capable to determine what P1, P2, … and R are in Capabilities.kt

P1, P2, … are the generic sorts for the parameters of completionListener
R is the generic return sort for the return sort of the operate in our case completionListener return sort

Should you nonetheless cannot determine what is going on on, strive calling the identical operate you created in Kotlin from a Java file, you possibly can determine the way it works.

Since Kotlin is designed with Java interoperability in thoughts, current Java code might be known as from Kotlin naturally, and Kotlin code will also be used from Java with out situation.

//Calling the identical methodology from Java world
public static void important(String[] args)
// Calling the identical insertEvent from java world
eventHelper.insertEvent("take a look at", new Function0<Unit>() 
@Override
public Unit invoke() 
return null;

);

As you possibly can see above, we now have to create an nameless internal class for the Function0 interface to get the callback into the Java world.

Okay, let’s modify completionListener Y add a parameter:

// eliminated the eventName param
enjoyable insertEvent(completionListener: (take a look at: String) -> Unit) 
completionListener.invoke("success")

That is the generated code:

public last void insertEvent(@NotNull Function1 completionListener) 
Intrinsics.checkNotNullParameter(completionListener, "completionListener");
completionListener.invoke("success");

function0 is now changed with function1 to assist the String parameter.

I hope this weblog has helped you perceive how larger order capabilities work beneath the hood.

Some extra information:
Okay, will Kotlin assist any variety of parameters in our larger order capabilities? I obtained this query as a result of I observed one thing unusual in Capabilities.kt, there are operate interfaces as much as Function22. What is going to occur if I’ve greater than 22 parameters? Will Kotlin throw a compile error? We’ll see…

Let’s modify our completionListener have 23 parameters. 😅

// I've eliminated the string param and changed invoke methodology with a println.
enjoyable insertEvent(
completionListener: (
test1: String, test2: String, test3: String, test4: String, test5: String, test6: String, test7: String, test8: String, test9: String, test10: String, test11: String, test12: String, test13: String, test14: String, test15: String, test16: String, test17: String, test18: String, test19: String, test20: String, test21: String, test22: String, test23: String,
) -> Unit
) 
println("Simply Printing dont need to invoke it :sweat:")

Let’s decompile…

public last void insertEvent(@NotNull FunctionN completionListener) 
Intrinsics.checkNotNullParameter(completionListener, "completionListener");
String var2 = "Simply Printing dont need to invoke it :sweat:";
System.out.println(var2);

Wow, now there’s one thing known as FunctionN. I am going to allow you to discover what that’s.