3장 - 함수 정의와 호출

3장에서는 모든 프로그램에서 핵심이라 할 수 있는 함수 정의와 호출 기능을 코틀린이 어떻게 개선했는지 살펴본다. 추가로 확장 함수와 프로퍼티를 사용해 자바 라이브러리를 활용하면 코틀린과 자바를 함께 쓰는 프로젝트에서 코틀린의 장점을 최대한 살릴 수 있다.

이번 장에서 설명하는 내용이 더 유용하기 (그리고 덜 추상적이기 위해)위해서 코틀린 컬렉션, 문자열, 정규식(regulear expression)만으로 문제 영역을 한정한다. 우선 코틀린에서 컬렉션을 만드는 방법을 살펴보자.

코틀린에서 컬렉션 만들기

일단 컬렉션을 만드는 방법을 배워보자.
앞에서 setOf 함수로 집합을 만드는 방법을 살펴본 적이 있다.

val set = hashSetOf(1, 7, 53)

비슷한 방법으로 리스트와 맵도 만들 수 있다.

val list = arrayListOf(1, 7, 53)
val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

여기서 to는 언어가 제공하는 특별한 키워드가 아니라 일반 함수 라는 점에 유의하라. 이에 대해서는 나중에 다룬다.
여기서 만든 객체가 어떤 클래스에 속하는지 추측할 수 있겠는가? 다음 예제를 실행하면 직접 그 결과를 볼 수 있다.

>>> println(set.javaClass) // javaClass는 자바 getClass()에 해당하는 코틀린 코드다. 
class java.util.HashSet
>>> println(list.javaClass)
class java.util.ArrayList
>>> println(map.javaClass)
class java.util.HashMap

이는 코틀린이 자신만의 컬렉션 기능을 제공하지 않는다는 뜻이다. 자바 개발자가 기존 자바 컬렉션을 활용할 수 있다는 뜻이므로 이는 자바 개발자들에게 좋은 소식이다.

코틀린이 자체 컬렉션을 제공하지 않는 이유는 뭘까? 표준 자바 컬렉션을 활용하면 자바 코드와 상호작용하기가 훨씬 더 쉽다. 자바에서 코틀린 함수를 호출하거나 코틀린에서 자바 함수를 호출할 때 자바와 코틀린 컬렉션을 서로 변환할 필요가 없다.

코틀린 컬렉션은 자바 컬렉션과 똑같은 클래스다. 하지만 코틀린에서는 자바보다 더 많은 기능을 쓸 수 있다. 예를 들어 리스트의 마지막 원소를 가져오거나 수로 이뤄진 컬렉션에서 최댓값을 찾을 수 있다.

>>> val strings = listOf("first", "second", "fourteeth");

>>> println(strings.last())
fourteeth

>>> val numbers = setOf(1, 14, 2)

>>> println(numbers.max())
14

이번 장에서는 이런 기능이 어떻게 동작하는지 보여주고, 자바 클래스에 없는 메서드를 코틀린이 어디에 정의하는지 살펴본다.
last나 max가 함수가 자바 컬렉션에 대해 어떻게 마술처럼 작동하는지 살펴보기 전에 함수 선언에 대한 몇 가지 새로운 개념을 살펴보자.

함수를 호출하기 쉽게 만들기

여러 원소로 이뤄진 컬렉션을 만드는 방법을 배웠으므로 간단하게 모든 원소를 찍어보자. 너무 단순하지 않나 걱정할 필요는 없다. 원소를 찍는 과정에서 여러 중요한 개념에 마주치게 된다.

자바 컬렉션에는 디폴트 toString 구현이 들어있다. 하지만 그 디폴트 toString의 출력 형식은 고정돼 있고 우리에게 필요한 형식이 아닐 수도 있다.

>>> val list = listOf(1, 2, 3)
>>> println(list)  <- toString() 호출
[1, 2, 3]

디폴트 구현과 달리 (1; 2; 3) 처럼 원소 사이를 세미콜론으로 구분하고 괄호로 리스트를 둘러싸고 싶다면 어떻게 해야할까? 이를 위해서는 자바 프로젝트에 구아바(Guava)나 아파치 커먼즈(Apache Commons) 같은 서드파티 프로젝트를 추가하거나 직접 관련 로직을 구현해야 한다. 코틀린에는 이런 요구 사항을 처리할 수 있는 함수가 표준 라이브러리에 이미 들어있다.

이번 절에서는 이런 함수를 구현해볼 것이다. 처음에는 함수 선언을 간단하게 만들 수 있게 코틀린이 지원하는 여러 기능을 사용하지 않고 함수를 직접 구현한다. 그 후 좀 더 코틀린답게 같은 함수를 다시 구현한다.

다음 리스트의 joinToString 함수는 컬렉션의 원소를 StringBuilder의 뒤에 덧붙인다. 이때 원소 사이에 구분자(separator)를 추가하고, StringBuilder의 맨 앞과 맨 뒤에는 접두사(prefix)와 접미사(postfix)를 추가한다.

| joinToString() 함수의 초기 구현

fun <T> joinToString(
        collection: Collection<T>,
        separator: String,
        prefix: String,
        postfix: STring
) : String {
    val result = StringBuilder(prefix)
    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator) // 첫 원소 앞에는 구분자를 붙이면 안 된다.
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

이 함수는 제네릭이다. 즉, 이 함수는 어떤 타입의 값을 원소로 가진 컬렉션이든 처리할 수 있다. 제네릭 함수의 문법은 자바와 비슷하다.

이 함수가 의도대로 작동하는지 검증해보자.

>>> val list = listOf(1, 2, 3)
>>> println(joinToString(list, "; ", "(", ")"))
(1; 2; 3)

