Fp basic-kotlin

Functional
Programming
Lazysoul

우명인

FP?
• Immutable DataStructure

• Pure Function

• Lazy evaluation

FP?

FP?
var mutableInt: Int = 10
mutableInt = 5
var mutableString: String = "FP"
mutableString = "Kotlin"

FP?
mutableInt = 5
property keyword

FP?
mutableInt = 5
property name

FP?
mutableInt = 5
property type

FP?
mutableInt = 5
property value

FP?
val immutableInt: Int = 10
immutableInt = 5 // Error
val immutableString: String = "FP"
immutableString = "Kotlin" // Error

FP?
var mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
mutableList.add(10)

FP?
var mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
mutableList.add(10)
println(mutableList) // [1, 2, 3, 10]

FP?
val immutableList: List<Int> = listOf(1, 2, 3)
immutableList.add(10) // Error
println(immutableList) // [1, 2, 3]

FP?
immutableList.plus(10)

FP?

FP?
println(immutableList.plus(10)) // [1, 2, 3, 10]

FP?
val newList = immutableList.plus(10)

FP?
val newList = immutableList.plus(10)
println(newList) // [1, 2, 3, 10]

• Pure Function
FP?
fun main(args: Array<String>) {
println(pureFunction("FP")) // Hello FP
}
fun pureFunction(input: String): String {
return "Hello " + input
}

• Pure Function
FP?
}
fun pureFunction(input: String): String {
return "Hello " + input
}

• Pure Function
FP?
println(nonPureFunction("FP")) // Hello FP
}
val strBuilder: StringBuilder = StringBuilder("Hello ")
fun nonPureFunction(input: String): String {
return strBuilder.append(input).toString()
}

• Pure Function
FP?
println(nonPureFunction("FP")) // Hello FP
println(nonPureFunction("FP")) // Hello FPFP
println(nonPureFunction("FP")) // Hello FPFPFP
}
val strBuilder: StringBuilder = StringBuilder("Hello ")
fun nonPureFunction(input: String): String {
return strBuilder.append(input).toString()
}

• Pure Function
FP?
println(nonPureFunction2(4)) // 5
}
var x = 1
fun nonPureFunction2(input: Int): Int{
return input + x
}

• Pure Function
FP?
}
var x = 1
return input + x
}

• Pure Function
FP?
x = 10
}
var x = 1
return input + x
}

• Lazy evaluation
FP?
val lazyValue: String by lazy {
println("시간이 오래 걸리는 작업")
"hello"
}
println(lazyValue)
println(lazyValue)
}

• Lazy evaluation
FP?
val lazyValue: String by lazy {
println("시간이 오래 걸리는 작업")
"hello"
}
println(lazyValue)
println(lazyValue)
}
시간이 오래 걸리는 작업
hello
hello

• Lazy evaluation
FP?
val infiniteValue = generateSequence(0) { it + 1 }
infiniteValue
.take(5)
.forEach { print("$it ") }

• Lazy evaluation
FP?
val infiniteValue = generateSequence(0) { it + 1 }
infiniteValue
.take(5)
.forEach { print("$it ") } //0 1 2 3 4

• Lazy evaluation
FP?
val lazyValue2: () -> Unit = {
println("FP")
}
lazyValue2
lazyValue2
lazyValue2
lazyValue2()

• Lazy evaluation
FP?
val lazyValue2: () -> Unit = {
println("FP")
}
lazyValue2 //
lazyValue2 //
lazyValue2 //
lazyValue2() // FP

Functional Data Structure
• control with pure functions

• Immutable Data Structure

• Data Share

val value = 3
val result = plusThree(value)
}
fun plusThree(x: Int): Int {
return x + 3
}

val value = 3
val result = plusThree(value)
println(result) // 6
println(value) // 3
}
fun plusThree(x: Int): Int {
return x + 3
}

val list = listOf(1, 2)
val listResult = plusThree(list)
}
fun plusThree(list: List<Int>): List<Int> {
return list.plus(3)
}

println(list) // [1, 2]
println(listResult) // [1, 2, 3]
}
return list.plus(3)
}

• Data Share

• Data Share
1 2
Cons Cons
Head Tail Head Tail
NIL
list

• Data Share
1 2
Cons Cons
Head Tail Head Tail
list
NIL

• Data Share
return list.plus(3)
}
Tail NIL1 2
Head Tail Head Tail
NIL
list

