Fp 의 기본적인 개념을 Kotlin으로 설명.

1. Kotlin with FP
basic
우명인

2. Kotlin
• OOP 와 FP 둘다 가능한 멀티 패러다임 언어.

3. Kotlin
• OOP 와 FP 둘다 가능한 멀티 패러다임 언어.
• JetBrains 에서 개발한 언어

4. Kotlin
• OOP 와 FP 둘다 가능한 멀티 패러다임 언어.
• JetBrains 에서 개발한 언어
• JVM에서 실행되는 언어
• Java 와 100% 호환 (점진적으로 확대 적용 가능)

5. Kotlin
• OOP 와 FP 둘다 가능한 멀티 패러다임 언어.
• JetBrains 에서 개발한 언어
• JVM에서 실행되는 언어
• Java 와 100% 호환 (점진적으로 확대 적용 가능)
• Google I/O에서 Android 공식언어

6. Kotlin
• OOP 와 FP 둘다 가능한 멀티 패러다임 언어.
• JetBrains 에서 개발한 언어
• JVM에서 실행되는 언어
• Java 와 100% 호환 (점진적으로 확대 적용 가능)
• Google I/O에서 Android 공식언어
• Spring 5에서 공식 지원

7. FP
• Functional Programming이란 OOP와 전혀 다른 개념이 아
니다.
• OOP를 잘 이해하고 있어야 FP를 잘 사용 할 수 있다.

8. FP
• Functional Programming이란 OOP와 전혀 다른 개념이 아
니다.
• OOP를 잘 이해하고 있어야 FP를 잘 사용 할 수 있다.
• Immutable 한 자료구조를 사용해 SideEffect를 최소화.

9. FP
• Functional Programming이란 OOP와 전혀 다른 개념이 아
니다.
• OOP를 잘 이해하고 있어야 FP를 잘 사용 할 수 있다.
• Immutable 한 자료구조를 사용해 SideEffect를 최소화.
• 상태를 바꾸기 보다는 변경 불가능한 데이터와 순수 함수를
이용 한 프로그래밍.

10. FP
• Functional Programming이란 OOP와 전혀 다른 개념이 아
니다.
• OOP를 잘 이해하고 있어야 FP를 잘 사용 할 수 있다.
• Immutable 한 자료구조를 사용해 SideEffect를 최소화.
• 상태를 바꾸기 보다는 변경 불가능한 데이터와 순수 함수를
이용 한 프로그래밍.
• 모든 것은 객체다. (함수도 객체)

11. Variable
var testInt: Int = 32

12. Variable
var testInt: Int = 32
keyword name type
value

13. Variable
•(val or var) name: type = value
• var testInt: Int = 32

14. Variable
•(val or var) name: type = value
• var testInt: Int = 32
• var testInt = 32

15. Variable
•(val or var) name: type = value
• var testInt: Int = 32
• var testInt = 32
• val testStr: String = “Hello, World”

16. Variable
•(val or var) name: type = value
• var testInt: Int = 32
• var testInt = 32
• val testStr: String = “Hello, World”
• val testStr = “Hello, World”

17. Variable
• var
• variable
• read/write
• Java normal variable
• val
• value
• readOnly
• Java final variable

18. Variable
val immutable: String = "immutable"
var mutable: String = "mutable"
immutable = "test" // Error
mutable = "test" // Ok

19. Variable
val value: Int
value = 3 // Ok
value = 4 // Error

20. Variable
• 함수형 프로그래밍을 해보고 싶거나 SideEffect를 피하고
싶다면 var 보다는 val을 사용하는 습관이 좋습니다.

21. Variable
• 함수형 프로그래밍을 해보고 싶거나 SideEffect를 피하고
싶다면 var 보다는 val을 사용하는 습관이 좋습니다.
• 변수 선언 시: 타입 을 생략 하면 컴파일러가 추론합니다.,
하지만 명시적으로 타입을 선언해 주는게 가독성이나 유지
보수 측면에 좋습니다.

22. Variable
• 함수형 프로그래밍을 해보고 싶거나 SideEffect를 피하고
싶다면 var 보다는 val을 사용하는 습관이 좋습니다.
• 변수 선언 시: 타입 을 생략 하면 컴파일러가 추론합니다.,
하지만 명시적으로 타입을 선언해 주는게 가독성이나 유지
보수 측면에 좋습니다.
• ;(세미콜론) 은 한줄에 여러 변수를 선언하지 않는다면 생략
가능 합니다.