잘 작동한다. 이 함수를 그대로 써도 좋을 것이다. 하지만 선언 부분을 좀 더 고민해봐야 한다. 어떻게 하면 이 함수를 호출하는 문장을 더 간편하게 만드는 방법은 없을까? 매번 네 인자를 전달하지 않을 수는 없을까?

이름 붙인 인자

첫 번째 문제는 함수 호출 부분의 가독성이다.
예를 들어 다음과 같이 joinToString 호출을 살펴보자.

joinToString(collection, " ", " ", ".")

인자로 전달한 각 문자열이 어떤 역할을 하는지 구분할 수 있는가? (예르들어 원소는 공백으로 구분될까? 마침표로 구분될까?)
함수의 시그니처를 외우거나 IDE가 함수 시그니처를 표시해서 도움을 줄 수는 있겠지만, 함수 호출 코드 자체는 여전히 모호하다.

이런 문제는 특히 불리언 플래그(flag) 값을 전달해야 하는 경우 흔히 발생한다. 이를 해결하기 위해 일부 자바 코딩 스타일에서는 불리언 대신 enum 타입을 사용하라고 권장한다. 일부 코딩 스타일에서는 다음과 같이 파라미터 이름을 주석에 넣으라고 요구하기도 한다. (Lombok의 @Builder를 떠올리면 될 것 같다!)

joinToString(collection, /* separator */ " ", /* prefix */ " ", /* postfix */ ".");

코틀린에서는 다음과 같이 이름붙인 인자 기능을 제공한다.

joinToString(collection, separator = " ", prefix = " ", postfix = ".")

코틀린으로 작성한 함수를 호출할 때는 함수에 전달하는 인자 중 일부(또는 전부)의 이름을 명시할 수 있다. 호출 시 인자 중 어느 하나라도 이름을 명시하고 나면 혼동을 막기위해 그 뒤에 오는 모든 인자는 이름을 꼭 명시해야 한다.

이름 붙인 인자는 특히 다음 절에 살펴볼 디폴트 파라미터 값과 함께 사용할 때 쓸모가 많다.

디폴트 파라미터 값

자바에서는 일부 클래스에서 오버로딩(overloading)한 메서드가 너무 많아진다는 문제가 있다. java.lang.Thread에 있는 8가지 생성자를 살펴보라. 이런 식의 오버로딩 메서드들은 하위 호완성을 유지하거나 API 사용자에게 편의를 더하는 등의 여러 가지 이유로 만들어진다. 하지만 어느 경우든 중복이라는 결과는 같다. 파라미터 이름과 타입이 계속 반복되며, 우리가 친절한 개발자라면 모든 오버로딩 함수에 대해 대부분의 설명을 반복해 달아야 할 것이다. 그리고 인자 중 일부가 생략된 오버로드 함수를 호출할 때 어떤 함수가 불릴지 모호한 경우가 생긴다.

코틀린에서는 함수 선언에서 파라미터의 디폴트 값을 지정할 수 있으므로 이런 오버로드 중 상당수를 피할 수 있다. 디폴트 값을 사용해 joinToString 함수를 개선해보자. 대부분의 경우 아무 접두사나 접미사 없이 콤마로 원소를 구분한다. 따라서 그런 값을 디폴트로 지정하자.

디폴트 파라미터 값을 사용해 joinToString() 정의하기

fun <T> joinToString(
    collection: Collection<T>,
    separator: String = ", ",
    prefix: String = ""
) : String

이제 함수를 호출할 때 모든 인자를 쓸 수도 있고, 일부를 생략할 수도 있다.

>>> joinToSTring(list, ", ", "", "")
1, 2, 3

>>> joinToString(list) // separator, prefix, postfix 생략
1, 2, 3

>>> joinToString(list, "; ") // separator를 "; "로 지정, prefix, postfix 생략 
1; 2; 3

일반 호출 문법을 사용하려면 함수를 선언할 때와 같은 순서로 인자를 지정해야 한다. 그런 경우 일부를 생략하면 뒷부분의 인자들이 생략된다. 이름 붙인 인자를 사용하는 경우에는 인자 목록의 중간에 있는 인자를 생략하고, 지정하고 싶은 인자만 이름을 붙여서 순서와 관계없이 지정할 수 있다.

>>> joinToString(list, postfix = ";", prefix = "# ")
# 1, 2, 3;

함수의 디폴트 파라미터 값은 함수를 호출하는 쪽이 아니라 함수 선언 쪽에서 지정된다는 사실을 기억하라. 따라서 어떤 클래스 안에 정의된 디폴트 값을 바꾸고 그 클래스가 포함된 파일을 재컴파일하면 그 함수를 호출하는 코드 중에 값을 지정하지 않은 모든 인자는 자동으로 바뀐 디폴트 값을 적용받는다.

디폴트 값과 자바
자바에서는 디폴트 파라미터 값이라는 개념이 없어서 코틀린 함수를 자바에서 호출하는 경우에는 그 코틀린 함수가 디폴트 파라미터 값을 제공하더라도 모든 인자를 명시해야 한다. 자바에서 코틀린 함수를 자주 호출해야 한다면 자바 쪽에서 좀 더 편하게 코틀린 함수를 호출하고 싶을 것이다. 그럴 때 @JvmOverloads 애너테이션을 함수에 추가할 수 있다. @JvmOverloads를 함수에 추가하면 코틀린 컴파일러가 자동으로 맨 마지막 파라미터로부터 파라미터를 하나씩 생략한 오버로딩한 자바 메서드를 추가해준다.

예를들어 joinToStringdp @JvmOverloads를 붙이면 다음과 같은 오버로딩한 함수가 만들어진다.

