함수형 프로그래밍? 그래서 어떻게

함수형 프로그래밍?
그래서 어떻게?(Kotlin)
김규하

목차
1. 함수형 프로그래밍
2. 순수한 함수
3. 불변성
4. 일급객체
5. 고차함수

● 함수형 프로그래밍이란 자료처리를 수학적 함수의
계산으로 취급하고 상태와 가변 데이터를 멀리하는
프로그래밍 패러다임 중 하나
함수형 프로그래밍?

순수한 함수
f(x) = y
f(3) = 6

var number3 = 5
fun add(number1: Int, number2: Int) : Int {
return number1 + number2 + number3
}
fun add(number1: Int, number2: Int) : Int {
return number1 + number2
}
순수하지 못한 함수순수한 함수

fun add(number1: Int, number2: Int) {
var result = number1 + number2
}
fun justTen(): Int {
return 10
}
순수한듯 순수하지 못한 함수

순수한 함수
1. 함수에 입력값이 같으면 항상 동일한 결과를
출력한다.
2. 최소한의 입력과 최소한의 출력이 있어야 한다.

fun calc(operator: Char) {
result = when (operator) {
'+' -> number1 + number2
'-' -> number1 - number2
'*' -> number1 - number2
else -> -1
}
}
순수하지 못한 함수
var result = 0
var number1 = 10
var number2 = 2
fun main(args: Array<String>) {
calc('*')
println("result : $result")
calc('*')
result = -1
println("result : $result")
}

순수하지 못한 함수를 순수한 함수로
fun calc(operator: Char) {
result = when (operator) {
else -> -1
}
}
fun calc(number1: Int, number2: Int, operator: Char): Int {
return when (operator) {
else -> -1
}
}

var result = 0
var number1 = 10
var number2 = 2
println("result : ${calc(number1, number2, '*')}")
}
순수한 함수
else -> -1
}
}

불변성
val x = 1 var x = 1
x = x + 1x = x + 1

불변성
val immutableList: List<Int> = listOf(1, 2, 3)
println("immutableList : $immutableList")
val immutableList2 = immutableList.plus(4)
println("immutableList : $immutableList")
println("immutableList2 : $immutableList2")
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
println("mutableList : $mutableList")
mutableList.add(4)
println("mutableList : $mutableList")

불변성
● 부수 효과가 없다.
● 프로그램의 복잡도가 낮아진다.
● 멀티 쓰레딩 환경에서의 개발에 용이하다.

불변성
fun addLT10Number1(number1: Int): Int {
return if (number1 < 10) number1 + number2
else -1
}
fun addGT5Number2(number2: Int): Int {
return if (number2 > 5) number1 + number2
else -1
}
fun addGT5Number1LT10Number2(): Int {
return if (number1 > 5 && number2 < 10) number1 + number2
else -1
}
var number1 = 10
var number2 = 2
println("addGT5Number1LT10Number2: ${addGT5Number1LT10Number2()}")
println("addGT5Number2: ${addGT5Number2(number2)}")
println("addLT10Number1: ${addLT10Number1(number1)}")
println("-------------------------------------------")
number1 = 25
number2 = 3
println("-------------------------------------------")
number1 = 7
number2 = 7
}

가변성에서 불변성으로
var number1 = 10
var number2 = 2
number1 = 25
number2 = 3
number1 = 7
number2 = 7
}

가변성에서 불변성으로
val number1 = 10
val number2 = 2
println("-------------------------------------------")
println("-------------------------------------------")
}

val number1 = 10
val number2 = 2
println("-------------------------------------------")
println("-------------------------------------------")
}
전역에서 지역으로

