[Kotlin] 코틀린 고차 함수

// 타입 추론
val sum = {x: Int, y: Int -> x + y}
val action = { println(42) }

// 함수 타입 명시
val sum: (Int, Int) -> Int = {x, y -> x + y}
val action: () -> Unit = { println(42) }

// 반환 타입이 널이 될 수 있는 타입
var canReturnNull: (Int, Int) -> Int? = { x,y -> null }

// 함수 타입 변수 자체가 널이 될 수 있는 타입
var funOrNull: ((Int, Int) -> Int)? = null

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

twoAndThree { a, b -> a + b}
// 결과: The result is 5
twoAndThree() { a, b -> a * b }
// 결과: The result is 6

// 코틀린에서 선언
fun processTheAnswer(f: (Int) -> Int) {
    println(f(42))
}

fun <T> Collection<T>.joinToString(separator: String = ", ",
                                    prefix: String = "",
                                    postfix: String = "",
                                    transform: (T) -> String = { it.toString() } // 함수 타입 파라미터를 선언하면서 람다를 디폴트 값으로 지정
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(transform(element))
    }
    result.append(postfix)
    return result.toString()
}

val letters = listOf("Alpha", "Beta")

// 디폴트 람다 사용
println(letters.joinToString())
// 결과: Alpha, Beta

// 직접 람다 전달
println(letters.joinToString { it.toLowerCase() })
// 결과: alpha, beta

// 이름이 붙은 인자 구문을 사용해 여러 인자를 전달
println(letters.joinToString(separator = "! ", postfix = "! ", transform = { it.toUpperCase() }))
//결과: ALPHA! BETA!
 

fun foo(callback: (() -> Unit)?) {
    // TODO
    if (callback != null){
        callback()
    }
}

fun <T> Collection<T>.joinToString(separator: String = ", ", 
                                    prefix: String = "",
                                    postfix: String = "",
                                    transform: ((T) -> String)? = null // 널이 될 수 있는 함수 타입의 선언
): String {
    val result = StringBuilder(prefix)
    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        val str = transform?.invoke(element) ?: element.toString()
        result.append(str)
    }
    result.append(postfix)
    return result.toString()
}

enum class Delivery { STANDARD, EXPEDITED }
class Order(val itemCount: Int)
fun getShippingCostCalculator(delivery: Delivery): (Order) -> Double {
    if (delivery == Delivery.EXPEDITED) {
        return { order -> 6 + 2.1 * order.itemCount }
    }

    return { order -> 1.2 * order.itemCount}
}

val calculator = getShippingCostCalculator(Delivery.EXPEDITED)
println("Shipping costs ${calculator(Order(3))}")
// 결과: Shipping costs 12.3

data class Person(val firstName: String, val lastName: String, val phoneNumber: String?)
class ContactListFilters {
    var prefix: String = ""
    var onlyWithPhoneNumber: Boolean = false
    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 } // 람다를 반환
    }
}

val contacts = listOf(Person("Dmitry", "Jemerov", "123-4567"), Person("Svetlana", "Isakova", null))
val contactListFilters = ContactListFilters()
with (contactListFilters) {
    prefix = "Dm"
    onlyWithPhoneNumber = true
}
println(contacts.filter(contactListFilters.getPredicate()))
// 결과: [Person(firstName=Dmitry, lastName=Jemerov, phoneNumber=123-4567)]

data class SiteVisit(val path: String, val duration: Double, val os: OS)

enum class OS { WINDOWS, LINUX, MAC, IOS, ANDROID }

val log = listOf(SiteVisit("/", 34.0, OS.WINDOWS), 
    SiteVisit("/", 22.0, OS.MAC),
    SiteVisit("/login", 12.0, OS.WINDOWS),
    SiteVisit("/signup", 8.0, OS.IOS),
    SiteVisit("/", 16.3, OS.ANDROID))

// 윈도우 사용자의 평균 방문 시간 가져오기
val averageWindowsDuration = log.filter { it.os == OS.WINDOWS }
                                .map(SiteVisit::duration)
                                .average()
println(averageWindowsDuration)
// 결과: 23.0

// OS별 사용자 평균 방문 시간 가져오는 확장 함수 정의
fun List<SiteVisit>.averageDurationFor(os: OS) = 
    filter { it.os }.map(SiteVisit::duration).average()

println(log.averageDurationFor(OS.WINDOWS))
// 결과: 23.0
println(log.averageDurationFor(OS.MAC))
// 결과: 22.0

// 하드코딩한 필터를 사용해 방문 데이터 분석하기
val averageMobileDuration = log.filter { it.os in setOf(OS.IOS, OS.ANDROID) }
                                .map(SiteVisit::duration)
                                .average()
println(averageMobileDuration)
// 결과: 12.15

// 고차 함수를 사용해 중복 제거하기
fun List<SiteVisit>.averageMobileDurationFor(predicate: (SiteVisit) -> Boolean) =
    filter(predicate).map(SiteVisit::duration).average()

// 인라인 함수 정의하기
inline fun <T> synchronized(lock: Lock, action: () -> T): T {
    lock.lock()
    try {
        return action()
    } finally {
        lock.unlock()
    }
}
val l = Lock()
synchronized(l) {
    // TODO
}

fun foo(l: Lock) {
    println("Before sync")
    synchronized(l) {
        println("Action")
    }
    println("After sync")
}

fun __foo__(l: Lock) {
    println("Before sync")
    l.lock() // synchronized 함수가 인라이닝된 코드 시작
    try {
        println("Action")  // 람다 코드의 본문이 인라이닝된 코드
    } finally {
        l.unlock()
    }        // synchronized 함수가 인라이닝된 코드 끝
    println("After sync")
}

class LockOwnser(val lock: Lock) {
    fun runUnderLock(body: () -> Unit) {
        synchronized(lock, body)
    }
}

class LockOwner(val lock: Lock) {
    fun __runUnderLock__(body: () -> Unit) {
        lock.lock()
        try {
            body()
        } finally {
            lock.unlock()    
        }   
    }
}

inline fun <T> synchronized(lock: Lock, action: () -> T): T {
    val someA = action // ‐> 컴파일 에러
}
// Illegal usage of inline-parameter 'action' ...

fun <T,R> Sequence<T>.map(transform: (T) -> R): Sequence<R> {
    return TransformingSequence(this, transform)
}
// 파라미터 transform은 인라이닝하지 않은 함수(함수 인터페이스를 구현하는 무명 클래스 인스턴스)로 표현하여야 한다.

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
    // TODO
}

data class Person(val name: String, val age: Int)
...
people.filter { it.age > 30} // 중간 리스트 생성
        .map(Person::name)

val l: Lock = ...
l.withLock {
    // 락에 의해 보호되는 자원을 사용
}

fun readFirstLineFromFile(path: String): String {
    BufferedReader(FileReader(path)).use { br ->
        return br.readLine() // 람다의 종료가 아닌 readFirstLineFromFile 함수를 끝내며 값 반환
    }
}

data class Person(val name: String, val age: Int)
val people = listOf(Person("Alice", 29), Person("Bob", 31))

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

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

lookForAlice(people)
//결과: Alice might be somewhere

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

fun lookForAlice(people: List<Person>) {
    people.forEach(fun (person) { // 람다식 대신 무명 함수를 사용
        if (person.name == "Alice") return // 가장 가까운 함수에서 return 처리가 됨
        println("${person.name} is not Alice")
    })
}

people.filter(fun (person): Boolean {
    return person.age < 30
})

// 식을 본문으로 하는 무명 함수의 반환 타입은 생략할 수 있음
people.filter(fun (person) = person.age < 30)