String joinToString(Collection<T> collection, String separator, String prefix, String postfix);

String joinToString(Collection<T> collection, String separator, String prefix);

String joinToString(Collection<T> collection, String separator);

String joinToString(Collection<T> collection);

각각의 오버로딩한 함수들은 시그니처에서 생략된 파라미터에 대해 코틀린 함수의 디폴트 파라미터 값을 사용한다.

지금까지는 함수를 사용할 때 그 함수를 선언하는 시점의 주위 환경을 신경쓰지 않았다. 지금까지 설명한 함수들은 어떤 클래스 안에 선언해야만 할 것이다. 그러나 실제로 코틀린에서는 함수를 클래스 안에 선언할 필요가 전혀 없다.

정적인 유틸리티 클래스 없애기: 최상위 함수와 프로퍼티

자바를 아는 사람은 객체지향 언어인 자바에서는 모든 코드를 클래스의 메서드로 작성해야 한다는 사실을 알고 있다. 보통 그런 구조는 잘 작동한다. 하지만 실전에서는 어느한 클래스에 포함시키기 어려운 코드가 많이 생긴다. 일부 연산에는 비슷하게 중요한 역할을 하는 클래스가 둘 이상 있을 수도 있다. 중요한 객체는 하나뿐이지만 그 연산을 객체의 인스턴스 API에 추가해서 API를 너무 크게 만들고 싶지는 않은 경우도 있다.

그 결과 다양한 정적 메서드를 모아두는 역할만 담당하며, 특별한 상태나 인스턴스 메서드가 없는 클래스가 생겨난다. JDK의 Collections 클래스가 전형적인 예다. 우리가 작성한 코드에서 비슷한 예를 보고 싶다면 Util이 이름에 들어있는 클래스를 찾으면 된다.

코틀린에서는 이런 무의미안 클래스가 필요 없다. 대신 함수를 직접 소스파일의 최상위 수준, 모든 다른 클래스의 밖에 위치시키면 된다. 그런 함수들은 여전히 그 파일의 맨 앞에 정의된 패키지의 멤버 함수이므로 다른 패키지에서 그 함수를 사용하고 싶을 때는 그 함수가 정의된 패키지를 임포트해야만 한다. 하지만 임포트 시 유틸리티 클래스 이름이 추가로 들어갈 필요는 없다.

joinToString 함수를 strings 패키지에 직접 넣어보자. join.kt라는 파일을 다음과 같이 작성하라.

JoinToString 함수를 최상위 함수로 선언하기

package strings

fun joinToString(...) : String { ... }

이 함수가 어떻게 실행될 수 있는 걸까? JVM이 클래스 안에 들어있는 코드만을 실행할 수 있기 때문에 컴파일러는 이 파일을 컴파일할 때 새로운 클래스를 정의해준다. 코틀린만 사용하는 경우에는 그냥 그런 클래스가 생긴다는 사실만 기억하면 된다. 하지만 이 함수를 자바 등의 다른 JVM 언어에서 호출하고 싶다면 코드가 어떻게 컴파일되는지 알아야 joinToString과 같은 최상위 함수를 사용할 수 있다. 어떻게 코틀린이 join.kt를 컴파일하는지 보여주기 위해 join.kt를 컴파일한 결과와 같은 클래스를 자바 코드로 써보면 다음과 같다.

package strings;

