고차 함수와 람다 — 함수를 파라미터로 넘기는 코틀린의 방법

// 함수 타입 선언
val sum: (Int, Int) -> Int = { a, b -> a + b }
val isPositive: (Int) -> Boolean = { it > 0 }
val greet: () -> String = { "안녕하세요" }
val printMsg: (String) -> Unit = { println(it) }

// 수신 객체가 있는 함수 타입 (확장 함수 타입)
val toUpperCase: String.() -> String = { this.uppercase() }
"hello".toUpperCase()  // "HELLO"

// nullable 함수 타입
val callback: ((String) -> Unit)? = null
callback?.invoke("호출")  // null이면 실행 안 됨

// 함수 타입을 반환하는 함수
fun getOperation(type: String): (Int, Int) -> Int = when (type) {
    "add" -> { a, b -> a + b }
    "multiply" -> { a, b -> a * b }
    else -> { _, _ -> 0 }
}

// 함수를 파라미터로 받는 고차 함수
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 다양한 호출 방법
operate(3, 4, { a, b -> a + b })   // 7
operate(3, 4) { a, b -> a * b }    // 12 — trailing lambda

// 1. 콜백 패턴
fun fetchData(url: String, onSuccess: (String) -> Unit, onError: (Exception) -> Unit) {
    try {
        val data = /* HTTP 요청 */ "데이터"
        onSuccess(data)
    } catch (e: Exception) {
        onError(e)
    }
}

// 2. 전략 패턴
fun <T> List<T>.customSort(comparator: (T, T) -> Int): List<T> {
    return this.sortedWith(Comparator { a, b -> comparator(a, b) })
}

// 3. 리소스 관리 패턴
fun <T> withConnection(block: (Connection) -> T): T {
    val conn = getConnection()
    return try {
        block(conn)
    } finally {
        conn.close()
    }
}

// 전체 형태
val sum = { a: Int, b: Int -> Int
    a + b
}

// 타입 추론 가능하면 파라미터 타입 생략
val numbers = listOf(1, 2, 3, 4, 5)
numbers.filter({ num: Int -> num > 3 })  // 전체
numbers.filter({ num -> num > 3 })        // 타입 생략
numbers.filter({ it > 3 })               // it 사용
numbers.filter { it > 3 }                // trailing lambda

// 마지막 파라미터가 함수면 괄호 밖으로 뺄 수 있다
numbers.map { it * 2 }
numbers.filter { it > 3 }

// 람다가 유일한 인자면 괄호 자체를 생략
run { println("실행") }

// 여러 파라미터 중 마지막이 람다
numbers.fold(0) { acc, num -> acc + num }

// 파라미터가 하나면 이름을 생략하고 it으로 참조
numbers.filter { it > 3 }
numbers.map { it.toString() }

// 중첩 람다에서는 it이 헷갈리므로 이름을 명시하자
numbers.flatMap { num ->
    (1..num).map { multiplier ->  // it을 쓰면 어떤 it인지 혼란
        num * multiplier
    }
}

val map = mapOf("이름" to "코틀린", "버전" to "2.0")

// 구조 분해
map.forEach { (key, value) ->
    println("$key: $value")
}

// 사용하지 않는 파라미터는 밑줄로
map.forEach { (_, value) ->
    println(value)
}

val transform: (String) -> String = { input ->
    val trimmed = input.trim()
    val upper = trimmed.uppercase()
    upper  // 마지막 줄이 반환값 (return 키워드 불필요)
}

fun countMatches(items: List<String>, target: String): Int {
    var count = 0  // 바깥 변수

    items.forEach {
        if (it == target) {
            count++  // 바깥 변수 수정 가능!
        }
    }

    return count
}

var counter = 0

// 컴파일러가 내부적으로 변환하는 형태 (개념적 설명)
// val counterRef = Ref(0)
// 람다 내부에서 counterRef.element++ 로 접근

val increment = { counter++ }
increment()
println(counter)  // 1

// 카운터 팩토리
fun makeCounter(): () -> Int {
    var count = 0
    return { count++ }   // 호출할 때마다 count 증가
}

val counter = makeCounter()
println(counter())  // 0
println(counter())  // 1
println(counter())  // 2

// 최상위 함수 참조
fun isEven(n: Int) = n % 2 == 0
val numbers = listOf(1, 2, 3, 4, 5)
numbers.filter(::isEven)  // [2, 4]

// 멤버 함수 참조
val strings = listOf("abc", "de", "fghi")
strings.sortedBy(String::length)  // ["de", "abc", "fghi"]

// 생성자 참조
data class User(val name: String)
val names = listOf("Alice", "Bob")
val users = names.map(::User)  // [User(name=Alice), User(name=Bob)]

val str = "Hello, World"

// 특정 인스턴스의 메서드 참조
val isHello = str::startsWith
println(isHello("Hello"))  // true

// 비교
val unboundRef: (String, String) -> Boolean = String::startsWith  // 언바인딩
val boundRef: (String) -> Boolean = str::startsWith               // 바인딩

// 자바의 Runnable — 추상 메서드 1개
// 원래 방식
val runnable1 = object : Runnable {
    override fun run() {
        println("실행")
    }
}

// SAM 변환 — 람다로 대체
val runnable2 = Runnable { println("실행") }

// 파라미터로 전달할 때
Thread { println("스레드 실행") }.start()  // SAM 변환 적용

// 일반 인터페이스 — SAM 변환 불가
interface Processor {
    fun process(value: Int): Int
}
// val p: Processor = { it * 2 }  // 컴파일 에러!

// fun interface — SAM 변환 가능
fun interface Transformer {
    fun transform(value: Int): Int
}

val doubler: Transformer = Transformer { it * 2 }   // OK
val tripler: Transformer = { it * 3 }               // OK

// 함수 타입 — 코틀린에서 더 자연스러운 방식
fun process(items: List<Int>, transform: (Int) -> Int): List<Int> {
    return items.map(transform)
}

// fun interface — 의미 있는 타입 이름이 필요할 때
fun interface Validator {
    fun validate(input: String): Boolean
}

fun register(validator: Validator) { /* ... */ }
register { it.isNotBlank() }  // SAM 변환

// 이 코드는 매번 Function1 객체를 생성
fun filterPositive(numbers: List<Int>): List<Int> {
    return numbers.filter { it > 0 }  // 람다 → Function1 객체
}