Kotlin in action(8)

고차 함수 정의

코틀린에서는 람다나 함수 참조를 사용해 함수를 값으로 표현할 수 있는데, 고차 함수는 다른 함수를 인자로 받거나 함수를 반환한다. filter, map도 고차함수에 속한다.

함수 타입 - 람다로 인자 받기

함수 타입을 정의하려면 함수 파라미터의 타입을 괄호 안에 넣고, 그 뒤에 화살표를 추가한 다음, 함수의 반환 타입을 지정하면 된다. Unit 타입은 의미 있는 값을 반환하지 않는 함수 반환 타입에 쓰는 특별한 타입이다. 그냥 함수를 정의한다면 함수의 파라미터 목록 뒤에 오는 Unit 반환 타입 지정을 생략해도 되지만, 함수 타입을 선언할 때는 반환 타입을 반드시 명시해야 하므로 Unit을 빼먹어서는 안 된다.

val action: () -> Unit = { println(42) }        

 

인자로 받은 함수 호출

인자로 받은 함수를 호출하는 방법은 그냥 일반 함수와 같다.

fun twoAndThree(operation: (op1: Int, Int) -> Int) {
	  val result = operation(2, 3)
    println("The result is $result")
}

 

반환타입에 당연히 Nullable 하게 선언할 수 있고 파라미터에 이름을 붙여서 사용해도 된다. 이름을 붙여서 쓰면 가독성이 더 좋아지는 효과가 있다.

디폴트 값을 지정한 함수 타입 파라미터나 널이 될 수 있는 함수 타입 파라미터

파라미터를 함수 타입으로 선언할 때도 디폴트 값을 정할 수 있다.

fun <T> Collection<T>.joinToString(
        separator: String = ", ",
        prefix: String = "",
        postfix: String = "",
        transform: (T) -> String = { it.toString() } 
): String {
    ...
}

 

보다시피 디폴트 값을 람다로 지정하면 된다.

함수 타입은 invoke 메서드를 구현하는 인터페이스라는 게 이제 자연스럽게 이해되는데, 그냥 함수로 사용해도 되지만 invoke메서드를 safe call로 호출하면 더 null safe한 코드가 된다. 호출 부분만 살펴보자.

transform?.invoke(element) ?: element.toString()// 파라미터가 하나다

 

이렇게 하기 위해서는 함수타입도 nullable하게 고쳐줘야한다.

transform: ((T) -> String)? = null

 

함수를 함수에서 반환

함수를 반환하려면 return 식에 람다나 멤버 참조나 함수 타입의 값을 계산하는 식을 넣으면 된다.

fun getPredicate(): (Person) -> Boolean {
        val startsWithPrefix = { p: Person ->
            p.firstName.startsWith(prefix) || p.lastName.startsWith(prefix)
        }
        if (!onlyWithPhoneNumber) {
            return startsWithPrefix
        }
        return { startsWithPrefix(it)
                    && it.phoneNumber != null }
    }

 

익숙하지않은 모습이지만 반환값이 함수타입이다. return에 들어가 있는 것도, 변수로 정의된 람다와 그냥 람다 식이다.

왜 함수 타입을 사용할까? 고차함수를 사용하게 되면, 코드 구조를 좀 더 간단하게 개선할 수 있고 함수를 직접 넘기면서 그 전에 사용하던 보일러 플레이트들을 제거할 수 있게 된다. 중복제거 먼저 살펴보자.

람다를 활용한 중복 제거

사실 이건 filter, map을 사용하면서 미리 체감했을 수 있다. 코틀린으로 코딩테스트를 본다고 가정했을 때, 입력값을 받아 리스트로 변환하는 코드를 한줄로 바꿀 수 있다.

val input = br.readLine().split(" ").map{ it.toInt }.toIntArray()

 

함수타입이 반환되는걸 받아서 split, map, toIntArray로 차례로 변환되는 모습이다. 이렇게 함수를 넘기는 건 디자인패턴 중 전략패턴에 대응한다고 볼 수 있다. 전략에 따라 다른 람다를 넘기면 되기 때문에 자바 구버전처럼 전략별로 코드를 작성할 필요가 없어진다.

인라인 함수: 람다의 부가 비용 없애기 inline

inline 변경자를 어떤 함수에 붙이면 컴파일러는 그 함수를 호출하는 모든 문장을 함수 본문에 해당하는 바이트코드로 바꿔치기 해준다. 즉 내가 볼 때는 별도의 함수지만, 컴파일러가 볼 때는 본문에 들어가 있게 되는 것이다. 호출 비용을 없애준다는 말이다

인라이닝이 작동하는 방식

어떤 함수를 inline으로 선언하면 그 함수의 본문이 인라인된다. 다른 말로 하면 함수를 호출하는 코드를 함수를 호출하는 바이트코드 대신에 함수 본문을 번역한 바이트 코드로 컴파일한다는 뜻이다.

inline fun foo(): Person -> Boolean { }

 

인라인 함수의 본문 코드가 호출 지점에 들어가게 되고, 인라인 함수 안에 있는 람다 본문은 그냥 일반적인 람다 호출로 된다. 따라서 컴파일러는 무명 클래스로 감싸지 않고 람다를 사용하게 놔둔다.

인라인 함수의 한계점

인라인으로 사용한 람다가 본문에 펼쳐지기 때문에 파라미터로 받은 람다를 다른 변수에 저장했다가 사용해야되는 경우에는 인라이닝이 불가능하다. 이 경우 인라인 키워드를 붙이면

Illegal usage of inline-parameter 메시지가 나오기 때문에 noinline 키워드를 붙여서 미리 인라이닝을 금지시켜야한다.