• Data Share
list
return list.plus(3)
}
Tail 3
Cons
Head Tail
NIL1 2
Head Tail Head Tail
1 2
Head Tail Head Tail
NIL
list
• Data Share

• Data Share
1 2
Cons Cons
Head Tail Head Tail
3
Cons
Head Tail
NIL
listResult

val tail = listResult.tail()
• Data Share

• Data Share
1 2
Cons Cons
Head Tail Head Tail
listResult
3
Cons
Head Tail
NIL
Tail

• Data Share
2
Cons
Head Tail
3
Cons
Head Tail
NIL
Tail

Recursion
• solutions to smaller instances of the same problem

Recursion
• Tip

• 어떻게 보다 무엇에 집중.

• 종료조건부터 생각하자.

• 재귀를 반복 할수록 종료 조건으로 수렴.

Recursion
fun factorial(num: Int): Int {
var result = 1
for (i in 1..num) {
result *= i
}
return result
}

Recursion
fun factorial2(num: Int): Int = when (num) {
1 -> 1
else -> num * factorial2(num - 1)
}

Recursion
1 -> 1
}
Readability +

Recursion
n * factorial2( n-1)
1 -> 1
}

Recursion
n * (n-1 * factorial2(n -2) )
1 -> 1
}

Recursion
n * (n-2 * (n-3 * factorial2(n-3)))
n * (n-2 * (n-3 * (n-4 * factorial2(n-4))))
….. ((((((1))))))
1 -> 1
}

Recursion
1 -> 1
}
n * (n-2 * (n-3 * factorial2(n-3)))
n * (n-2 * (n-3 * (n-4 * factorial2(n-4))))
….. ((((((1))))))
n * (n-2 * (n-3 * (n-4 * 1)))
n * (n-2 * (n-3 * n-4 * 1))
n * (n-2 * n-3 * n-4 * 1)
n * n-2 * n-3 * n-4 * 1

Recursion
5 * factorial2(4)
5 * (4 * factorial2(3))
5 * (4 * (3 * factorial2(2)))
5 * (4 * (3 * (2 * factorial2(1))))
5 * (4 * (3 * (2 * (1))))
5 * (4 * (3 * (2)))
5 * (4 * (6))
5 * (24)
120
1 -> 1
}

Recursion
5 * factorial2(4)
5 * (4 * factorial2(3))
5 * (4 * (3 * factorial2(2)))
5 * (4 * (3 * (2 * factorial2(1))))
5 * (4 * (3 * (2 * (1))))
5 * (4 * (3 * (2)))
5 * (4 * (6))
5 * (24)
120
Performance -
1 -> 1
}

Recursion
5 * factorial2(4)
5 * (4 * factorial2(3))
5 * (4 * (3 * factorial2(2)))
5 * (4 * (3 * (2 * factorial2(1))))
5 * (4 * (3 * (2 * (1))))
5 * (4 * (3 * (2)))
5 * (4 * (6))
5 * (24)
120
Performance -
SOF
1 -> 1
}

Recursion
• Int 리스트 값중 최대값을 구하는 함수 getMaxValue 함수를 재귀
로 구현하자

Recursion
로 구현하자
종료조건?

Recursion
로 구현하자
fun getMaxValue(list: List<Int>): Int = when {
list.isEmpty() -> throw NullPointerException()
list.size == 1 -> list.first()
}
종료조건?

Recursion
로 구현하자
}
종료 조건으로 수렴?

Recursion
로 구현하자
else -> if (list.first() > getMaxValue(list.drop(1))) {
list.first()
} else {
getMaxValue(list.drop(1))
}
}
종료 조건으로 수렴?

Recursion
tailrec fun factorial3(num: Int, acc: Int = 1): Int =
when (num) {
1 -> acc
else -> factorial3(num - 1, acc * num)
}

• TailRecursion
Recursion
when (num) {
1 -> acc
}
factorial3( n-1, n)

• TailRecursion
Recursion
when (num) {
1 -> acc
}
factorial3( n-1, n)
factorial3( n-2, acc * n-1)

• TailRecursion
Recursion
when (num) {
1 -> acc
}
factorial3( n-1, n)
…
factorial3( 1, acc ….)
acc

• TailRecursion
Recursion
when (num) {
1 -> acc
}
Readability +

• TailRecursion
Recursion
when (num) {
1 -> acc
}
Readability +
Performance +