public class JoinKt {
    public static String joinToSTring(...) { ... }

코틀린 컴파일러가 생성하는 클래스의 이름은 최상위 함수가 들어있던 코틀린 소스 파일의 이름과 대응한다. 코틀린 파일의 모든 최상위 함수는 이 클래스의 정적인 메서드가 된다. 따라서 자바에서 joinToString을 호출하기는 쉽다.

import strings.JoinKt;
...

JoinKt.joinToString(list, ", ", "", "");

파일에 대응하는 클래스의 이름 변경하기
코틀린 최상위 함수가 포함되는 클래스의 이름을 바꾸고 싶다면 파일에 @JvmName 애너테이션을 추가하라. @JvmName 애너테이션은 파일의 맨 앞, 패키지 이름 선언 이전에 위치해야 한다.

@file:JvmName("StringFunctions") // 클래스 이름을 지정하는 애너테이션 

package strings // @file:JvmName 애너테이션 뒤에 패키지 문이 와야한다. 

fun joinToString(...) : String { ... }

이제 다음과 같이 joinToString 함수를 호출할 수 있다.

import strings.StringFunctions;

StringFunctions.joinToString(list, ", ", "", "");

(@JvmName 애너테이션 문법에 대해서는 10장에서 설명한다)

최상위 프로퍼티

함수와 마찬가지로 프로퍼티도 파일의 최상위 수준에 놓을 수 있다. 어떤 데이터를 클래스 밖에 위치시켜야 하는 경우는 흔하지는 않지만, 그래도 가끔 유용할 때가 있다. 예를 들어 어떤 연산을 수행한 횟수를 저장하는 var 프로퍼티를 만들 수 있다.

var opCount = 0  // 최상위 프로퍼티를 선언한다. 

fun performOperation() {
    opCount++ // 최상위 프로퍼티의 값을 변경한다. 
    // ...
}

fun reportOperationCount() {
    println("Operation performed $opCount times") // 최상위 프로퍼티의 값을 읽는다. 
}

이런 프로퍼티의 값은 정적 필드에 저장된다.

최상위 프로퍼티를 활용해 코드에 상수를 추가할 수 있다.

val UNIX_LINE_SEPARATOR = "\n"

기본적으로 최상위 프로퍼티도 다른 모든 프로퍼티처럼 접근자 메서드를 통해 자바 코드에 노출된다(val의 경우 게터, var의 경우 게터, 세터). 겉으론 상수처럼 보이는데, 실제로는 게터를 사용해야 한다면 자연스럽지 못하다. 더 자연스럽게 사용하려면 이 상수를 public static final 필드로 컴파일해야 한다. const 변경자를 추가하면 프로퍼티를 public static final 필드로 컴파일하게 만들 수 있다(단, 원시 타입과 String 타입의 프로퍼티만 const로 지정할 수 있다).

const val UNIX_LINE_SEPARATOR = "\n"

앞의 코드는 다음 자바 코드와 동등한 바이트코드를 만들어낸다.

public static final String UNIX_LINE_SEPARATOR = "\n";

메서드를 다른 클래스에 추가: 확장 함수와 확장 프로퍼티

기존 코드와 코틀린 코드를 자연스럽게 통합하는 것은 코틀린의 핵심 목표 중 하나다.
완전히 코틀린으로만 이뤄진 프로젝트조차도 JDK나 안드로이드 프레임워크 또는 다른 서드파티 프레임워크 등의 자바 라이브러리를 기반으로 만들어진다. 또 코틀린을 기존 자바 프로젝트에 통합하는 경우에는 코틀린으로 직접 변환할 수 없거나 미처 변환하지 않은 기존 자바 코드를 처리할 수 있어야 한다. 이런 기존 자바 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 사용할 수 있다면 정말 좋은 일 아닐까? 바로 확장 함수(extension function)가 그런 역할을 해줄 수 있다.

개념적으로 확장 함수는 단순하다. 확장 함수는 어떤 클래스의 멤버 메서드인 것처럼 호출할 수 있지만 그 클래스의 밖에 선언된 함수다. 확장 함수를 보여주기 위해 어떤 문자열의 마지막 문자를 돌려주는 메서드를 추가해보자.

package strings

fun String.lastChar(): Char = this.get(this.length - 1)

확장 함수를 만들려면 추가하려는 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 덧붙이기만 하면 된다. 클래스 이름을 수신 객체 타입(receiver type)이라 부르며, 확장 함수가 호출되는 대상이 되는 값(객체)을 수신 객체(receiver object)라고 부른다.

예를 들어 위의 코드의 경우 String: '수신 객체 타입', this: '수신 객체' 가 된다.
수신 객체의 타입은 확장이 정의될 클래스의 타입이며, 수신 객체는 그 클래스에 속한 인스턴스 객체다.

이 함수를 호출하는 구문은 다른 일반 클래스 멤버를 호출하는 구문과 똑같다.

>>> println("Kotlin".lastChar())

이 예제에서는 String이 수신 객체 타입이고 "Kotlin"이 수신 객체다.
어떤 면에서 이는 String 클래스에 새로운 메서드를 추가하는 것과 같다. String 클래스가 우리가 직접 작성한 코드가 아니고 심지어 String 클래스의 소스코드를 소유한 것도 아니지만, 우리는 여전히 원하는 메서드를 String 클래스에 추가할 수 있다. 심지어 String이나 자바나 코틀린 등의 언어 중 어떤 것으로 작성됐는가는 중요하지 않다.

일반 메서드의 본문에서 this를 사용할 때와 마찬가지로 확장 함수 본문에도 this를 쓸 수 있다.

package strings

fun String.lastChar(): Char = get(legnth - 1) // 수신 객체 멤버에 this 없이 접근할 수 있다.

확장 함수 내부에서는 일반적인 인스턴스 메서드의 내부에서와 마찬가지로 수신 객체의 메서드나 프로퍼티를 바로 사용할 수 있다. 하지만 확장 함수가 캡슐화를 깨지는 않는다는 사실을 기억하라. 클래스 안에서 정의한 메서드와 달리 확장 함수 안에서는 클래스 내부에서만 사용할 수 있는 비공개(private) 멤버나 보호된(protected) 멤버를 사용할 수 없다.

이제부터는 클래스의 멤버 메서드와 확장 함수를 모두 메서드라고 부를 것이다. 호출하는 쪽에서는 확장 함수와 멤버 메서드를 구분할 수 없다. 그리고 호출하는 메서드가 확장함수인지 멤버 메서드인지 여부가 중요한 경우도 거의 없다.

임포트와 확장 함수

확장 함수를 정의했다고 해도 자동으로 프로젝트 안의 모든 소스코드에서 그 함수를 사용할 수 있지는 않다. 확장 함수를 사용하기 위해서는 그 함수를 다른 클래스나 함수와 마찬가지로 임포트해야만 한다. 확장 함수를 정의하자마자 어디서든 그 함수를 쓸 수 있다면 한 클래스에 같은 이름의 확장 함수가 둘 이상 있어서 이름이 충돌하는 경우가 자주 생길 수 있다. 코틀린에서는 클래스를 임포트할 때와 동일한 구문을 사용해 개별 함수를 임포트할 수 있다.

import strings.lastChar

val c = "Kotlin".lastChar()

물론 *를 사용한 임포트도 잘 작동한다.

as 키워드를 사용하면 임포트한 클래스나 함수를 다른 이름으로 부를 수 있다.

import strings.lastChar as last

val c = "Kotlin".last()

한 파일 안에서 다른 여러 패키지에 속해있는 이름이 같은 함수를 가져와 사용해야 하는 경우 이름을 바꿔서 임포트하면 이름 충돌을 막을 수 있다. 물론 일반적인 클래스나 함수라면 그 전체 이름(FQN, Full Qualifed Name)을 써도 된다. 하지만 코틀린 문법상 확장 함수는 반드시 짧은 이름을 써야 한다. 따라서 임포트할 때 이름을 바꾸는 것이 확장 함수 이름 충돌을 해결할 수 있는 유일한 방법이다.

자바에서 확장 함수 호출

내부적으로 확장 함수는 수신 객체를 첫 번째 인자로 받는 정적 메서드다. 그래서 확장 함수를 호출해도 다른 어댑터(adapter) 객체나 실행 시점 부가 비용이 들지 않는다. 이런 설계로 인해 자바에서는 확장 함수를 사용하기도 편하다. 단지 정적 메서드를 호출하면서 첫 번째 인자로 수신 객체를 넘기기만 하면 된다. 다른 최상위 함수와 마찬가지로 확장 함수가 들어있는 자바 클래스 이름도 확장 함수가 들어있는 파일 이름에 따라 결정된다. 따라서 확장 함수를 StringUtil.kt 파일에 정의했다면 다음과 같이 호출할 수 있다.

/* 자바 */
char c = StringUtilKt.lastChar("Java");

확장 함수로 유틸리티 함수 정의

이제 joinToString 함수의 최종 버전을 만들자. 이제 이 함수는 코틀린 라이브러리가 제공하는 함수와 거의 같아졌다.

joinToString()를 확장으로 정의하기

fun <T> Collection<T>.joinToString( // Collection<T>에 대한 확장 함수를 선언한다. 
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
): String (
    val result = StringBuilder(prefix)

    for ((index, element) in this.withIndex())
        if (index > 0) result.append(separator)
        result.append(element)
    }
    result.append(postfix)
    return result.toString()
}