fillter와 map은 인라인 함수로 컬렉션에서 아주 많이 사용되는데, 과정에서 중간리스트를 만들어 사용하기 때문에 컬렉션의 크기가 커지면 부가비용도 같이 커진다. 이때는 asSequence를 붙여 시퀀스로 사용하면 된다. 다만 람다를 저장해서 사용하는 시퀀스는 람다를 인라인해서 사용하지않는다.

함수를 인라인으로 선언해야 하는 경우

inline 키워드의 이점을 배우고 나면 코드를 더 빠르게 만들기 위해 코드 여기저기에서 inline을 사용하고 싶어질 것이다. 하지만 사실 이는 좋은 생각이 아니다. inline 키워드를 사용해도 람다를 인자로 받는 함수만 성능이 좋아질 가능성이 높다(전체로 보면 성능이 나빠질 수 있다는 이야기).

일반 함수 호출의 경우 JVM은 이미 강력하게 인라이닝을 지원한다. JVM은 코드 실행을 분석해서 가장 이익이 되는 방향으로 호출을 인라이닝한다. 이런 과정은 바이트코드를 실제 기계어 코드로 번역하는 과정(JIT)에서 일어난다. 이런 JVM의 최적화를 활용한다면 바이트코드에서는 각 함수 구현이 정확히 한 번만 있으면 되고, 그 함수를 호출하는 부분에서 따로 함수 코드를 중복할 필요가 없다. 반면 코틀린 인라인 함수는 바이트 코드에서 각 함수 호출 지점을 함수 본문으로 대치하기 때문에 코드 중복이 생긴다. 게다가 함수를 직접 호출하면 스택 트레이스가 더 깔끔해진다.

inline 변경자를 함수에 붙일 때는 코드 크기에 주의를 기울여야 한다. 인라이닝하는 함수가 큰 경우 함수의 본문에 해당하는 바이트코드를 모든 호출 지점에 복사해 넣고 나면 바이트코드가 전체적으로 아주 커질 수 있다.

자원 관리를 위해 인라인된 람다 사용

자바 7부터는 자원을 관리하기 위한 특별한 구문인 try-with-resource문이 생겼다. 코틀린으로는 use함수가 있는데 closable 자원에 대한 확장함수며, 파라미터는 람다다. 작동방식은 람다를 호출하고, 자원을 닫는다.

BufferedReader(FileReader(path)).use { br ->
        return br.readLine()
    }

 

람다를 실행하고, FileReader를 인자로 받는 BufferedReader를 close한다.

고차 함수 안에서 흐름 제어

람다 안의 return문: 람다를 둘러싼 함수로부터 반환

for와 forEach의 차이를 보겠다.

fun lookForAlice(people: List<Person>) {
    people.forEach {
        if (it.name == "Alice") {
            println("Found!")
            return
        }
    }
    println("Alice is not found")
}

 

람다 안에서 return을 사용하면 람다로부터만 반환되는 게 아니라 그 람다를 호출하는 함수가 실행을 끝내고 반환된다. 그렇게 자신을 둘러싸고 있는 블록보다 더 바깥에 있는 다른 블록을 반환하게하는 방식을 non-local return이라 부른다. 예제에서 forEach는 인라인 함수이므로 람다 본문과 함께 인라이닝된다. 따라서 return 식이 바깥쪽 함수를 반환시키도록 쉽게 컴파일할 수 있다.

람다로부터 반환: 레이블(label)을 사용한 return

람다 식에서도 로컬 return을 사용할 수 있다. 반복문 탈출 할 때 break지점 지정하는 것과 비슷한데. 로컬 return과 넌로컬 return을 구분하기 위해 레이블(label)을 사용해야 한다.

fun lookForAlice(people: List<Person>) {
    people.forEach label@{
        if (it.name == "Alice") return@label
    }
    println("Alice might be somewhere")
}​

람다에 레이블을 붙여서 사용하는 대신 람다를 인자로 받는 인라인 함수의 이름을 return 뒤에 레이블로 사용해도 된다. 람다 식의 레이블을 명시하면 람다식에 레이블을 2개 이상 넣을 수 없기 때문에 함수이름을 레이블로 사용할 수 없다.

people.forEach {
        if (it.name == "Alice") return@forEach
    }

 

무명 함수: 기본적으로 로컬 return

무명 함수는 코드 블록을 함수에 넘길 때 사용할 수 있는 다른 방법이다. 람다 안에서 여러개의 return@label이 필요하게 되면 보기 어렵기 때문에 이럴 때는 무명함수를 사용하는 것이 좋다.

fun (person) {
        if (person.name == "Alice") return
        println("${person.name} is not Alice")
    }

 

이렇게 시그니처가 없는게 무명함수인데

fun lookForAlice(people: List<Person>) {
    people.forEach(fun (person) {
        if (person.name == "Alice") return
        println("${person.name} is not Alice")
    })
}

 

무명 함수 안에서 레이블이 붙지 않은 return 식은 무명 함수 자체를 반환시킨다. 식을 본문으로 하면 반환타입도 생략할 수 있게된다. 무명함수를 사용하면 무명함수 본인을 반환하기 때문에 로컬 리턴 방식으로 작동하게된다. 람다 식의 구현 방법이나 람다 식을 인라인 함수에 넘길 때 어떻게 본문이 인라이닝 되는지 등의 규칙을 무명 함수에도 모두 적용할 수 있다.

요약하자면 return을 이해할때는 가장 가까운 fun을 반환한다고 보는게 편하다.

"댓글, 공감 버튼 한 번씩 누르고 가주시면 큰 힘이 됩니다"