• TailRecursion
Recursion
when (num) {
1 -> acc
}
Readability +
Performance +
!SOP

Recursion
• 연습문제 (exercise1)

• getMaxValue를 꼬리 재귀로 만들어보자.

Recursion

tailrec fun getMaxValue(list: List<Int>, acc: Int): Int =
when {
list.size == 1 -> acc
else -> if (list.first() >= acc) {
getMaxValue(list.drop(1), list.first())
} else {
getMaxValue(list.drop(1), acc)
}
}

Recursion

when {
} else {
}
}
종료조건

Recursion

when {
} else {
}
} 종료조건으로 수렴하는 로직

Function Type
val functionType: () -> Unit

Function Type
Input

Function Type
Input
Output

Function Type
val functionType1: (Int) -> Unit
val functionType2: (Int, String) -> Unit

Function Type
functionType = { println("FP") }
functionType1 = { value -> println(value.toString()) }
functionType2 = { intValue, stringValie ->
println("intValue $intValue, stringValue $stringValie")
}

Function Type
functionType = { println("FP") }
functionType1 = { value -> println(value.toString()) }
functionType2 = { intValue, stringValie ->
println("intValue $intValue, stringValue $stringValie")
}
functionType() // FP
functionType1(10) // 10
functionType2(10, "FP") // intValue 10, stringVAlue FP

• 연습문제 2:

• Int 타입 2개를 입력받아서, 입력받은 두 값을 곱한 결과 값 을
반환하는 함수타입 프로퍼티 product를 만들어 보자.
Function Type

• 연습문제 2:

• Int 타입 2개를 입력받아서, 입력받은 두 값을 곱한 결과 값 을
반환하는 함수타입 프로퍼티 product를 만들어 보자.

• 연습문제 2:

• String 타입 3개를 입력받아서, 하나의 스트링으로 합쳐주는 함
수타입 프로퍼티 appendStrings 를 만들어보자.
Function Type

• Pass a function as an Argument

• Return a function

• Assign a function to a data structure
First Class Citizen

First Class Citizen
fun function(param: () -> Unit) {
// something
}

First Class Citizen
fun function2(): () -> Unit {
return { println("FP") }
}

First Class Citizen
val value1: () -> Unit = { println("FP") }

First Class Citizen
val value2: List<() -> Unit> = listOf({ println("FP") })

First Class Citizen
val value2: List<() -> Unit> = listOf({ println("FP") })
val value3: Map<String, () -> Unit> =
mapOf("FP" to { println("FP") })

Higher-order function


• Pass a function as an Argument OR Return a function

fun higherOrderFunction1(func: () -> Unit) {
func()
}

fun higherOrderFunction2(): () -> Unit {
}

fun higherOrderFunction1(func: () -> Unit) {
func()
}
fun higherOrderFunction2(): () -> Unit {
}
fun higherOrderFunction3(func: () -> Unit): () -> Unit {
return func
}

CallByName
fun callByName(): () -> String = {
println("callByName")
// shomething
"callByName"
}

CallByName
// shomething
"callByName"
}
fun callByValue(): String {
println("callByValue")
return "callByValue"
}

CallByName
callByName() // ""
callByValue() // "callByValue"
}
// shomething
"callByName"
}
}

CallByName
callByName()() // "callByName"
callByValue() // "callByValue"
}
// shomething
"callByName"
}
}

CallByName
개념은 알겠는데... 그래서??

CallByName
fun doCallByName(condtion: Boolean, callByName: () -> String) {
if (condtion) {
callByName()
}
}
fun doCallByValue(condtion: Boolean, callByValue: String) {
if (condtion) {
callByValue
}
}

CallByName
if (condtion) {
callByValue
}
}
return "FP"
}
doCallByValue(true, callByValue())
// "callByValue"

CallByName
if (condtion) {
callByValue
}
}
return "FP"
}
doCallByValue(true, callByValue())
// "callByValue"
doCallByValue(false, callByValue())
// "callByValue"

CallByName
if (condtion) {
callByName()
}
}
// shomething
"FP"
}
doCallByName(true, callByName())
// "callByName"

CallByName
if (condtion) {
callByName()
}
}
// shomething
"FP"
}
doCallByName(true, callByName())
// "callByName"
doCallByName(false, callByName())
// ""

CallByName
• 함수의 값을 전달하지 않고 함수의 이름을 전달 할수 있다.

CallByName