>>> val list = listOf(1, 2, 3)
>>> println(list.joinToString(separator = "; ",
...      prefix = "(", postfix = ")"))
(1; 2; 3)

원소로 이뤄진 컬렉션에 대한 확장을 만든다. 그리고 모든 인자에 대한 디폴트 값을 지정한다. 이제 joinToString을 마치 클래스의 멤버인 것처럼 호출할 수 있다.

>>> val list = arrayListOf(1, 2, 3)
>>> println(list.joinToSTring(" "))
1 2 3

확장 함수는 단지 정적 메서드 호출에 대한 문법적인 편의(syntatic sugar)일 뿐이다. 그래서 클래스가 아닌 더 구체적인 타입을 수신 객체 타입으로 지정할 수도 있다. 그래서 문자열의 컬렉션에 대해서만 호출할 수 있는 join 함수를 정의하고 싶다면 다음과 같이 하면 된다.

fun Collection<String>.join(
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
) = joinToString(separator, prefix, postfix)

>>> println(listOf("one", "two", "eight").join(" "))
one two eight

이 함수를 객체의 리스트에 대해 호출할 수는 없다.

확장 함수가 정적 메서드와 같은 특징을 가지므로, 확장 함수를 하위 클래스에서 오버라이드 할 수는 없다.

확장 함수는 오버라이드할 수 없다.

코틀린의 메서드 오버라이드도 일반적인 객체지향의 메서드 오버라이드와 마찬가지다. 하지만 확장 함수는 오버라이드 할 수 없다. View와 그 하위 클래스인 Button이 있는데, Button이 상위 클래스의 click 함수를 오버라이드하는 경우를 생각해보자.

open class View {
    open fun click() = println("View clicked")
}

class Button: View() { // Button은 View를 확장한다 
    override fun click() = println("Button clicked")
}

Button이 View의 하위 타입이기 때문에 View 타입 변수를 선언해도 Button 타입 변수를 그 변수에 대입할 수 있다. View 타입 변수에 대해 click과 같은 일반 메서드를 호출했는데, click을 Button 클래스가 오버라이드했다면 실제로는 Button이 오버라이드한 click이 호출된다.

>>> val view: View = Button()
>>> view.click() // "view"에 저장된 값의 실제 타입에 따라 호출할 메서드가 결정된다. 
Button clicked

하지만 확장은 이런 식으로 동작하지 않는다. 확장 함수는 클래스의 일부가 아니다. 확장 함수는 클래스 밖에 선언된다. 이름과 파라미터가 완전히 같은 확장 함수를 기반 클래스와 하위 클래스에 대해 정의해도 실제로는 확장 함수를 호출할 때 수신 객체로 지정한 변수의 정적 타입에 의해 어떤 확장함수가 호출될지 결정되지, 그 변수에 저장된 객체의 동적인 타입에 의해 확장 함수가 결정되지 않는다.

다음 예제는 View와 Button 클래스에 대해 선언된 두 showOff() 확장 함수를 보여준다.

확장 함수는 오버라이드할 수 없다.

fun View.showOff() = println("I'm a view!")
fun Button.showOff() = println("I'm a button")

>>> >>> val view: View = Button()
>>> view.showOff() // 확장 함수는 정적으로 결정된다. 
I'm a view!

view가 가리키는 객체의 실제 타입이 Button이지만, 이 경우 view의 타입이 View이기 때문에 무조건 View의 확장 함수가 호출된다.

확장 함수를 첫 번째 인자가 수신 객체인 정적 자바 메서드로 컴파일한다는 사실을 기억한다면 이런 동작을 쉽게 이해할 수 있다. 자바도 호출할 정적(static) 함수를 같은 방식으로 정적으로 결정한다.

/* 자바 */
>>> View view = new Button();
>>> ExtensionsKt.showOff(view); // showOff 함수를 extensions.kt 파일에 정의했다.
I'm a view!

위 예제와 같이 확장 함수를 오버라이들할 수는 없다. 코틀린은 호출될 확장 함수를 정적으로 결정하기 때문이다.