23. Function
fun add(x: Int, y: Int): Int {
return x + y
}

24. Function
fun add(x: Int, y: Int): Int {
return x + y
}
함수키워드 함수이름 파라미터 반환타입
Body

25. Function
fun add(x: Int, y: Int): Int = x + y
함수키워드 함수이름 파라미터 반환타입
Body

26. Function
• fun 키워드를 사용

27. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.

28. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.
• Unit은 Java의 Void와 비슷하게 생각하면 됩니다. 하지만 실제로 Unit은
Singleton 객체입니다.

29. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.
• Unit은 Java의 Void와 비슷하게 생각하면 됩니다. 하지만 실제로 Unit은
Singleton 객체입니다.
• 리턴 타입을 생략하면 default 로 반환타입은 Unit이 됩니다.

30. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.
• Unit은 Java의 Void와 비슷하게 생각하면 됩니다. 하지만 실제로 Unit은
Singleton 객체입니다.
• 리턴 타입을 생략하면 default 로 반환타입은 Unit이 됩니다.
• ;(세미콜론) 은 생략가능 합니다.

31. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.
• Unit은 Java의 Void와 비슷하게 생각하면 됩니다. 하지만 실제로 Unit은
Singleton 객체입니다.
• 리턴 타입을 생략하면 default 로 반환타입은 Unit이 됩니다.
• ;(세미콜론) 은 생략가능 합니다.
• 함수의 Body가 한줄인 경우에는 { … } 대신 = 로 대신 할 수 있습니다.

32. Function
• fun 키워드를 사용
• 함수의 반환 타입을 생략 할수 없습니다. 생략이 가능 한 경우는 반환 타입
이 Unit일 경우에만 생략이 가능합니다.
• Unit은 Java의 Void와 비슷하게 생각하면 됩니다. 하지만 실제로 Unit은
Singleton 객체입니다.
• 리턴 타입을 생략하면 default 로 반환타입은 Unit이 됩니다.
• ;(세미콜론) 은 생략가능 합니다.
• 함수의 Body가 한줄인 경우에는 { … } 대신 = 로 대신 할 수 있습니다.
• class나 object 내부에 선언하지 않고 파일 레벨에 선언 할 수 있습니다.

33. 실습
• https://try.kotlinlang.org
• -> My programs

34. First-class citizen
• 객체의 인자로 전달 할 수 있어야 한다.
• 객체의 반환값으로 반환 할 수 있어야 한다.
• 자료구조에 넣을 수 있어야 한다.

35. First-class citizen
• 객체의 인자로 전달 할 수 있어야 한다.

36. First-class citizen
• 객체의 인자로 전달 할 수 있어야 한다.
fun function(param: () -> Unit) {
param()
}
function({ println("Hello, World") })
// Hello, World

37. First-class citizen
• 객체의 반환값으로 반환 할 수 있어야 한다.

38. First-class citizen
• 객체의 반환값으로 반환 할 수 있어야 한다.
fun function(): () -> Unit {
return { println("Hello, World") }
}

39. First-class citizen
• 자료구조에 넣을 수 있어야 한다.

40. First-class citizen
• 자료구조에 넣을 수 있어야 한다.
fun function(): () -> Unit {
return { println("Hello, World") }
}
val value = function()

41. PureFunction
fun pureFunction(str: String): String {
return str + "Test"
}

42. PureFunction
fun pureFunction(str: String): String {
return str + "Test"
}
println(pureFunction("kotlin")) // kotlinTest
println(pureFunction("kotlin")) // kotlinTest
println(pureFunction("kotlin")) // kotlinTest
println(pureFunction("kotlin")) // kotlinTest

43. PureFunction
val strBuilder = StringBuilder()
fun nonePureFunction(str: String): String {
return str + strBuilder.append("Test").toString()
}

44. PureFunction
val strBuilder = StringBuilder()
fun nonePureFunction(str: String): String {
return str + strBuilder.append("Test").toString()
}
println(nonePureFunction("kotlin")) // kotlinTest
println(nonePureFunction("kotlin")) // kotlinTestTest
println(nonePureFunction("kotlin")) // kotlinTestTestTest
println(nonePureFunction("kotlin")) // kotlinTestTestTestTest

45. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}
fun simpleHighOrderFunction(a: Int, b: Int): () -> Int {
return { a + b }
}

46. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}
fun simpleHighOrderFunction(a: Int, b: Int): () -> Int {
return { a + b }
}
• 함수를 파라미터로 전달 받거나, 함수를 리턴하는 함수를
말합니다.

47. Higher-Order Function
interface Calcable {
int calc(int x, int y);
}
public class Sum implements Calcable {
@Override
public int calc(int x, int y) {
return x + y;
}
}
public class Minus implements Calcable {
@Override
public int calc(int x, int y) {
return x - y;
}
}
public class Product implements Calcable {
@Override
public int calc(int x, int y) {
return x * y;
}
}
/* Java */

48. Higher-Order Function
interface Calcable {
int calc(int x, int y);
}
public class Sum implements Calcable {
@Override
public int calc(int x, int y) {
return x + y;
}
}
public class Minus implements Calcable {
@Override
public int calc(int x, int y) {
return x - y;
}
}
public class Product implements Calcable {
@Override
public int calc(int x, int y) {
return x * y;
}
}
Calcable calcSum = new Sum();
Calcable calcMinus = new Minus();
Calcable calcProduct = new Multi();
int resultSum = calcSum.calc(1, 5); //6
int resultMinus = calcMinus.calc(5, 2); //3
int resultProduct = calcProduct.calc(4, 2); //8
/* Java */

49. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}

50. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}
val sum: (Int, Int) -> Int = { a, b -> a + b }
val product: (Int, Int) -> Int = { a, b -> a * b }
val minus: (Int, Int) -> Int = { a, b -> a - b }

51. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}
val sum: (Int, Int) -> Int = { a, b -> a + b }
val product: (Int, Int) -> Int = { a, b -> a * b }
val minus: (Int, Int) -> Int = { a, b -> a - b }
println(simpleHighOrderFunction(sum, 1, 5)) // 6
println(simpleHighOrderFunction(product, 5, 2)) // 10
println(simpleHighOrderFunction(minus, 4, 2)) // 8

52. Higher-Order Function
fun simpleHighOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int {
return sum(a, b)
}
println(simpleHighOrderFunction({ x, y -> x + y }, 1, 5))
println(simpleHighOrderFunction({ x, y -> x - y }, 5, 2))
println(simpleHighOrderFunction({ x, y -> (x * y) + y }, 4, 2))

53. Anonymous Function
val value = sum(5, 10, { x, y -> x + y }
fun sum(x: Int, y: Int, function: (Int, Int) -> Int): Int {
return function(x, y)
}

54. Anonymous Function
val value = sum(5, 10, { x, y -> x + y }
fun sum(x: Int, y: Int, function: (Int, Int) -> Int): Int {
return function(x, y)
}
Anonymous Function

55. CallByValue
val function: () -> Unit = { println("Lezhin") }
fun callByValue(): Unit {
return function()
}
callByValue() // Lezhin

56. CallByName
val function: () -> Unit = { println("Lezhin") }
fun callByName(): () -> Unit {
return function
}

57. CallByName
val function: () -> Unit = { println("Lezhin") }
fun callByName(): () -> Unit {
return function
}
callByName() // nothing

58. CallByName
val function: () -> Unit = { println("Lezhin") }
fun callByName(): () -> Unit {
return function
}
callByName() // nothing
callByName().invoke() // Lezhin
callByName()() // Lezhin

59. CallByName
val function: () -> Unit = {
// 엄청 복잡하고 엄청 리소스가 많이 들고 엄청 오래걸리는 연산
println("OTL")
}

60. CallByName
val function: () -> Unit = {
// 엄청 복잡하고 엄청 리소스가 많이 들고 엄청 오래걸리는 연산
println("OTL")
}
fun firstClassCitizenFunction(func: () -> Unit, flag: Boolean) {
if (flag) {
func()
} else {
println("finish")
}
}
firstClassCitizenFunction(function, false) //finish

61. CallByName
val function: () -> Unit = {
// 엄청 복잡하고 엄청 리소스가 많이 들고 엄청 오래걸리는 연산
println("OTL")
}
fun firstClassCitizenFunction(func: () -> Unit, flag: Boolean) {
if (flag) {
func()
} else {
println("finish")
}
}
firstClassCitizenFunction(function, false) //finish
상황에 따라 특정 함수를 호출 할 수도 있고 호출 하지 않을 수 있다면 함수의 평가를 Lazy 하게
효율적으로처리 할 수 있습니다.