• 함수의 이름을 전달하면, 전달하는 시점에 함수가 실행되지 않는다.

CallByName


• 특정 상황에 따라 크고 무거운 연산을 하거나 하지 않을 경우 이름
에 의한 호출을 하면 훨씬 효율적이다.

CallByName


• 특정 상황에 따라 크고 무거운 연산을 하거나 하지 않을 경우 이름
에 의한 호출을 하면 훨씬 효율적이다.
게으른 연산(Lazy Evaluation)

Partial Applied Function
• Partial Applied Function

• Curring

val func: (Int, Int) -> Int = { x, y -> x + y }
println(func(5, 10)) // 15

val func: (Int, Int) -> Int = { x, y -> x + y }
println(func(5, 10)) // 15
x 값은 알고있지만 y는 나중에 알수 있다면??

fun <P1, P2, R> ((P1, P2) -> R).partialAppliedFunction(x: P1): (P2) -> R {
return { p2 -> this(x, p2) }
}

val partial = func.partialAppliedFunction(5)
// doSomething

val partial = func.partialAppliedFunction(5)
// doSomething
println(partial(10)) // 15

val multiThree = { x: Int, y: Int, z: Int -> x * y * z }
println(multiThree(1, 2, 3)) // 6

x 값은 알고있지만 y, z 는 나중에 알수 있다면??

fun <P1, P2, P3, R> ((P1, P2, P3) -> R).partialAppliedFunction(x: P1): (P2, P3) -> R {
return { p2, P3 -> this(x, p2, P3) }
}

val partial2 = multiThree.partialAppliedFunction(1)
println(partial2(2, 3)) // 6

• 연습문제 3:

• 입력값 4개를 중 2개를 먼저 입력받고 나머지 2개는 나중에 받
는 (P1, P2, P3, P4) -> R의 확장함수 면서 부분 함수인
partialAppliedFunction을 만들자.

• Int값 4개를 입력받아서 모든 값을 더한 결과를 반환하는 함수타
입 프로퍼티 sumFour 를 만들자.

• sumFor에 partialAppliedFunction을 적용해보자.

• Curring

• Curring
x 값은 컴파일 타임에 알고 있지만 y, z값은 런타임에 각각 전달받는다면?

• Curring
fun <P1, P2, P3, R> ((P1, P2, P3) -> R).curried(): (P1) -> (P2) -> (P3) -> R =
{ p1: P1 -> { p2: P2 -> { p3: P3 -> this(p1, p2, p3) } } }

• Curring
{ p1: P1 -> { p2: P2 -> { p3: P3 -> this(p1, p2, p3) } } }
val curriedMultiThree = multiThree.curried()
println(curriedMultiThree(1)(2)(3)) // 6

• Curring
{ p1: P1 -> { p2: P2 -> { p3: P3 -> this(p1, p2, p3) } } }
val p1 = curriedMultiThree(1)
// doSomething

• Curring
{ p1: P1 -> { p2: P2 -> { p3: P3 -> this(p1, p2, p3) } } }
// doSomething
val p2 = p1(2)
// doSomething

• Curring
{ p1: P1 -> { p2: P2 -> { p3: P3 -> this(p1, p2, p3) } } }
// doSomething
val p2 = p1(2)
// doSomething
val p3 = p2(3)
// doSomething
println(p3) //6

Collection(Stream)
• map

• ﬁlter

• drop

• dropWhile

• take

• groupBy

• fold, foldRight

Collection(Stream)
• map
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

Collection(Stream)
• map
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• map
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.map { value -> value * value })
// [1, 4, 9, 16, 25, 36]

Collection(Stream)
• ﬁlter
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
return filterTo(ArrayList<T>(), predicate)
}

Collection(Stream)
• ﬁlter
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• ﬁlter
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.filter { value -> value % 2 == 0 })
// [2, 4, 6]

Collection(Stream)
• drop
public fun <T> Iterable<T>.drop(n: Int): List<T> {
require(n >= 0) { "Requested element count $n is less than zero." }
if (n == 0) return toList()
val list: ArrayList<T>
if (this is Collection<*>) {
val resultSize = size - n
if (resultSize <= 0)
return emptyList()
if (resultSize == 1)
return listOf(last())
list = ArrayList<T>(resultSize)
if (this is List<T>) {
if (this is RandomAccess) {
for (index in n until size)
list.add(this[index])
} else {
for (item in listIterator(n))
list.add(item)
}
return list
}
}
else {
list = ArrayList<T>()
}
var count = 0
for (item in this) {
if (count++ >= n) list.add(item)
}
return list.optimizeReadOnlyList()
}

