Kotlin: Lambda Expression vs Member Reference(::)🫢

사진: Unsplash의Mateusz Wacławek

Intro

• Gurgen Gevondov의 글을 읽고 정리한 아티클입니다.

• 아래 지식을 알면 이 아티클을 이해하기 더 쉽습니다 😸

• 고차함수: 다른 함수를 인자로 받거나 함수를 반환하는 함수
• 람다식은 함수형 인터페이스를 구현하는 클래스로 컴파일 된다.
• Callable references: 생성자, 함수, 프로퍼티의 참조값(::)은 함수 타입 으로 변환될 수 있다(모두 KCallable을 공통 조상으로 갖고 있다)
• Bounded Member Reference: 프로퍼티나 메서드를 단 하나만 호출하는 함수 값(레퍼런스)를 만들어준다.

추후, 해당 내용들을 알기 쉽게 정리해보겠습니다! 💪

---

나는 고차함수를 넘길 때 멤버 참조식 :: 을 다음과 같은 이유로 애용한다.

1) 람다식에 비해 가독성이 좋다.
2) 람다식의 객체 생성 비용을 줄일 수 있다.

student.maxBy { it.age }
student.maxBy(Student::age) // 더 이해하기 쉽다!

그러나, 레아가 추천해주신 블로그 글을 읽고, :: 을 잘 모르고 사용했다는 것을 깨달았다. 🥲

그럼 Quiz를 통해 독자들은 ::와 람다의 차이를 잘 알고 있는지 확인해보자~

Quiz : 너 :: 와 람다 차이 잘 알고 있니? 🤔

private class ButtonClickListener {
    fun onClick() {
        println("Button clicked")
    }
}

버튼을 눌렀을 때의 Action을 나타내는 ButtonClickListener 가 있다.

private class Button(
    private val listener: ClickListener
) {
    fun performClick() = listener.onClick()
}

해당 listener는 Button 의 멤버이고, performClick() 을 호출 시 listener 의 이벤트가 수행된다.

private class ScreenView {
    lateinit var listener: ClickListener
    val button = Button(listener::onClick)}
    val button2 = Button { listener.onClick() 
}

ScreenView 는 listener, button 과 button2 를 멤버로 가지고 있다.

• button은 람다식으로 이벤트를 전달받는다.
• button2는 프로퍼티 레퍼런스로 이벤트를 전달받는다.

fun main() {
    ScreenView().apply {
        listener = ButtonClickListener() // listener 초기화
        button.performClick()
        button2.performClick()
    }
}

해당 main() 를 호출하면 결과가 어떻게 나올까?!
.
.
.
.
.
.
.
.
.
.
.
.
.
.

두둥! 프로그래밍이 죽는다! 💀.
🤯 Error 메세지를 보니 listener 가 아직 초기화되지 않았는데 listener를 사용했기 때문에 크래쉬가 났다고 한다

우리는 분명 main() 함수에서 ScreenView의 listener를 초기화해주었다.
그런데 왜 초기화 에러로 프로그램이 터질까?!
이유를 알기 위해서 java 코드로 디컴파일 해보자 💪

어디서 문제가 발생한건지 고민해본 후 읽어보는걸 추천한다.

button 디컴파일

private class ScreenView {
	lateinit var listener: ClickListener
	val button = Button(listener::onClick)
    ...

해당 ScreenView 를 디컴파일해보면 button을 ScreenView 의 생성자에서 초기화하고 있다.

public ScreenView() {
    Button var10001 = new Button;
    Function0 var10003 = new Function0() {
        ...

        public final void invoke() {
            ((ButtonClickListener)this.receiver).onClick();
        }
    };
    ButtonClickListener var10005 = this.listener;
    if (var10005 == null) {
        Intrinsics.throwUninitializedPropertyAccessException("listener");
    }

    var10003.<init>(var10005); // listener::onClick 할당
    var10001.<init>((Function0)var10003); // Button 할당
    this.button = var10001;
    ...

엄청 복잡해보인다..
차근차근 뜯어보자! 💪

1) var10003 부분

Function0 var10003 = new Function0() {
	...
    
    public final void invoke() {
        ((ButtonClickListener)this.receiver).onClick();
    }
};

Function0 익명 class의 인스턴스를 var1003 변수에 할당하고 있다.
그 이유는, listener::onClick을 람다식으로 변환하여 Button의 생성자로 넘기기 위함이다.

람다식은 FunctionN 인테퍼에스를 구현하는 익명 class의 인스턴스다.

Function0 익명 class의 invoke() 내부에 this.receiver 를 볼 수 있는데, receiver 가 바로 listener::onClick 의 수신객체 listener다.
즉, invoke() 가 호출될 때 listener.onClick()이 실행된다.

lateinit var listener: ClickListener // 얘가 this.receiver 를 뜻함

정리)

