Merge branch 'Team-Sixteen-Study:main' into main

.gitignore

@@ -0,0 +1,5 @@
+.idea
+
+# Default ignored files
+/shelf/
+/workspace.xml

jhwon91/8. 고차 함수: 파라미터와 반환 값으로 람다 사용.md

@@ -0,0 +1,236 @@
+# 고차 함수: 파라미터와 반환 값으로 람다 사용
+## 1. 고차 함수 정의
+- 고차 함수는 다른 함수를 인자로 받거나 함수를 반환하는 함수다.
+### 📌 함수 타입
+- 함수 타입을 정의하려면 함수 파라미터의 타입을 괄호 안에 넣고, 그 뒤에 화살표(→)를 추가한 다음, 함수의 반환 타입을 지정하면 된다.
+- 함수 타입에서도 반환 타입을 널이 될 수 있는 타입으로 저정할 수 있다.
+- 함수의 타입이 아니라 함수 타입 전체가 널이 될 수 있는 타입임을 선어하기 위해 함수 타입을 괄호로 감싸고 그 뒤에 물음표를 붙여야만 한다.
+```kotlin
+var canReturnNull: (Int, Int) -> Int? = {x, y -> null}
+var funOrNull: ((Int, Int) -> Int) ? null
+```
+
+### 📌 인자로 받은 함수 호출
+```kotlin
+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
+```
+- 인자로 받은 함수를 호출하는 구문은 일반 함수를 호출하는 구문과 같다.
+- 함수 이름 뒤에 괄호를 붙이고 괄호 안에 원하는 인자를 콤마(,)로 구분해 넣는다
+- String에 대한 filter를 구현
+- 문자열의 각 문자를 술어에 넘겨서 반환 값이 true면 결과를 담는 StringBuilder뒤에 그 문자를 추가한다.
+```kotlin
+fun String.filter(predicate: (Char) -> Boolean): String {
+    val sb = StringBuilder()
+    for (index in 0 until length) {
+        val element = get(index)
+        if (predicate(element)) sb.append(element)
+    }
+    return sb.toString()
+}
+
+println("ab1c".filter { it in 'a'..'z' }) //abc
+```
+
+
+### 📌 자바에서 코틀린 함수 타입 사용
+- 컴파일된 코드 안에서 함수 타입은 일반 인터페이스로 바뀐다.
+- 함수 타입의 변수는 FunctionN 인터페이스를 구현하는 객체를 저장한다.
+- 코틀린 표준 라이브러리는 함수 인자의 개수에 따라 Function0(인자가 없는 함수), Function1<P1, R>(인자가 하나인 함수) 등의 인터페이스를 제공
+
+
+### 📌 디폴트 값을 지정한 함수 타입 파라미터나 널이 될 수 있는 함수 타입 파라미터
+- 파라미터를 함수 타입으로 선언할 때도 디폴트 값을 정할 수 있다.
+```kotlin
+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)) // "transform" 파라미터로 받은 함수를 호출한다. 
+    }
+
+    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!
+```
+
+
+### 📌 함수를 함수에서 반환
+```kotlin
+// 함수를 반환하는 함수 정의
+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
+```
+- `getShippingCostCalculator` 함수는 `Order`를 받아서 Double을 반환하는 함수를 반환한다.
+- 함수를 반환하려면 return 식에 람다나 멤버 참조나 함수 타입의 값을 계산하는 식 등을 넣으면 된다.
+
+### 📌 람다를 활용한 중복 제거
+- 함수 타입과 람다 식은 재활용하기 좋은 코드를 만들 때 쓸 수 있는 훌륭한 도구다.
+```kotlin
+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()
+
+fun List<SiteVisit>.averageDurationFor(os: OS) =
+    filter { it.os == os }.map(SiteVisit::duration).average()
+
+println(log.averageDurationFor(OS.WINDOWS)) // 23.0
+println(log.averageDurationFor(OS.MAC))  // 22.0
+```
+
+```kotlin
+//고차 함수를 사용해 중복 제거하기
+fun List<SiteVisit>.averageDurationFor(predicate: (SiteVisit) -> Boolean) =
+        filter(predicate).map(SiteVisit::duration).average()
+
+println(log.averageDurationFor {
+    it.os in setOf(OS.ANDROID, OS.IOS) }) // 12.15
+println(log.averageDurationFor {
+    it.os == OS.IOS && it.path == "/signup" }) // 8.0
+```
+
+## 2. 인라인 함수: 람다의 부가 비용 없애기
+-  inline 변경자를 어떤 함수에 붙이면 컴파일러는 그 함수를 호출하는 모든 문장을 함수 본문에 해당하는 바이트코드로 바꿔치기 해준다.
+### 📌 인라이닝이 작동하는 방식
+- 함수를 inline으로 선언하면 그 함수의 본문이 인라인된다.
+- 함수를 호출하는 코드를 함수를 호출하는 바이트코드 대신에 함수 본문을 번역한 바이트 코드로 컴파일한다는 뜻이다.
+```kotlin
+inline fun <T> synchronized(lock: Lock, action: () -> T): T {
+	lock.lock()
+    try {
+		return action()
+	}
+	finally {
+		lock.unlock()
+	}
+}
+
+val l = Lock()
+
+synchronized(l) {
+	// ... 	
+}
+```
+- synchronized 함수를 inline으로 선언했으므로 synchronized 를 호출하는 코드는 모두 자바의 synchronized 문과 같아진다.
+
+## 3. 고차 함수 안에서 흐름 제어
+### 📌 람다안의 return문: 람다를 둘러싼 함수로부터 반환
+- 다음 코드의 실행 결과를 보면 이름이 Alice인 경우에 lookForAlice 함수로부터 반환된다.
+```kotlin
+data class Person(val name: String, val age: Int)
+
+val people = listOf(Person("Alice", 29), Person("Bob", 31))
+
+fun lookForAlice(people: List<Person>) {
+    for (person in people) {
+        if (person.name == "Alice") {
+            println("Found!")
+            return
+        }
+    }
+    println("Alice is not found")
+}
+```
+- forEach 함수를 대신 써도 안전하다.
+```kotlin
+fun lookForAlice(people: List<Person>) {
+    people.forEach {
+        if (it.name == "Alice") {
+            println("Found!")
+            return
+        }
+    }
+    println("Alice is not found")
+}
+```
+- 람다 안에서 return을 사용하면 람다로부터만 반환되는 게 아니라 그 람다를 호출하는 함수가 실행을 끝내고 반환된다.
+- 자신을 둘러싸고 있는 블록보다 더 바깥에 있는 다른 블록을 반환하게 만드는 return 문을 넌로컬(non-local) return이라 부른다.
+- return이 바깥쪽 함수를 반환시킬 수 있는 때는 람다를 인자로 받는 함수가 인라인 함수인 경우뿐이다.
+
+
+### 📌 람다로부터 반환: 레이블을 사용한 return
+- 람다 식에서도 로컬 return을 사용할 수 있다. 람다 안에서 로컬 return은 for루프의 break와 비슷한 역할을 한다.
+- 로컬 return과 넌로컬 return을 구분하기 위해 레이블(label)을 사용해야 한다.
+```kotlin
+//레이블을 통해 로컬 리턴 사용하기
+fun lookForAlice(people: List<Person>) {
+    people.forEach label@{ //람다식 앞에 레이블을 붙인다.
+        if (it.name == "Alice") return@label //return@label은 앞에서 정의한 레이블을 참조한다.
+    }
+    println("Alice might be somewhere") //항상 이줄이 출력된다.
+}
+```
+- 람다에 레이블을 붙여서 사용하는 대신 람다를 인자로 받는 인라인 함수의 이름을 return 뒤에 레이블로 사용해도 된다.
+```kotlin
+fun lookForAlice(people: List<Person>) {
+    people.forEach {
+        if (it.name == "Alice") return@forEach
+    }
+    println("Alice might be somewhere")
+}
+```
+- 람다 식의 레이블을 명시하면 함수 이름을 레이블로 사용할 수 없다.
+
+
+### 📌 무명 함수: 기본적으로 로컬 return
+- 무명 함수는 코드 블록을 함수에 넘길 때 사용할 수 있는 다른 방법이다.
+```kotlin
+fun lookForAlice(people: List<Person>) {
+    people.forEach(fun (person) { //람다 식 대신 무명 함수를 사용한다.
+        if (person.name == "Alice") return // return 은 가장 가까운 함수를 가르키는데 이 위치에서 가장 가까운 함수는 무명 함수다. 
+        println("${person.name} is not Alice")
+    })
+}
+```
+
+
+
+
+