[Kotlin] 함수형 프로그래밍

💡익명함수, 인라인 함수, 확장함수, Infix 함수, 고차함수💡

 

---

▪️함수형 프로그래밍

· Java는 완벽한 객체지향 프로그래밍 언어이다.

· Kotlin은 함수만 만들어 사용하는 것을 지원한다.

· 간단한 함수는 한 줄로 작성이 가능하다.

fun main() {
    val result1 = fun1(100, 200)
    println(result1)

    val result2 = fun2(200, 300)
    println(result2)

    val result3 = fun2(300, 400)
    println(result3)
}

fun fun1(num1 : Int, num2 : Int) : Int {
    return num1 + num2
}

// fun1처럼 간단한 함수는 한 줄로 작성이 가능
fun fun2(num1 : Int, num2 : Int) : Int = num1 + num2

// 자동으로 타입을 알아낼 수 있으므로 반환 타입 생략 가능
fun fun3(num1 : Int, num2 : Int) = num1 + num2

 

람다식

· 위에서 작성한 함수와 같은 형태는 람다라는 것으로 바꿔 사용할 수 있다.

· 특정 함수 내에서만 사용하는 연산 코드를 사용할 때 사용된다.

fun main() {
    val lambda1 : (Int, Int) -> Int = { num1 : Int, num2 : Int -> num1 + num2 }
    val result1 = lambda1(100, 200)
    println(result1)

    // 람다 또한 타입 생략이 가능
    val lambda2 = { num1 : Int, num2 : Int -> num1 + num2 }
    val result2 = lambda2(200, 300)
    println(result2)

    // 앞의 타입을 보고 추론이 가능하기 때문에 괄호안의 타입 생략 가능
    val lambda3 : (Int, Int) -> Int = { num1, num2 -> num1 + num2 }
    val result3 = lambda2(300, 400)
    println(result3)

    val lambda4 = { num1 : Int, num2 : Int ->
        val result1 = num1 + num2
        val result2 = num1 - num2

        // 람다식에선 마지막이 return값
        result1 * result2
    }
    val result4 = lambda4(400, 500)
    println(result4)
}

 

 

▪️익명함수

· 함수의 이름이 없는 함수이다.

· 함수를 변수에 담아 관리할 때 사용한다.

fun main() {
    val NonFunction = fun() {
        println("NonFunction 호출")
    }

    NonFunction()
}

 

 

▪️인라인 함수

· 전체 코드 양이 늘어 메모리를 더 많이 사용한다.

· 코드 흐름의 이동 없이 수행되기 때문에 작업량이 늘어나지 않는다.

fun main() {
    inlFunction1()
    inlFunction1()
    
    // inlFunction2() 함수내의 코드가 복사되어 덮어씌워짐
    inlFunction2()
    inlFunction2()
    
    /*
    코드가 실행되면 아래처럼 바뀜
    
    println("----------")
    println("inlFunction2 호출")
    println("----------")
    println("----------")
    println("inlFunction2 호출")
    println("----------")
    */
}

fun inlFunction1() {
    println("----------")
    println("inlFunction1 호출")
    println("----------")
}

inline fun inlFunction2() {
    println("----------")
    println("inlFunction2 호출")
    println("----------")
}

 

 

▪️확장함수

· 기존 클래스에 새로운 함수를 추가하는 것이다.

· 기존 클래스에 메서드를 추가해 사용하는 것처럼 보이지만 사실 객체의 주소값을 받은 함수가 만들어지고 호출하는 방식으로 동작한다.

fun main() {
    var str = "abcd"
    println(str.extFunction())
}

// 기존 String 클래스에 메서드를 추가한것처럼 보이지만
// 실제로는 그냥 일반적인 메서드로 만들고 객체의 주소값을 전달받음
fun String.extFunction() : String {
    return this.toUpperCase()
}

 

 

▪️Infix 함수

· 함수를 연산자처럼 사용할 수 있는 함수이다.

fun main() {
    val result1 = 100 add2 100
    println("result1 : $result1")

    val result2 = 100 minus2 100
    println("result2 : $result2")
}

infix fun Int.add2(num : Int) : Int {
    return this + num
}

infix fun Int.minus2(num : Int) : Int {
    return this - num
}

 

 

▪️고차함수

· 함수를 매개 변수로 받거나 반환 타입이 함수인 함수를 고차함수라고 부른다.

· 함수 호출 시 전달하는 함수와 반환하는 함수는 람다식을 사용할 수 있다.

fun main() {
    // 익명함수 사용
    val fun1 = fun(n1 : Int, n2 : Int) : Int {
        return n1 + n2
    }
    higFunction1(fun1, 100, 200)

    // 익명함수를 바로 넣어 사용 가능
    higFunction1(fun(n1 : Int, n2 : Int) : Int {
        return n1 - n2
    }, 100, 200)

    // 람다 사용
    val lambda1 = { n1 : Int, n2 : Int -> n1 * n2 }
    higFunction1(lambda1, 100, 200)

    // 람다를 바로 넣어 사용 가능
    higFunction1({n1 : Int, n2 : Int -> n1 / n2}, 200, 100)

    ///////////////////////////////////////////////////

    val fun2 = higFunction2()
    val result2 = fun2(100, 200)
    println("result2 : $result2")

    val fun3 = higFunction3()
    val result3 = fun3(100, 200)
    println("result3 : $result3")
}

// 매개 변수가 함수인 고차함수
fun higFunction1(f:(Int, Int) -> Int, num1 : Int, num2 : Int) {
    val result1 = f(num1, num2)
    println("result1 : $result1")
}

// 반환 타입이 함수인 고차함수
fun higFunction2() : (Int, Int) -> Int {
    return fun(n1 : Int, n2 : Int) : Int {
        return n1 + n2
    }
}

// 반환 타입이 람다인 고차함수
fun higFunction3() : (Int, Int) -> Int {
    return { n1 : Int, n2 : Int -> n1 - n2 }
}

 

---