Collection(Stream)
• drop
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• drop
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.drop(1))
// [2, 3, 4, 5, 6]

Collection(Stream)
• dropWhile
public inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T> {
var yielding = false
val list = ArrayList<T>()
for (item in this)
if (yielding)
list.add(item)
else if (!predicate(item)) {
list.add(item)
yielding = true
}
return list
}

Collection(Stream)
• dropWhile
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• dropWhile
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.dropWhile { value -> value < 3 })
// [3, 4, 5, 6]

Collection(Stream)
• ﬁlter vs dropWhile

Collection(Stream)
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.dropWhile { value -> value % 2 == 1 })

Collection(Stream)
val list = listOf(1, 2, 3, 4, 5, 6)
// [1, 3, 5]
println(list.dropWhile { value -> value % 2 == 1 })
// [2, 3, 4, 5, 6]

Collection(Stream)
• take
public fun <T> Iterable<T>.take(n: Int): List<T> {
require(n >= 0) { "Requested element count $n is less than zero." }
if (n == 0) return emptyList()
if (this is Collection<T>) {
if (n >= size) return toList()
if (n == 1) return listOf(first())
}
var count = 0
val list = ArrayList<T>(n)
for (item in this) {
if (count++ == n)
break
list.add(item)
}
return list.optimizeReadOnlyList()
}

Collection(Stream)
• take
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• take
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.take(3))
// [1, 2, 3]

Collection(Stream)
• groupBy
public inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>> {
return groupByTo(LinkedHashMap<K, MutableList<T>>(), keySelector)
}

Collection(Stream)
• groupBy
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• groupBy
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.groupBy { value -> value % 2 })
// {1=[1, 3, 5], 0=[2, 4, 6]}

Collection(Stream)
• fold
public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R {
var accumulator = initial
for (element in this) accumulator = operation(accumulator, element)
return accumulator
}

Collection(Stream)
• fold
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• fold
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.fold(0) { acc, value -> acc + value })
// 21

Collection(Stream)
• foldRight
public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R {
var accumulator = initial
if (!isEmpty()) {
val iterator = listIterator(size)
while (iterator.hasPrevious()) {
accumulator = operation(iterator.previous(), accumulator)
}
}
return accumulator
}

Collection(Stream)
• foldRight
val list = listOf(1, 2, 3, 4, 5, 6)

Collection(Stream)
• foldRight
val list = listOf(1, 2, 3, 4, 5, 6)
println(list.foldRight(0) { value, acc -> acc + value })
// 21

Collection(Stream)
• foldLeft vs foldRight
list1 = listOf("a", "b", "c", "d", "e", "f")
println(list1.foldRight("") { value, acc -> acc + value })
println(list1.fold("") { acc, value -> acc + value })

Collection(Stream)
// abcdef

Collection(Stream)
// fedcba
// abcdef

연습문제
• exercise4 파일에 있는 list와 collection api를 사용해서 새로운
list를 만들자.

• 나이가 30 이상이고, single 인 사람들의 이름을 반환

연습문제
• exercise4 파일에 있는 list와 collection api를 사용해서 새로운
list를 만들자.

• 나이가 30 이상이고, single 인 사람들의 이름을 반환
list.filter { person -> person.age > 30 }
.filter { person -> person.single }
.map { person -> person.name }

Algebraic Data Type
• ProductType / SumType

• Pattern Matching

Algebraic Data Type
interface RGBInterface
class Red : RGBInterface
class Green : RGBInterface
class Blue : RGBInterface
data class Dog(val name: String, val age: Int)
enum class RGB {
RED, GREEN, BLUE
}
sealed class Option<out T>
data class Just<T>(val value: T) : Option<T>()
object None : Option<Nothing>()

Algebraic Data Type
• ProductType

Algebraic Data Type
• ProductType
. . .
. . .
… : RGBInterface
… : RGBInterface

Algebraic Data Type
• ProductType

Algebraic Data Type
• ProductType
Dog("A", 1)
Dog("B", 1)
Dog("B", 2)
Dog("C", 1)
Dog("C", 2)
Dog("C", 3)
. . .
. . .

Algebraic Data Type
• SumType
enum class RGB {
RED, GREEN, BLUE
}