어떤 클래스를 확장함 함수와 그 클래스의 멤버 함수의 이름과 시그니처가 같다면 확장 함수가 아니라 멤버 함수가 호출된다(멤버 함수의 우선순위가 더 높다). 클래스의 API를 변경할 경우 항상 이를 염두에 둬야 한다. 우리가 코드 소유권을 가진 클래스에 대한 확장 함수를 정의해서 사용하는 외부 클라이언트 프로젝트가 있다고 하자. 그 확장 함수와 이름과 시그니처가 같은 멤버 함수를 우리의 클래스 내부에 추가하면 클라이언트 프로젝트를 재컴파일한 순간부터 그 클라이언트는 확장 함수가 아닌 새로 추가된 멤버 함수를 사용하게 된다.

확장 프로퍼티

확장 프로퍼티를 사용하면 기존 클래스 객체에 대한 프로퍼티 형식의 구문으로 사용할 수 있는 API를 추가할 수 있다. 프로퍼티라는 이름으로 불리기는 하지만 상태를 저장할 적절한 방법이 없기 때문에 실제로 확장 프로퍼티는 아무 상태도 가질 수 없다. 하지만 프로퍼티 문법으로 더 짧게 코드를 작성할 수 있어서 편한 경우가 있다.

앞 절에서 lastChar라는 함수를 정의했다. 이제 그 함수를 프로퍼티로 바꾸자.

확장 프로퍼티 선언하기

val String.lastChar: Char
    get() = get(length - 1)

확장 함수의 경우와 마찬가지로 확장 프로퍼티도 일반적인 프로퍼티와 같은데, 단지 수신 객체 클래스가 추가됐을 뿐이다. 뒷받침하는 필드가 없어서 기본 게터 구현을 제공할 수 없으므로 최소한 게터는 꼭 정의를 해야 한다. 마찬가지로 초기화 코드에서 계산한 값을 담을 장소가 전혀 없으므로 초기화 코드도 쓸 수 없다.

StringBuilder에 같은 프로퍼티를 정의한다면 StringBuilder의 맨 마지막 문자는 변경 가능하므로 프로퍼티를 var로 만들 수 있다.

변경 가능한 확장 프로퍼티 선언하기

var StringBuilder.lastChar: Char 
    get() = get(length - 1) // 프로퍼티의 게터 
    set(value: Char) {
        this.setCharAt(length - 1, value) // 프로퍼티의 세터
}

확장 프로퍼티를 사용하는 방법은 멤버 프로퍼티를 사용하는 방법과 같다.

>>> println("Kotlin".lastChar)
n
>>> val sb = StringBuilder("Kotlin?")
>>> sb.lastChar = '!'
>>> println(sb)
Kotlin!

자바에서 확장 프로퍼티를 사용하고 싶다면 항상 StringUiltKt.getLastChar("Java") 처럼 게터나 세터를 명시적으로 호출해야 한다.

지금까지 확장에 대해 전반적으로 다뤘다. 이제는 컬렉션이라는 주제로 돌아가서 컬렉션을 처리할 때 유용한 라이브러리 함수를 몇 가지 살펴본다.

컬렉션 처리: 가변 길이 인자, 중위 함수 호출, 라이브러리 지원

컬렉션을 처리할 때 쓸 수 있는 코틀린 표준 라이브러리 함수 몇 가지를 보여준다. 그 과정에서 다음과 같은 코틀린 언어 특성을 설명한다.

• vararg 키워드를 사용하면 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있다.
• 중위(infix) 함수 호출 구문을 사용하면 인자가 하나뿐인 메서드를 간편하게 호출할 수 있다.
• 구조 분해 선언(destructuring declaration)을 사용하면 복합적인 값을 분해해서 여러 변수에 나눠 담을 수 있다.

자바 컬렉션 API 확장

맨 앞부분에서 코틀린 컬렉션은 자바와 같은 클래스를 사용하지만 더 확장된 API를 제공한다고 언급했었다. 그리고 리스트의 마지막 원소를 가져오는 예제와 숫자로 이뤄진 컬렉션의 최댓값을 찾는 예제를 살펴봤다.

>>> strings.last()
fourteenth
>>> val numbers: Collection<Int> = setOf(1, 14, 2)
>>> numbers.max()
14

이런 코드가 어떻게 작동할 수 있는지 궁금했을 것이다. 어떻게 자바 라이브러리 클래스의 인스턴스인 컬렉션에 대해 코틀린이 새로운 기능을 추가할 수 있을까? 이제 우리는 그 답을 명확히 안다. last와 max는 모두 확장 함수였던 것이다.

last 함수는 앞 절에서 String에 대해 정의했던 lastChar보다 복잡하지 않다.
last는 List 클래스의 확장 함수다. max의 경우에는 더 단순하게 정리한 선언을 살펴봤다.

fun <T> List<T>.last(): T (/* 마지막 원소를 반환함 */}
fun Collection<Int>.max(): Int {/*컬렉션의 최댓값을 찾음 */}

코틀린 표준 라이브러리는 수많은 확장 함수를 포함하므로 여기서 그들을 모두 나열하지는 않을 것이다. 코틀린 표준 라이브러리의 기능을 전부 다 배우는 가장 좋은 방법이 무엇인지 궁금할 수 있지만 코틀린 표준 라이브러리를 모두 다 알 필요는 없다. 컬렉션이나 다른 객체에 대해 사용할 수 있는 메서드나 함수가 무엇인지 궁금할 때마다 IDE의 코드 완성 기능을 통해 그런 메서드나 함수를 살펴볼 수 있다.

