[Kotlin] 람다는 자바로 어떻게 컴파일될까

1. 받는 인수가 없고, 반환 타입이 없는 람다

코틀린 코드

fun runLambda(lambda: () -> Unit) {
    lambda()
}

fun main() {
    runLambda { println("HelloWord") }
}

// 출력 결과 : HelloWord

 

자바 변환

public final class MainKt {
   public static final void main() {
      runLambda((Function0)null.INSTANCE);
   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }

   public static final void runLambda(@NotNull Function0 lambda) {
      Intrinsics.checkNotNullParameter(lambda, "lambda");
      lambda.invoke();
   }
}

 

 

받는 인수가 없고, 반환 타입이 없는 람다는 Function0 인터페이스가 구현된 클래스로 변환된다.

 

Function0 인터페이스

// Functions.kt 안
package kotlin.jvm.functions

/** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}

 

2 외부 스코프에  value 참조하는 람다

코틀린 코드

fun runLambda(lambda: () -> Unit) {
    lambda()
}

fun main() {
    val sayHello = "Say Hello"
    runLambda {
        println(sayHello)
    }
}

// 출력 결과 : Say Hello

 

자바 변환

public final class MainKt {
   public static final void main() {
      final String sayHello = "Say Hello";
      runLambda((Function0)(new Function0() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke() {
            this.invoke();
            return Unit.INSTANCE;
         }

         public final void invoke() {
            String var1 = sayHello;
            System.out.println(var1);
         }
      }));
   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }

   public static final void runLambda(@NotNull Function0 lambda) {
      Intrinsics.checkNotNullParameter(lambda, "lambda");
      lambda.invoke();
   }
}

 

value의 참조를 Function0 클래스 안에서 사용한다.

 

2 외부 스코프에  variable을 참조하는 람다

코틀린 코드

fun main() {
    var sayHi = "Say Hi"
    val myLambda = {
        println(sayHi)
    }
    sayHi = "Good night"
    myLambda()
}

//출력 결과 : Good night

 

자바 변환

public final class MainKt {
   public static final void main() {
      final Ref.ObjectRef sayHi = new Ref.ObjectRef();
      sayHi.element = "Say Hi";
      Function0 myLambda = (Function0)(new Function0() {
         // $FF: synthetic method
         // $FF: bridge method
         public Object invoke() {
            this.invoke();
            return Unit.INSTANCE;
         }

         public final void invoke() {
            String var1 = (String)sayHi.element;
            System.out.println(var1);
         }
      });
      sayHi.element = "Good night";
      myLambda.invoke();
   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }
}

 

variable을 Ref 클래스로 래핑한다.

variable이 String이므로, Ref.ObjectRef 클래스의 element 값으로 variable이 저장되어 래핑된다.

람다 바깥의 varialbe을 캡쳐한 람다가 먼저 선언되어 있어도, 람다 실행 전엥 variable이 수정되면 Ref.ObjectRef 클래스의 element로 값을 변경해서 람다 실행 시 변경된 값이 출력된다.

 

Ref 클래스

//Ref.java 파일 안

package kotlin.jvm.internal;

import java.io.Serializable;

public class Ref {
    private Ref() {}

    public static final class ObjectRef<T> implements Serializable {
        public T element;

        @Override
        public String toString() {
            return String.valueOf(element);
        }
    }

    public static final class ByteRef implements Serializable {
        public byte element;

        @Override
        public String toString() {
            return String.valueOf(element);
        }
    }
    ... // Short, Long, Int, Boolean, Double, Float, Char용 래퍼 클래스들이 선언되어 있다.
}

 

 

3 인수가 여러 개인 람다, 반환 타입이 있는 람다 등

코틀린 코드

fun main() {

    val lambdaWithParameterOne = { it: String ->
        println("lambdaWithParameterOne $it")
    }
    lambdaWithParameterOne("Hello Kotlin")

    val lambdaWithParameterTwo = { one: String, two: String ->
        println("lambdaWithParameterTwo $one, $two")
    }
    lambdaWithParameterTwo("Hi", "Good Luck")

    val lambdaWithReturn = {
        "Return Hello"
    }
    println(
        lambdaWithReturn()
    )

    val lambdaWithParameterAndReturn = { it: String ->
        "$it Kotlin"
    }
    println(
        lambdaWithParameterAndReturn("Hi")
    )
}
// 출력 결과 : 
// lambdaWithParameterOne Hello Kotlin
// lambdaWithParameterTwo Hi, Good Luck
// Return Hello
// Hi Kotlin

 

자바 변환

public final class MainKt {
   public static final void main() {
      Function1 lambdaWithParameterOne = (Function1)null.INSTANCE;
      lambdaWithParameterOne.invoke("Hello Kotlin");
      
      Function2 lambdaWithParameterTwo = (Function2)null.INSTANCE;
      lambdaWithParameterTwo.invoke("Hi", "Good Luck");
      
      Function0 lambdaWithReturn = (Function0)null.INSTANCE;
      Object var3 = lambdaWithReturn.invoke();
      System.out.println(var3);
      
      Function1 lambdaWithParameterAndReturn = (Function1)null.INSTANCE;
      Object var4 = lambdaWithParameterAndReturn.invoke("Hi");
      System.out.println(var4);
   }
}

 

인수가 한 개이고 반환 값이 없는 람다 -> Function1 클래스로 변환

인수가 두 개이고 반환 값이 없는 람다 -> Function2 클래스로 변환

인수가 없고 반환 값이 있는 람다 -> Functoin0 클래스로 변환

인수가 한 개에 반환 값이 있는 람다 -> Function1() 클래스로 변환

 

Functions.kt 파일 안

/*
 * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

// Auto-generated file. DO NOT EDIT!

package kotlin.jvm.functions

/** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}

/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}

/** A function that takes 2 arguments. */
public interface Function2<in P1, in P2, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2): R
}

/** A function that takes 3 arguments. */
public interface Function3<in P1, in P2, in P3, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2, p3: P3): R
}

...

/** A function that takes 22 arguments. */
public interface Function22<in P1, in P2, in P3, in P4, in P5, in P6, in P7, in P8, in P9, in P10, in P11, in P12, in P13, in P14, in P15, in P16, in P17, in P18, in P19, in P20, in P21, in P22, out R> : Function<R> {
    /** Invokes the function with the specified arguments. */
    public operator fun invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21, p22: P22): R
}