Algebraic Data Type
• SumType
enum class RGB {
RED, GREEN, BLUE
}
RED or GREEN or BLUE

Algebraic Data Type
• SumType

Algebraic Data Type
• SumType
Just or None

Algebraic Data Type
• Pattern matching

Algebraic Data Type
• Pattern matching (Product Type)
val rgb: RGBInterface = Red()
val result = when (rgb) {
is Red -> "Red"
is Green -> "Green"
is Blue -> "Blue"
else -> throw IllegalArgumentException()
}

Algebraic Data Type
val rgb: RGBInterface = Red()
is Red -> "Red"
is Green -> "Green"
is Blue -> "Blue"
}
Pink 가 추가 된다면?

Algebraic Data Type
interface ColorInterface
class Red : ColorInterface
class Green : ColorInterface
class Blue : ColorInterface
class Pink: ColorInterface

Algebraic Data Type
val rgb: ColorInterface = Pink()
is Red -> "Red"
is Green -> "Green"
is Blue -> "Blue"
}

Algebraic Data Type
is Red -> "Red"
is Green -> "Green"
is Blue -> "Blue"
}
Compile ok

Algebraic Data Type
is Red -> "Red"
is Green -> "Green"
is Blue -> "Blue"
}
Runtime crash

Algebraic Data Type
• Pattern matching (Sum Type)

Algebraic Data Type
val rgb2: RGB = RGB.RED
val result2 = when (rgb2) {
RGB.RED -> "Red"
RGB.BLUE -> "Blue"
RGB.GREEN -> "Green"
}

Algebraic Data Type
RGB.RED -> "Red"
RGB.BLUE -> "Blue"
}
ProductType가 다르게 else가 필요 없다.

Algebraic Data Type
RGB.RED -> "Red"
RGB.BLUE -> "Blue"
}
ProductType가 다르게 else가 필요 없다.
Pink 가 추가 된다면?

Algebraic Data Type
enum class COLOR {
RED, GREEN, BLUE, PINK
}

Algebraic Data Type
val rgb2: Color = Color.PINK
Color.RED -> "Red"
Color.BLUE -> "Blue"
Color.GREEN -> "Green"
}
Compile error

Algebraic Data Type
Color.RED -> "Red"
}
Compile error
컴파일 타임에 에러를 방지할 수 있다.

Algebraic Data Type
Color.RED -> "Red"
Color.PINK -> "Pink"
}
Compile ok

Exception
• none pureFunction

• partialFunction

• Maybe

Exception

Exception
val a = 5
val result = func(a)
println(result) // 2
}
fun func(value: Int): Int {
return 10 / value
}

Exception
val b = 0
val result = func(b)
println(result)
// java.lang.ArithmeticException: / by zero
}
return 10 / value
}

Exception
• partialFunction
val b = 0
val result = func(b)
println(result)
// java.lang.ArithmeticException: / by zero
}
return 10 / value
}

Exception
• partialFunction
if(value == 0){
return -1
} else {
return 10 / value
}
}
fun func2(value: Int): Int? {
if(value == 0){
return null
} else {
return 10 / value
}
}
fun func3(value: Int): Int {
if(value == 0){
return throw ArithmeticException("")
} else {
return 10 / value
}
}
fun func4(value: Int): Int {
return try {
10 / value
} catch (e: Exception) {
-1
}
}

Exception
• partialFunction
return try {
10 / value
-1
}
}
fun func2(x: Int, y: Int): Int {
return x * y
}

Exception
• partialFunction
val a = 0
val b = 10
val result2 = func2(result, b)
println(result2) // -10
}
return try {
10 / value
-1
}
}
return x * y
}

Exception
• partialFunction
return try {
10 / value
-1
}
}
return x * y
}
val a = 0
val b = 10
val result2 = func2(result, b)
}

Exception
• partialFunction
return try {
10 / value
-1
}
}
return x * y
}
val a = 0
val b = 10
val result2 = if (result != -1) {
func2(result, b)
} else {
-1
}
}

Exception
• partialFunction
return try {
10 / value
-1
}
}
return try {
x * y
-1
}
}
val a = 0
val b = 10
func2(result, b)
} else {
-1
}
}

Exception
• partialFunction

• -1을 예외상황에 사용한다면 실제값이 -1인 상황을 예외로 인식
할수 있다.

• Null 이나 exception을 사용하면 순수함수라고 할 없으며, 비즈
니스 로직의 흐름이 끊겨버린다.