순수하지 못한 함수에서 순수한 함수로
val number1 = 10
val number2 = 2
println("add...: ${addGT5Number1LT10Number2(number1, number2)}")
println("addGT5Number2: ${addGT5Number2(number1, number2)}")
println("addLT10Number1: ${addLT10Number1(number1, number2)}")
println("-------------------------------------------")
println("-------------------------------------------")
}
fun addLT10Number1(number1: Int, number2: Int): Int {
return if (number1 < 10) number1 + number2
else -1
}
fun addGT5Number2(number1: Int, number2: Int): Int {
return if (number2 > 5) number1 + number2
else -1
}
fun addGT5Number1LT10Number2(number1: Int, number2: Int): Int {
return if (number1 > 5 && number2 < 10) number1 + number2
else -1
}

일급 함수
● 함수를 변수나 데이터 구조에 담을 수 있다.
● 함수를 파라미터로 전달할 수 있다.
● 함수를 반환값으로 사용할 수 있다.

일급 함수
val functionValue: (Int) -> Int = { a ->
a * a
}
println("result : ${functionValue(2)}")
}

fun functionInFunction(func: (Int) -> Int, number: Int): Int {
return func.invoke(number)
}
val functionValue: (Int) -> Int = { a->
a * a
}
println("result : ${functionInFunction(functionValue, 2)}")
}
일급 함수

fun functionInFunction(a: Int): (Int) -> Int = { b ->
a * b
}
println("result : ${functionInFunction(2)(2)}")
}
일급 함수

고차 함수
● 파라미터에 함수가 넘어오는 함수
● 반환하는 값이 함수인 함수

고차 함수
fun functionInFunction(func: (Int) -> Int, number: Int): Int {
return func.invoke(number)
}
val functionValue: (Int) -> Int = { a->
a * a
}
println("result : ${functionInFunction(functionValue, 2)}")
}

fun functionInFunction(a: Int): (Int) -> Int = { b ->
a * b
}
println("result : ${functionInFunction(2)(2)}")
}
고차 함수

var result = 0
var number1 = 10
var number2 = 2
println("result : ${calc(number1, number2, '*')}")
}
고차함수
'*' -> number1 * number2
else -> -1
}
}

순수함수에 고차함수 적용
fun calc(number1: Int, number2: Int, operator: Char): Int
{
'*' -> number1 * number2
else -> -1
}
}
fun calc(number1: Int, number2: Int, inFunction: (Int, Int) -> Int): Int {
return inFunction.invoke(number1, number2)
}

val number1 = 10
val number2 = 2
println("result : ${calc(number1, number2, {n1, n2 -> n1 / n2})}")
println("result : ${calc(number1, number2, {n1, n2 -> n1 % n2})}")
}
고차함수
}

val number1 = 10
val number2 = 2
println("result : ${calc(number1, number2, {n1, n2 -> n1 / n2})}")
println("result : ${calc(number1, number2, {n1, n2 -> n1 % n2})}")
println("result : ${calc(number1, number2, {n1, n2 -> n1 * n2})}")
println("result : ${calc(number1, number2, {n1, n2 -> n1 + n2})}")
println("result : ${calc(number1, number2, {n1, n2 -> n1 - n2})}")
}
고차함수
}

함수형 프로그래밍의 장단점
1. 변하지 않는 값
2. 결과가 예측 가능한 순수한 함수
3. 적은 사이드 이펙트
4. 높은 추상화로 간결해진 코드
1. 러닝커브
2. 레퍼런스가 부족하다.
3. 지나치게 높은 추상화가
가독성을 해칠 수 있다.
단점
장점

선언형 프로그래밍과 함수형 프로그래밍 비교
선언형 프로그래밍
● 알고리즘을 명시하고 목표를
명시하지 않음
● 상태변경 O
● 주요 흐름 제어로는 반복문, 조건 및
함수(메소드) 호출
● 클래스나 구조체, 인스턴스
함수형 프로그래밍
● 알고리즘을 명시하지 않고 목표를
명시함
● 상태변경 X
● 원하는 정보와 필요한 반환
● 재귀를 비롯한 함수 응용
● 일급 객체와 데이터 컬렉션 함수

함수형 프로그래밍? 그래서 어떻게

More Related Content

What's hot (20)

Similar to 함수형 프로그래밍? 그래서 어떻게 (20)

함수형 프로그래밍? 그래서 어떻게