inline 함수와 reified — 람다의 성능 비용을 없애는 방법

// 이 고차 함수를 호출할 때마다...
fun performOperation(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

// ... 람다는 Function1 객체로 변환된다
performOperation(5) { it * 2 }

// 바이트코드 수준에서 일어나는 일 (개념적 설명)
performOperation(5, new Function1<Integer, Integer>() {
    @Override
    public Integer invoke(Integer it) {
        return it * 2;
    }
});

inline fun performOperation(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

// 호출
val result = performOperation(5) { it * 2 }

// 인라이닝 결과 — 함수 호출도 없고, Function 객체도 없다
val result = 5 * 2   // 직접 삽입됨

// 이 함수들은 모두 inline
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
public inline fun <T> T.let(block: (T) -> R): R
public inline fun <T> T.apply(block: T.() -> Unit): T

inline fun forEach(items: List<Int>, action: (Int) -> Unit) {
    for (item in items) {
        action(item)
    }
}

fun findFirstNegative(numbers: List<Int>): Int? {
    forEach(numbers) { num ->
        if (num < 0) return num   // findFirstNegative를 반환! (비지역 반환)
    }
    return null
}

// inline이 아닌 함수의 람다에서는 비지역 반환 불가
fun nonInlineForEach(items: List<Int>, action: (Int) -> Unit) {
    for (item in items) {
        action(item)
    }
}

fun test(numbers: List<Int>) {
    nonInlineForEach(numbers) { num ->
        // if (num < 0) return  // 컴파일 에러!
        if (num < 0) return@nonInlineForEach  // 레이블 반환만 가능
    }
}

inline fun execute(
    inlinedAction: () -> Unit,
    noinline storedAction: () -> Unit  // 이 람다는 인라이닝하지 않음
) {
    inlinedAction()

    // 인라이닝된 람다는 변수에 저장하거나 다른 함수에 전달할 수 없다
    // val saved = inlinedAction  // 컴파일 에러!

    // noinline 람다는 가능
    val saved = storedAction      // OK — Function 객체로 존재
    someOtherFunction(saved)      // OK — 다른 함수에 전달 가능
}

inline fun runInThread(crossinline action: () -> Unit) {
    // action이 다른 람다(Runnable) 내부에서 실행됨
    Thread(Runnable {
        action()   // crossinline 덕분에 인라이닝 가능
    }).start()
}

fun test() {
    runInThread {
        println("다른 스레드에서 실행")
        // return  // 컴파일 에러! crossinline은 비지역 반환 금지
    }
}

// 일반 제네릭 — 런타임에 타입 정보 없음
fun <T> isType(value: Any): Boolean {
    // return value is T  // 컴파일 에러! T의 타입을 알 수 없음
    return false
}

// reified — 런타임에 타입 정보 유지
inline fun <reified T> isType(value: Any): Boolean {
    return value is T     // OK!
}

println(isType<String>("hello"))  // true
println(isType<Int>("hello"))     // false

// 소스 코드
inline fun <reified T> check(value: Any) = value is T
check<String>("hello")

// 인라이닝 후 (개념적)
"hello" is String   // T가 String으로 대체됨

// 1. 타입 검사
inline fun <reified T> filterByType(items: List<Any>): List<T> {
    return items.filterIsInstance<T>()
}

val mixed = listOf(1, "hello", 2, "world", 3.0)
val strings: List<String> = filterByType(mixed)  // ["hello", "world"]

// 2. 클래스 참조 얻기
inline fun <reified T> getClassName(): String {
    return T::class.simpleName ?: "Unknown"
}

println(getClassName<String>())  // "String"

// 3. Jackson/Gson 같은 라이브러리에서 활용
inline fun <reified T> String.fromJson(): T {
    return ObjectMapper().readValue(this, T::class.java)
}

val user = """{"name":"코틀린"}""".fromJson<User>()

// filterIsInstance — 특정 타입만 필터링
val items: List<Any> = listOf(1, "hello", 2.0, "world")
val strings = items.filterIsInstance<String>()  // ["hello", "world"]

// 내부 구현
public inline fun <reified R> Iterable<*>.filterIsInstance(): List<R> {
    return filterIsInstanceTo(ArrayList(), R::class.java)
}

// 나쁜 예 — 함수 본문이 크면 바이트코드 크기가 급증
inline fun bigFunction(action: () -> Unit) {
    // ... 수십 줄의 코드 ...
    action()
    // ... 수십 줄의 코드 ...
}

// bigFunction을 10곳에서 호출하면 → 본문이 10번 복사됨

class StringWrapper(private val value: String) {
    // getter를 인라이닝 — 함수 호출 오버헤드 제거
    inline val length: Int
        get() = value.length

    // backing field가 없는 프로퍼티에만 사용 가능
    // inline var name: String = ""  // 컴파일 에러! backing field가 있으면 불가
}