• 앞의 결과를 다음 로직에 사용 하려면 항상 값 체크를 해줘야 한
다.

Exception
• Maybe
sealed class Maybe<out T>
data class Just<T>(val value: T) : Maybe<T>()
object None : Maybe<Nothing>()

Exception
• Maybe
sealed class Maybe<out T>
data class Just<T>(val value: T) : Maybe<T>()
object None : Maybe<Nothing>()
• 값이 있으면 Just

• 값이 없으면 None

Exception
• Maybe
return try {
10 / value
-1
}
}

Exception
• Maybe
fun func(value: Int): Maybe<Int> {
return try {
Just(10 / value)
None
}
}

Exception
• Maybe
그래서?

Exception
• Maybe
val a = 0
val b = 10
func2(result, b)
} else {
-1
}
}

Exception
• Maybe
val a = 0
val b = 10
val result2 = when (result) {
is Just -> func2(result.value, b)
None -> None
}
when(result2){
is Just -> println(result2.value)
None -> println("none")
}
}

Exception
• Maybe
sealed class Maybe<out T> {
abstract fun <R> map(transformer: (T) -> R): Maybe<R>
}
data class Just<T>(val value: T) : Maybe<T>() {
override fun <R> map(transformer: (T) -> R): Just<R> =
Just(transformer(value))
}
object None : Maybe<Nothing>() {
override fun <R> map(transformer: (Nothing) -> R): Maybe<R> =
None
}

Exception
• Maybe
val a = 0
val b = 10
val result2 = result.map { value -> func2(value, b) }
when (result2) {
is Just -> println(result2.value)
None -> println("none")
}
}

Exception
• Maybe
val result = func(0)
func2(result, 10)
} else {
-1
}
val result3 = if (result2 != -1) {
func2(result2, 0)
} else {
-1
}
val result4 = if (result3 != -1) {
func2(result3, 4)
} else {
-1
}

Exception
• Maybe
val result = func(0)
.map { func2(it, 10) }
println(result) // -1

실습
• IntelliJ를 실행하고 GitHub 에서 소스 다운

• https://github.com/myeonginwoo/t-academy

실습
• head 를 추가하는 addHead를 추가하자.

실습
• head 를 추가하는 addHead를 추가하자.
fun <T> FpList<T>.addHead(value: T): FpList<T> = when (this) {
Nil -> Cons(value, Nil)
is Cons -> Cons(value, this)
}

실습
• FpList<Int>의 모든 요소들의 합을 구하는 sum 함수를 일반재귀,
꼬리재귀로 만들어보자.

실습
• FpList<Int>의 모든 요소들의 합을 구하는 sum 함수를 일반재귀,
꼬리재귀로 만들어보자.
fun FpList<Int>.sum(): Int = when (this) {
Nil -> 0
is Cons -> head + tail.sum()
}
tailrec fun FpList<Int>.tailrecSum(acc: Int): Int =
when (this) {
Nil -> acc
is Cons -> tailrecSum(head + acc)
}

실습
• FpList의 요소중 앞에서부터 n개를 제외하는 drop 함수를 만들자.

• 요소의 개수가 n보다 크다면 요소의 빈리스트를

• 빈리스트면 n과 상관없이 빈리스트를 반환

실습
• FpList의 요소중 앞에서부터 n개를 제외하는 drop 함수를 만들자.

• 요소의 개수가 n보다 크다면 요소의 빈리스트를

tailrec fun <T> FpList<T>.drop(n: Int): FpList<T> = when(this){
Nil -> Nil
is Cons -> when(n){
0 -> this
else -> tail.drop(n-1)
}
}

실습
• FpList의 요소중 앞에서부터 n개를 반환하는 take 함수를 만들자.

• 요소의 개수가 n보다 작다면 요소의 개수만큼 반환


실습
• FpList의 요소중 앞에서부터 n개를 반환하는 take 함수를 만들자.

• 요소의 개수가 n보다 작다면 요소의 개수만큼 반환

fun <T> FpList<T>.take(n: Int): FpList<T> = when (this) {
Nil -> Nil
is Cons -> when (n) {
0 -> Nil
else -> Cons(head, tail.take(n - 1))
}
}
tailrec fun <T> FpList<T>.take(n: Int, acc: FpList<T>): FpList<T> = when (this) {
Nil -> acc
is Cons -> when (n) {
0 -> acc
else -> tail.take(n - 1, acc.appendTail(head))
}
}