1) listener::onClick 를 Function0 익명 class 로 wrapping하여 람다식으로 만들고 있음

2) button의 performClick() 이 호출될 때마다 위의 invoke() 함수가 호출될 것임

1) var10005 부분 코드 해석

ButtonClickListener var10005 = this.listener;
if (var10005 == null) {
    Intrinsics.throwUninitializedPropertyAccessException("listener");
}

listener를 var1005 변수에 할당하고 있고, var1005 가 초기화되지 않았으면 Exception을 던진다고 한다.

🤓 바로 이 부분에서 프로그램이 크래쉬되는 것이다!

ScreenView가 초기화될 때, listener가 아직 아직 초기화되지 않았다.
따라서, 위 null 검증문을 통과하지 못해 UninitializedPropertyAccessException이 발생 😱

// ScreenView가 초기화될 때 null 검사함, 근데 아직 초기화 안됐으니 펑! 👻
   ScreenView().apply {
        listener = ButtonClickListener() // listener 초기화
        button.performClick()
        button2.performClick()
    }

---

그럼 이제 람다식을 통해 이벤트를 전달한 button2의 디컴파일된 코드를 분석해보자~

button2 의 디컴파일 코드

class ScreenView{
	val button2 = Button { listener.onClick() }
	...
    
// java
private static final class ScreenView {
    private final Button button2 = new Button((Function0)(new Function0() {
        public final void invoke() {
           ScreenView.this.getListener().onClick();
        }
    }));
    ...

button와 달리 button2는 listener의 초기화 검사를 ScreenView가 생성될 때 하지 않는다.

@NotNull
public final ButtonClickListener getListener() {
    ButtonClickListener var10000 = this.listener;
    if (var10000 == null) {
        Intrinsics.throwUninitializedPropertyAccessException("listener");
    }

    return var10000;
}

button2 는 this.getListener() 를 호출될 때 초기화 검사를 하고 있다.

buttone2.performClick() // 이 때 listener가 초기화됐는지 검사

즉, buttone2.performClick()이 호출될 때 람다의 invoke() 함수에서 초기화 검사를 하기 때문에, ScreenView를 생성할 때
따라서, 람다를 활용해 고차함수를 넘길 때는 throwUninitializedPropertyAccessException 가 발생하지 않는다. 😀

정리

• bounded member reference: 수신 객체가 초기화되있어야, 고차함수로 활용할 수 있다.
• lambda expression: invoke()가 호출되는 시점에 수신객체가 초기화되었는지 검사한다.

사실 bounded member reference에 대한 개념을 잘 알고 있으면, 굳이 디컴파일하지 않아도 프로그램이 터진다는 것을 알 수 있다.

애초에 bounded member reference 자체가 멤버 참조를 생성할 때, 인스턴스를 함께 저장한 다음 나중에 그 인스턴스에 대해 멤버를 호출해주는 것이다.
그러나, 위의 예시의 경우 Listener 가 초기화되지 않았는데, 호출하니 당연히 터질 수 밖에...

lateinit var listener: ButtonClickListener
val onClick = ButtonClickListener::onClick // KFunction1<ButtonClickListener, Unit>
val button = Button { onClick(listener) }

val button2 = Button(listener::onClick) // 위와 똑같다

추가 퀴즈

class Button(
    private val onClick: () -> Unit
) {
    fun performClick() = onClick()
}

class ButtonClickListener(
    private val name: String
) {
    fun onClick() {
        print(name)
    }
}

class ScreenView {
    var listener = ButtonClickListener("First")
    val buttonLambda = Button { listener.onClick() }
    val buttonReference = Button(listener::onClick)
}

fun main() {
    val screenView = ScreenView()
    screenView.listener = ButtonClickListener("Second")
    screenView.buttonLambda.performClick()
    screenView.buttonReference.performClick()
}

풀어보십셔~!!

정답은 SecondFirst 입니다. 크크

Thanks To Gurgen Gevondov

Reference

https://kt.academy/article/fk-function-references

https://proandroiddev.com/kotlin-lambda-vs-method-reference-fdbd175f6845