How to deal with the "extra" size?

In Kotlin programs, the use of anonymous code is very widespread and, without doubt, the ease of its description and use is one of the principal advantages of this language. Due to the abundance of anonymous code applications, the problem of increasing the size of a program due to the generation of classes for each code fragment can become a very big problem.

There are two ways to deal with the storage of redundant information in a file with the collected application.

The first is to use various tools that are designed to remove service information from the compiled files for the JVM .

One of the very interesting tools of this group is ProGuard . This is a free tool that allows you to repack a JAR archive with the application and remove all service information from it. In addition to the simple removal of proprietary information, it does a great job of optimizing the code for the classes. As a bonus, this tool can be used as an " Obfuscator ", i.e. a tool that makes it difficult to recover application logic from its code.

This is a powerful tool, but its review goes beyond the goals of this article.

The second way (which can be combined with the first) is to use the features of the Kotlin compiler. This feature is discussed in the next section.

Internal Auto Classes

Let's make experiment with our example, having changed the description of two methods.

 inline fun <T> cAction(v : T, cb : T.() -> Int) = println(v.cb()) inline fun Action(cb : () -> Int) = println(cb()) 

In this case, we added the inline to the write function.

After compiling the program, the list of files created by the compiler for automatic classes was reduced to three: “ KMainKt$Test$1.class ”, “ KMainKt$Test$2.class ” and “ KMainKt$Test$cb$1.class ”. Those. there are only those classes that are not passed as parameters to the Action and cAction functions. The size of the file " KMainKt.class " increased by about 200 bytes.

Where are the other classes?

The code of all functions declared with the inline modifier was inserted directly into the place where the functions were called. In addition, the compiler has created separate functions with the same name. The syntax of the language will not allow using the declared functions. when you try to call it, its code will be placed in the place of use, but its static copy is created to provide access to this function through reflection .

How it works?

The block of anonymous code in Kotlin, depending on where it is used, can be implemented either with the help of automatic objects, or placed directly at the call site. In the first case, an object of a certain class will be created, the description of which will be in this section, and in the second case such a block as an object does not exist at all.

When creating automatic classes, Kotlin can create two types of objects:

1. An object of some class, a successor of a user class.
2. An object representing a special class to call a block of code.

Custom Type Objects

The first method is used when creating anonymous classes, lambda functions and implementing interfaces using delegates. In this case, a class will be created, the successor of the specified (explicitly or implicitly) user class and the code block will be placed inside one of the methods of this class.

 fun add(i : ActionListener) {} add(object : ActionListener { override fun actionPerformed(e : ActionEvent?) {} }) add(ActionListener { e -> }) 

If an automatic class is created for an anonymous class, then an object for it will be built in the place of the declaration and passed as a parameter to the destination. If a class is created to implement a functional interface, then if it does not capture local variables, the previously created singleton of this class will be used. If local variables are captured, a new object will be built, to which references to all captured variables will be passed to the constructor as parameters.

 //   : add(ActionListener { e -> }) class AutoClassForCase1 : ActionListener { override fun actionPerformed(e : ActionEvent?) { //        - } companion object { @JvmField val INSTANCE = AutoClassForCase1() } } add( AutoClassForCase1.INSTANCE ) //     

Capture Local Variables

Kotlin , in contrast to Java , allows anonymous code to capture local variables of any type (in Java they must be " effectively final "), so the transfer of captured variables to an automatic class occurs through the special class " Ref<T> ". As a result of this approach, if a local variable was captured by at least one block of code, then it automatically turns into a link at the place of its use, and all references to it are made using this link. This method introduces some additional overhead in comparison with the method used in Java , but allows you to change the values ​​of variables.

  fun Test() { val local = 10 Action{ local+1 } local + 2 } 

  fun Test() { val local = Ref<Int>(10) //      Action{ local.value + 1 } //        local.value + 2 //     local.value = null //       } 

At the same time, you need to pay attention to the following points:

1. The value of the captured variable is accessed from the code block through the object of the automatic class, which contains the same object as the link in the function body. This object is created and passed to the constructor object of the automatic class in the place where the code block is declared.
2. In case the code captures any variables from the current context, not a singleton is used as an object of the automatic class, but a new object is created. This happens in order to be able to call the constructor and pass references to the captured variables.
3. At the end of the function, Kotlin automatically generates the object cleanup code for all captured variables, so after the function completes, the number of references to local objects is always equal to the number of automatic objects created.

Objects for code block

The example described just above for calling an anonymous block of code is implemented by the compiler in approximately the following way:

  //       class AutoClassForMethod : Function0<Int> { //       private val local : Ref<Int> //       constructor( l:Ref<Int> ) { local.value = l.value } //     fun invoke() : Int { //      } } //          Action( AutoClassForMethod(local) ) 

All Kotlin code blocks always have the type FunctionX<Ret[,Param1[,...]]> , where FunctionX is a set of template classes that implement a method call with an arbitrary number of parameters. The last template type is the return type, the first is the type of the first parameter, and so on. The symbol in the class name I used to denote the number of method parameters. Those. the method described in Kotlin as ()->Unit will have the actual type Function0<Unit> , and the method described as (Int,String)->Double type Function2<Int,String,Double> , etc.

FunctionX templates are described in the Kotlin library " kotlin-runtime.jar " and can be used in your program. The syntax for describing blocks of code using the "standard" syntax in the form ()->Unit and using the template Function0<Unit> absolutely equivalent. You can verify this by replacing the function declaration in the original example.

 fun <T> cAction(v : T, cb : Function1<T,Int>) = println(cb.invoke(v)) fun Action(cb : Function0<Int>) = println(cb.invoke()) 

The program will be collected and executed as before.

Please note that the syntax " T.() -> Int " used earlier was completely transparently replaced by the use of a template with passing an extra type corresponding to the type of object for which the method will be called. Those. the difference between calling the static function and the function of the object, only in the extra parameter " this ".

What is this useful?

From the point of view of a simple user, the available syntax of the language is a little useful here.

But, from the point of view of a developer of a library, or a person implementing a complex control algorithm using dynamic lists of methods, knowing how automated objects are organized and how to handle blocks of code can be extremely useful.

— .

 class Holder { var cb : (()->Unit)? = null inline fun setup( cb:()->Unit ) { this.cb = cb // :    inline- } } fun Test() { Holder().setup{ } } 

 class Holder { var cb : (()->Unit)? = null inline fun setup( cb:()->Unit, noinline delayed:(()->Unit)?=null ) { this.cb = delayed cb() CallCodeWithDelay() } fun DelayPassed() = cb?.invoke() } 

 @Suppress("NOTHING_TO_INLINE") inline fun SetupControl( ctl: Label ) { ctl.text = "Label" ctl.setSize( 100,100 ) } fun Test() { SetupControl( Label() ) } 

 fun Test1() : Int { Action { return 3 } } 

 fun <T,P> templateTest(value : T) : P { if ( value is P ) // :    return value } templateTest<String,String>("text") 

 inline fun <T,reified P> templateTest(value : T) : P { if ( value is P ) //         return value } 

 This function has a reified type parameter and thus can only be inlined at compilation time, not called directly