🚗 4. 함수 가지고 놀기

1. 고차함수와 람다식 (1)

{람다 함수에 사용할 매개변수 -> 반환할 식}

* 자료형을 추론할 수 있게 써야 표현된다!

🌎 반환 자료형이 없는 경우: () -> Unit
🌎 매개변수가 하나인 경우: (Int)->Int**

val greet: () -> Unit = {println("Hello")} //반환값도, 인자도 없는 경우: 오른쪽에 화살표X

🌎 람다식 안에 람다식이 있는 경우**
val nestedLambda: ()->()->Unit = { { println("nested")} }
//중괄호 두개!

함수 자체에 반환을 함수로 줄 수 있음

-람다식, 고차함수 호출하기

1) 값에 의한 호출

: 함수가 인자로 전달되는 경우: 람다식 함수는 값으로 처리되어 그 즉시 함수가 수행된 후에 값이 전달된다!

fun main(){
val result = callByValue(lambda())// 1️⃣ 람다식 함수를 호출!
println(result)//5️⃣ result 값
}

fun callByValue(b: Boolean): Boolean{//3️⃣ b = 일반 변수 자료형으로 선언된 매개변수
println("callByValue func")
return b//4️⃣
}

val lambda: () -> Boolean = {//람다 표현식이 두줄이면
println("lambda func")
true//2️⃣ 마지막 표현식 문장의 결과가 반환!
}

2) 람다식 이름을 사용한 호출

fun main(){
val result = callByName(otherLambda)//1️⃣ 람다식 이름만 사용한 경우 () 필요 없음
println(result)//4️⃣ result
}
fun callByName(b: () -> Boolean): Boolean{//변수 b도 람다식!!
println("callByName func")
return b()// 2️⃣
}
val otherLambda: () -> Boolean = {//값만 들어가는게 아니라, 이 내용이 다 들어가
println("otherLamda func")
true//3️⃣
}

3) 다른 함수의 참조에 의한 호출

: 람다식일때만 함수의 인자로 사용할 수 있다.

fun sum(x: Int, y: Int) = x+y

funcParam(3,2,sum) //오류!!//sum이 람다식이 아니기 때문!!!

=> funcParam(3,2,::sum) //참조방식!내부적으로 람다식에 매치해서 가져옴

fun funcParam(a: Int, b: Int, c: (Int, Int) -> Int): Int{
return c(a,b)
}

2. 고차함수와 람다식 (2)

-매개변수 개수에 따라 람다식을 구성하는 방법

1) 매개변수가 없는 경우

2) 매개변수가 1개인 경우

//매개변수 a가 하나 있는 람다식 함수
oneParam({a-> "Hello $a"})
oneParam{a-> "Hello $a"}
oneParam{"Hello $it"}//앞에서 가져온 변수 하나(두개일경우 대체X)

fun oneParam(out: (String) -> String){
println(out("OneParam"))
}

3) 매개변수가 2개 이상인 경우

//매개변수가 2개
moreParam{a,b -> "Hello $a $b"}

fun moreParam(out:(String, String)-> String){
println(out("One Param", "Two Param"))
}

/////////////
moreParam{_,b -> "Hello $b"}
//첫번째 문자열은 사용안해

4) 일반 매개변수와 람다식 매개변수를 같이 사용

//인자와 함께 사용하는 경우
//일반 매개변수와 람다식 매개변수를 같이 사용
withArgs("Arg1","Arg2",{a,b -> "Hello $a $b"})
//withArgs()의 마지막 인자(out)가 람다식인 경우 () 분리 가능
withArgs("Arg1","Arg2") {a,b -> "Hello $a $b"}

fun withArgs(a: String, b: String, out:(String, String)->String){//a,b,out(람다식)
println(out(a,b))
}

5) 두 개의 람다식을 가진 함수

3. 익명함수, 인라인 함수 (1)

1) 익명함수

-함수가 이름이 없는 것!
fun (x: Int, y: Int): Int = x+y//=={return x+y}

val add: (Int, Int) -> Int = fun(x,y) = x+y//익명함수를 사용한 add 선언
//임시적으로 사용할 때 유용함!
val result = add(10,2) //함수처럼 보이지만, 처리된 결과 리턴한 값을 담고 있는 변수!!

val add = fun(x: Int, y: Int) = x+y

val add = {x: Int, y: Int -> x+y}

//위처럼 익명함수와 익명함수 중 하나인 람다식은 매우 흡사하다!

• 차이점은 일반 익명함수에서는 return, break, continue가 사용가능하지만, 람다식에서는 사용하기 어렵다는 점이다.

2) 인라인 함수

: 함수가 호출되는 곳에 내용을 모두 복사!
-함수의 분기 없이 처리 -> 성능 증가!
-코드가 복사되어 들어가기 때문에 대개 내용은 짧게 작성한다
-인라인 함수는 람다식 매개변수를 가지고 있는 함수 형태를 권장한다.

inline 함수는 main 함수 내에서 inline함수 내용이 복사되어 그대로 실행된다. 반면 inline을 지우고 실행하면 shortFunc()함수를 호출하여 실행된다. [Kotlin - Show ByteCode - Decomplie] 해서 java 코드로 이 차이점을 확실히 볼 수 있다.

inline 부분에 노란색으로 경고가 뜨는데,
Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types
인라인 함수는 성능에 영향을 주기 때문에, 람다식 함수를 사용해야 더 좋다는 내용이다.