IDE가 표시해주는 목록에서 원하는 함수를 선택하기만 하라. 추가로 표준 라이브러리 참조 매뉴얼을 살펴보면 각 라이브러리 클래스가 제공하는 모든 메서드(멤버 메서드와 확장 함수)를 볼 수 있다.

가변 인자 함수: 인자의 개수가 달라질 수 있는 함수 정의

리스트를 생성하는 함수를 호출할 때 원하는 만큼 많이 원소를 전달할 수 있다.

val list = listOf(2, 3, 5, 7, 11)

라이브러리에서 이 함수의 정의를 보면 다음과 같다.

fun listOf<T>(vararg values: T): List<T> { ... }

자바의 가변 길이 인자(varargs)에 익숙한 사람도 많을 것이다. 가변 길이 인자는 메서드를 호출할 때 원하는 개수만큼 값을 인자로 넘기면 자바 컴파일러가 배열에 그 값들을 넣어주는 기능이다. 코틀린의 가변 길이 인자도 자바와 비슷하다. 다만 문법이 조금 다르다. 타입 뒤에 ...를 붙이는 대신 코틀린에서는 파라미터 앞에 vararg 변경자를 붙인다.

이미 배열에 들어있는 원소를 가변 길이 인자로 넘길 때도 코틀린과 자바 구문이 다르다. 자바에서는 배열을 그냥 넘기면 되지만 코틀린에서는 배열을 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 해야 한다. 기술적으로는 스프레드 연산자가 그런 작업을 해준다. 하지만 실제로는 전달하려는 배열 앞에 *를 붙이기만 하면 된다.

fun main(args: Array<String>) {
    val list = listOf("args: ", *args) // 스프레드 연산자가 배열의 내용을 펼쳐준다. 
    println(list)
}

이 예제는 스프레드 연산자를 통하면 배열에 들어있는 값과 다른 여러 값을 함께 써서 함수를 호출할 수 있음을 보여준다. 이런 기능은 자바에서는 사용할 수 없다. 이제 맵으로 대상을 옮겨서 코틀린 함수 호출의 가독성을 향상시킬 수 있는 다른 방법인 중위 호출에 대해 살펴보자.

값의 쌍 다루기: 중위 호출과 구조 분해 선언

맵을 만들려면 mapOf 함수를 사용한다.

val map = mapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

여기서 to라는 단어는 코틀린 키워드가 아니다. 이 코드는 중위 호출(infix call)이라는 특별한 방식으로 to라는 일반 메서드를 호출한 것이다.
중위 호출 시에는 수신 객체와 유일한 메서드 인자 사이에 메서드 이름을 넣는다(이때 객체, 메서드 이름, 유일한 인자 사이에는 공백이 들어가야 한다).
다음 두 호출은 동일하다.

1.to("one") // "to" 메서드를 일반적인 방식으로 호출함
1 to "one" // "to" 메서드를 중위 호출 방식으로 호출함 

인자가 하나뿐인 일반 메서드나 인자가 하나뿐인 확장 함수에 중위 호출을 사용할 수 있다.
함수(메서드)를 중위 호출에 사용하게 허용하고 싶으면 infix 변경자를 함수(메서드) 선언 앞에 추가해야 한다. 다음은 to 함수의 정의를 간략하게 줄인 코드다.

infix fun Any.to(other: Any) = Pair(this, other)

이 to 함수는 Pair의 인스턴스를 반환한다. Pair는 코틀린 표준 라이브러리 클래스로, 그 이름대로 두 원소로 이뤄진 순서쌍을 표현한다. (실제로 to는 제네릭 함수다)

Pair의 내용으로 두 변수를 즉시 초기화할 수 있다.

val (number, name) = 1 to "one"

이런 기능을 구조 분해 선언(desrtucturing declaration)이라고 부른다.
Pair 인스턴스 외 다른 객체에도 구조 분해를 적용할 수 있다. 예를 들어 key와 value라는 두 변수를 맵의 원소를 사용해 초기화할 수 있다.

루프에서도 구조 분해 선언을 활용할 수 있다. joinToString에서 본 withIndex를 구조 분해 선언과 조합하면 컬렉션 원소의 인덱스의 값을 따로 변수에 담을 수 있다.

for ((index, element) in collection.withIndex()) {
    println("$index: $element")
}

to 함수는 확장 함수다. to를 사용하면 타입과 관계없이 임의의 순서쌍을 만들 수 있다. 이는 to의 수신 객체가 제네릭하다는 뜻이다. 1 to "one", "one" to 1, list to list.size() 등의 호출이 모두 잘 작동한다. mapOf 함수의 선언을 살펴보자.

fun <K,V> mapOf(vararg values: Pair<K, V>) : Map<K, V>

listOf와 마찬가지로 mapOf에도 원하는 개수만큼 인자를 전달할 수 있다. 하지만 mapOf의 경우에는 각 인자가 키와 값으로 이뤄진 순서쌍이어야 한다.

코틀린을 잘 모르는 사람이 보면 새로운 맵을 만드는 구문은 코틀린이 맵에 대해 제공하는 특별한 문법인 것처럼 느낄 수 있다. 하지만 실제로는 일반적인 함수를 더 간결한 구문으로 호출하는 것 뿐이다. 이제는 확장을 통해 문자열과 정규식을 더 편리하게 다루는 방법을 살펴본다.

문자열과 정규식 다루기

코틀린 문자열은 자바 문자열과 같다. 코틀린 코드가 만들어낸 문자열을 아무 자바 메서드에 넘겨도 되며, 자바 코드에서 받은 문자열을 아무 코틀린 표준 라이브러리 함수에 전달해도 문제없다. 특별한 변환도 필요 없고 자바 문자열을 감싸는 별도의 래퍼(wrapper)도 생기지 않는다.