실습
• 타입을 변환해주는 transformer 함수를 입력받아 다른 타입의
FpList로 반환해주는 map 함수를 일반 재귀와 꼬리재귀로 만들자.

실습
• 타입을 변환해주는 transformer 함수를 입력받아 다른 타입의
FpList로 반환해주는 map 함수를 일반 재귀와 꼬리재귀로 만들자.
fun <T, R> FpList<T>.map(transformer: (T) -> R): FpList<R> =
when (this) {
Nil -> Nil
is Cons -> Cons(transformer(head), tail.map(transformer))
}
tailrec fun <T, R> FpList<T>.map(acc: FpList<R>, transformer: (T) -> R): FpList<R> =
when (this) {
Nil -> acc
is Cons -> tail.map(acc.appendTail(transformer(head)), transformer)
}

실습
• boolean을 반환하는 predicate 함수를 입력받아 요소들 중 참인
요소들만 걸러내는 ﬁlter 함수를 일반 재귀와 꼬리재귀로 만들자.

실습
• boolean을 반환하는 predicate 함수를 입력받아 요소들 중 참인
요소들만 걸러내는 ﬁlter 함수를 일반 재귀와 꼬리재귀로 만들자.
fun <T> FpList<T>.filter(predicate: (T) -> Boolean): FpList<T> =
when (this) {
Nil -> Nil
is Cons -> if (predicate(head)) {
Cons(head, tail.filter(predicate))
} else {
tail.filter(predicate)
}
}
tailrec fun <T> FpList<T>.filter(acc: FpList<T>, predicate: (T) -> Boolean): FpList<T>
when (this) {
Nil -> acc
is Cons -> if (predicate(head)) {
tail.filter(acc.appendTail(head), predicate)
} else {
tail.filter(acc, predicate)
}
}

• 사이드 이펙트를 방지 할 수 있습니다.

• 일반적으로 코드가 간결해집니다.

• 코드의 재활용성이 높아집니다.

• 게으른 평가가 가능(LazyEvaluation)

• 타입 추론이 가능
장점

장점

장점
fun unSimple(list: List<Int>): List<Int> {
val evens = mutableListOf<Int>()
for (elem in list) {
if (elem % 2 == 0) {
evens.add(elem)
}
}
val result = mutableListOf<Int>()
for (elem in evens) {
result.add(elem * 10)
}
return result
}

장점
fun simple(list: List<Int>): List<Int> = list
.filter { it % 2 == 0 }
.map { it * 10 }

장점
val list = listOf(1, 2, 3, 4, 5)
println(unSimple(list)) //[20, 40]
println(simple(list)) //[20, 40]
}
fun unSimple(list: List<Int>): List<Int> {
val evens = mutableListOf<Int>()
for (elem in list) {
if (elem % 2 == 0) {
evens.add(elem)
}
}
val result = mutableListOf<Int>()
for (elem in evens) {
result.add(elem * 10)
}
return result
}
fun simple(list: List<Int>): List<Int> = list
.filter { it % 2 == 0 }
.map { it * 10 }

• 높은 일반화로 코드의 재활용성이 높아집니다.
장점

• 높은 일반화로 코드의 재활용성이 높아집니다.
장점
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}

• 게으른 평가가 가능(LazyEvaluation)
장점

• 타입 추론이 가능
장점

• 러닝커브가 높다.

• 국내 레퍼런스가 적다.

• 팀 전체가 관심있고 하려는 의지가 있어야 한다.

• 언어차원에서 지원해줘야 한다.
단점

단점
0
25
50
75
100
시작 함수타입 고차함수 꼬리재귀 컬렉션 모나드 ...

단점
0
25
50
75
100
시작 함수타입 고차함수 재귀 컬렉션 모나드 ...

단점

단점
FunFunStudy
https://github.com/funfunStudy/study/wiki
myeonginwoo@gmail.com

단점
2019년 3월
함수형 프로그래밍
공동 저서 출간 예정!!!

• 팀 전체가 관심있고 하려는 의지가 있어야 한다.
단점

• 언어차원에서 지원해줘야 한다.
단점

Fp basic-kotlin

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Fp basic-kotlin

Similaire à Fp basic-kotlin (20)

Plus de Myeongin Woo

Plus de Myeongin Woo (9)

Fp basic-kotlin