Decompile해서 확인해보면, 함수를 호출하는 것이 아닌, 내용이 main함수 내에 복사되어 들어가 있다!

인자가 하나일 경우 단축 가능!
=> it 사용

shortFunc(5 ){println("a: $it")}

얘도 가능!!!!

4. 익명함수, 인라인 함수(2)

-인라인 함수의 제한과 금지

-인라인 함수의 단점
: 코드가 복사되므로 내용이 많은 함수에 사용하면 코드가 늘어난다.

-noinline 키워드
: 일부 람다식 함수를 인라인 되지 않게 하기 위해

inline fun sub(out1: () -> Unit, noinline out2: () -> Unit){
//out2는 복사되는게 아니라 그대로 남아있음

//====================================

inline fun shortFunc(a: Int, noinline b: (Int)->Unit){
//반환값이 없는 람다식 인자 b
println("Hello")
b(a) //no inline
}
fun main(){
//shortFunc(5,{a -> println("a: $a")})
shortFunc(5 ){println("a: $it")}
}

Function1이 out.invoke를 통해 a를 호출하는데, main함수에서 이가 그대로 남아있음

//========================

-비지역반환

" 코틀린에서는 익명 함수를 종료하기 위해서 return을 사용할 수 있습니다. 이때 특정 반환값 없이 return만 사용해야 합니다. 그렇다면 람다식 함수를 빠져 나오려면 어떻게 할까요? 람다식 함수를 인자로 사용하는 함수는 의도하지 않게 람다식 함수 바깥에 있는 함수가 같이 반환되 버리는데 이것을 비지역 반환이라고 합니다. "

main함수에서 shortFunc 리턴을 주면, 해당 b만 빠져나가는 것이 아닌, b와 shortFunc 모두 빠져나가게 되어서 밑에 Goodbye가 출력이 안된다.

이때 이런 비지역 반환을 금지하려면 crossinline이라는 키워드를 람다식 함수 앞에 사용해 함수의 본문 블록에서 return이 사용되는 것을 금지할 수 있습니다. crossinline 키워드는 비지역 반환을 금지해야 하는 람다식에 사용합니다.

=> return을 사용할 수 없게 된다.

5. 확장 함수

-확장 함수(extension function)
:클래스의 멤버 함수를 외부에서 더 추가할 수 있다.

fun 확장 대상.함수명(매개변수, ...): 반환값 {
...
return 값
}

클래스에는 다양한 함수가 정의되어 있습니다. 이것은 클래스의 멤버 메서드라고도 불립니다. 그런데 기존 멤버 메서드는 아니지만 내가 원하는 함수를 하나 더 포함시켜 확장하고 싶을 때가 있을 것입니다. 코틀린에서는 이처럼 클래스처럼 필요로 하는 대상에 함수를 더 추가할 수 있는 확장 함수(extension function)라는 개념을 제공하고 있습니다.

확장 함수를 만들 때 만일 확장하려는 대상에 동일한 이름의 멤버 함수 혹은 메서드가 존재한다면 항상 확장 함수보다 멤버 메서드가 우선으로 호출됩니다.

**확장함수 부분 책보고 다시 공부하기

6. 중위 함수

-중위 표현법: 클래스의 멤버 호출 시 사용하는 점(.)을 생략하고 함수 이름 뒤에 소괄호를 생략해 직관적인 이름을 사용할 수 있는 표현법

-조건

• 멤버 메서드 / 확장 함수여야 한다.
• infix 키워드 사용.
• 하나의 매개변수를 가져야 한다.

• 중위 함수를 이용해 연산자처럼 사용하기
  

  //중위 표현법
  val multi_infix = 3 multiply 10
  println("multi_infix: $multi_infix")
  

val str1 = num.strPlus("Kotlin")//일반 표현법
val str2 = num strPlus "Kotlin"//중위 표현법

7. 재귀 함수

-자기 자신을 다시 참조
-계속 호출하는 특징

-조건

• 무한 호출에 빠지지 않도록 탈출 조건을 만들어준다.
• 스택 영역을 이용하므로 호출 횟수를 무리하게 많이 지정해 연산하지 않는다.
• 코드를 복잡하지 않게 한다.

+ 꼬리 재귀 함수(tail recursive func)

-스택에 계속 쌓이는 방식이 함수가 계속 씌워지는 꼬리를 무는 형태
-tailrec 키워드를 사용해 선언

fun main(){
    val num = 5
    println("Factorial : $num -> ${factorial(num)}")
}

tailrec fun factorial(n:Int, run: Int = 1): Long{
    return if(n==1) run.toLong() else **factorial(n-1, run*n)**
}

=> 스택 공간을 낭비하지 않아도 되므로, 일반 재귀함수보다 훨씬 안전한 코드가 된다.

8. 함수의 실행 블록

-함수의 블록({})
: 지역 변수
<-> 전역 변수

-함수의 범위
1) 최상위 함수, 지역 함수

fun main() { // 최상위 레벨의 함수
    ...
    fun secondFunc(a: Int) { // 지역 함수 선언
        ... 
    }
    userFunc(4) // 사용자 함수 사용 - **선언부의 위치에 상관 없이 사용**
    secondFunc(2) // 지역 함수 사용 - **선언부가 먼저 나와야 사용 가능**
}

fun userFunc(counts: Int) { // 사용자가 만든 최상위 레벨의 함수 선언
    ...
}