코틀린은 다양한 확장 함수를 제공함으로써 표준 자바 문자열을 더 즐겁게 다루게 해준다. 또한 혼동이 야기될 수 있는 일부 메서드에 대해 더 명확한 코틀린 확장 함수를 제공함으로써 프로그래머의 실수를 줄여준다. 자바와 코틀린 API의 차이를 알아보기위한 첫 번째 예제로 문자열을 구분 문자열에 따라 나누는 작업을 코틀린에서 어떻게 처리하는지 살펴보자.

문자열 나누기

자바 개발자라면 String의 split 메서드를 잘 알고 있을 것이다. 모든 자바 개발자가 그 메서드를 사용하지만 불만을 표시하는 사람도 있다. 스택 오버플로우 질문 중에는 "자바 split 메서드로는 점(.)을 사용해 문자열을 분리할 수 없습니다." 라는 질문이 있다. "12.345-6.A".split(".") 라는 호출의 결과가 [12, 345-6, A] 배열이라고 생각하는 실수를 저지르는 개발자가 많다. 하지만 자바의 split 메서드는 빈배열을 반환한다! split의 구분 문자열을 실제로는 정규식(regular expression)이기 때문이다. 따라서 마침표(.)는 모든 문자를 나타내는 정규식으로 해석된다.

코틀린에서는 자바의 split 대신에 여러 가지 다른 조합의 파라미터를 받는 split 확장 함수를 제공함으로써 혼동을 야기하는 메서드를 감춘다. 정규식을 파라미터로 받는 함수는 String이 아닌 Regex 타입의 값을 받는다. 따라서 코틀린에서는 split 함수에 전달하는 값의 타입에 따라 정규식이나 일반 텍스트 중 어느 것으로 문자열을 분리하는지 쉽게 알 수 있다.

다음 코드는 마침표나 대시(-)로 문자열을 분리하는 예를 보여준다.

>>> println("12.345-6.A".split("//.|-".toRegex())) // 정규식을 명시적으로 만든다. 
[12, 345, 6, A]

코틀린 정규식 문법은 자바와 똑같다. 여기 있는 패턴은 마침표나 대시와 매치된다(정규식 안에서 마침표가 와일드카드 문자가 아닌 문자 자체로 쓰이게 하기 위해 마침표를 이스케이프 시켰다). 정규식을 처리하는 API는 표준 자바 라이브러리 API와 비슷하지만 좀 더 코틀린답게 변경됐다. 예를 들어 코틀린에서는 toRegex 확장 함수를 사용해 문자열을 정규식으로 변환할 수 있다.

이런 간단한 경우에는 꼭 정규식을 쓸 필요가 없다. split 확장 함수를 오버로딩한 버전 중에는 구분 문자열을 하나 이상 인자로 받는 함수가 있다.

>>> println("12.345-6.A".split(".", "-")) // 여러 구분 문자열을 지정한다. 
[12, 345, 6, A]

이 경우 "12.345-6.A".split('.', '-')처럼 문자열 대신 문자를 인자로 넘겨도 마찬가지 결과를 볼 수 있다. 이렇게 여러 문자를 받을 수 있는 코틀린 확장 함수는 자바에 있는 단 하나의 문자만 받을 수 있는 메서드를 대신한다.

정규식과 3중 따옴표로 묶은 문자열

다른 예로 두 가지 구현을 만들어보자. 첫 번째 구현은 String을 확장한 함수를 사용하고 두 번째 구현은 정규식을 사용한다. 우리가 할 일은 파일의 전체 경로명을 디렉터리, 파일 이름, 확장자로 구분하는 것이다. 코틀린 표준 라이브러리에는 어떤 문자열에서 구분 문자열이 맨 나중(또는 처음)에 나타난 곳 뒤(또는 앞)의 부분 문자열을 반환하는 함수가 있다. 이런 함수를 사용해 경로 파싱을 구현한 버전은 다음고 같다.

"/Users/yole/kotlin-book/chapter.adoc"
디렉터리: "/Users/yole/kotlin-book"
파일 이름: "chapter"
확장자: "adoc"

String 확장 함수를 사용해 경로 파싱하기

fun parsePath(path: String) {
    val directory = path.substringBeforeLast("/")
    val fullName = path.substringAfterLast("/")

    val fileName = "fullName.subStringBeforeLast(".")
    val extension = "fullName.substringAfterLast(".")

    println("Dir: $directory, name: $fileName, ext: $extension")
}
>>> parsePath("/Users/yole/kotlin-book/chapter.adoc")
Dir: /Users/yole/kotlin-book, name: chapter, ext: adoc

path에서 처음부터 마지막 슬래시 직전까지의 부분 문자열은 파일이 들어있는 디렉터리 경로다. path에서 마지막 마침표 다음부터 끝까지의 부분 문자열은 파일 확장자다. 파일 이름은 그 두 위치 사이에 있다.

코틀린에서는 정규식을 사용하지 않고도 문자열을 쉽게 파싱할 수 있다. 정규식은 강력하기는 하지만 나중에 알아보기 힘든 경우가 많다. 정규식이 필요할 때는 코틀린 라이브러리를 사용하면 더 편하다. 다음과 같은 작업을 정규식을 활용해 구현한 프로그램이다.

경로 파싱에 정규식 사용하기

fun parsePath(path: String) {
    val regex = """(.+)/(.+)\.(.+)""".toRegex()
    val matchResult = regex.matchEntire(path)
    if (matchResult != null) {
        val (directory, filename, extension) = matchResult.destructured
        println("Dir: $directory, name: $filename, ext: $extension")
    }
}

이 예에제어는... (p 132)