cuándo usar una function en línea en Kotlin?

Sé que una function en línea mejorará el performance y hará que el código generado crezca, pero no estoy seguro de cuándo usarlo correctamente.

lock(l) { foo() } 

En lugar de crear un object de function para el parámetro y generar una llamada, el comstackdor podría emitir el siguiente código. ( Fuente )

 l.lock() try { foo() } finally { l.unlock() } 

pero descubrí que no hay ningún object de function creado por kotlin para una function que no esté en línea. ¿por qué?

 /**non-inline function**/ fun lock(lock: Lock, block: () -> Unit) { lock.lock(); try { block(); } finally { lock.unlock(); } } 

    Supongamos que crea una function de order superior que toma una lambda de tipo () -> Unit (sin parameters, sin valor de retorno) y la ejecuta de la siguiente manera:

     fun nonInlined(block: () -> Unit) { println("before") block() println("after") } 

    En el lenguaje de Java, esto se traducirá a algo como esto (¡simplificado!):

     public void nonInlined(Function block) { System.out.println("before"); block.invoke(); System.out.println("after"); } 

    Y cuando lo llamas de Kotlin …

     nonInlined { println("do something here") } 

    Debajo del capó, se creará una instancia de Function aquí, que envuelve el código dentro de la lambda (de nuevo, esto se simplifica):

     nonInlined(new Function() { @Override public void invoke() { System.out.println("do something here"); } }); 

    Entonces, básicamente, llamar a esta function y pasarle una lambda siempre creará una instancia de un object Function .


    Por otro lado, si usa la palabra key en inline :

     inline fun inlined(block: () -> Unit) { println("before") block() println("after") } 

    Cuando lo llamas así:

     inlined { println("do something here") } 

    No se creará ninguna instancia de Function , en cambio, el código alnetworkingedor de la invocación de un block dentro de la function inline se copyrá en el sitio de la llamada, por lo que obtendrá algo como esto en el bytecode:

     System.out.println("before"); System.out.println("do something here"); System.out.println("after"); 

    En este caso, no se crean nuevas instancias.