๊นจ์•Œ ๊ฐœ๋… ๐Ÿ“‘/Kotlin

[Kotlin] ๋žŒ๋‹ค(Lambda) ํ‘œํ˜„์‹

interfacer_han 2024. 2. 1. 12:13

#1 ๋žŒ๋‹ค ๋Œ€์ˆ˜์™€ ๋žŒ๋‹ค ํ‘œํ˜„์‹

#1-1 ๋žŒ๋‹ค ๋Œ€์ˆ˜

// ์ˆ˜ํ•™ - ํ•จ์ˆ˜์˜ ํ‘œํ˜„
f(x) = x + 1
g(x, y) = x * y + 1

// ์ˆ˜ํ•™ - ๋žŒ๋‹ค ๋Œ€์ˆ˜๋กœ ํ•จ์ˆ˜ ํ‘œํ˜„
λx. x + 1
λx. λy. x * y + 1

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ์˜ ๋žŒ๋‹ค ํ‘œํ˜„์‹(Lambda Expression)์€ ์ˆ˜ํ•™์—์„œ์˜ ๋žŒ๋‹ค(λ) ๋Œ€์ˆ˜(Lambda Calculus)์—์„œ ๋น„๋กฏ๋œ ๊ฐœ๋…์ด๋‹ค. ๋žŒ๋‹ค ๋Œ€์ˆ˜๋Š” ํ•จ์ˆ˜์— f๋‚˜ g์™€ ๊ฐ™์€ ์ด๋ฆ„์„ ๋ถ™์ด์ง€ ์•Š๋Š”๋‹ค. ํ•จ์ˆ˜์˜ ๋ชธํ†ต ์ฆ‰, ๊ณ„์‚ฐ ๋ถ€๋ถ„๋งŒ์„ ๋‹จ์ˆœํ•˜๊ฒŒ ํ‘œํ˜„ํ•œ๋‹ค.

 

#1-2 ๋žŒ๋‹ค ํ‘œํ˜„์‹

// ์ฝ”ํ‹€๋ฆฐ - ํ•จ์ˆ˜์˜ ํ‘œํ˜„
fun f(x: Int): Int {
    return x + 1
}
fun g(x: Int, y: Int): Int {
    return x * y + 1
}

// ์ฝ”ํ‹€๋ฆฐ - ๋žŒ๋‹ค ํ‘œํ˜„์‹์œผ๋กœ ํ•จ์ˆ˜ ํ‘œํ˜„
{ x: Int -> x + 1 }
{ x: Int, y: Int -> x * y + 1 }

ํ•˜์ง€๋งŒ, ๋žŒ๋‹ค ๋Œ€์ˆ˜์—์„œ ํ•จ์ˆ˜๋ฅผ ํ‘œํ˜„ํ•  ๋•Œ ์‚ฌ์šฉํ•˜๋Š” ๋žŒ๋‹ค(λ) ๊ธฐํ˜ธ๋ฅผ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” "->"(๋Œ€๋ถ€๋ถ„์˜ ๊ฒฝ์šฐ) ๋˜๋Š” "lambda"(ํŒŒ์ด์ฌ ๋“ฑ์˜ ๊ฒฝ์šฐ)๋กœ ๋ฐ”๊ฟ” ํ‘œํ˜„ํ•œ๋‹ค. ์ฆ‰, ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ์˜ ๋žŒ๋‹ค ํ‘œํ˜„์‹์€ ๋žŒ๋‹ค์—†๋Š” ๋žŒ๋‹ค์‹์ด๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, f(x) = x + 1 ๋ผ๋Š” ํ•จ์ˆ˜๋ฅผ ๋žŒ๋‹ค ๋Œ€์ˆ˜์—์„œ๋Š” λx. x + 1 ๋กœ ํ‘œํ˜„ํ•˜๊ณ  ์ฝ”ํ‹€๋ฆฐ์—์„  x -> x + 1๋กœ ํ‘œํ˜„ํ•œ๋‹ค.

 

๋˜, ๋žŒ๋‹ค ํ‘œํ˜„์‹์œผ๋กœ ํ‘œํ˜„ํ•œ ์ฝ”ํ‹€๋ฆฐ ํ•จ์ˆ˜๋Š” f๋‚˜ g๊ฐ™์€ ํ•จ์ˆ˜์˜ ์ด๋ฆ„์ด ์—†์Œ์„ ๋ณผ ์ˆ˜ ์žˆ๋‹ค. ๋žŒ๋‹ค ๋Œ€์ˆ˜์˜ ์ทจ์ง€๋Œ€๋กœ, ํ•จ์ˆ˜์„ ์ด๋ฆ„์—†์ด ํ‘œํ˜„ํ–ˆ๋‹ค. ํ•˜์ง€๋งŒ, ์žฌ๋ฏธ์žˆ๊ฒŒ๋„ ์ด๋Ÿฌํ•œ ๋žŒ๋‹ค ํ‘œํ˜„์‹ ํ•จ์ˆ˜์— ์ด๋ฆ„์„ ๋ถ™์ผ ์ˆ˜๋„ ์žˆ๋‹ค.

 

#1-3 ์ด๋ฆ„์ด ๋ถ™์€ ๋žŒ๋‹ค ํ‘œํ˜„์‹

// ์ฝ”ํ‹€๋ฆฐ - ์ด๋ฆ„์ด ๋ถ™์€ ๋žŒ๋‹ค ํ‘œํ˜„์‹
val f: (Int) -> Int = { x: Int -> x + 1 }
val g: (Int, Int) -> Int = { x: Int, y: Int -> x * y + 1 }

์™œ ์ด๋Ÿฐ ์ง“์„ ํ•˜๋ƒ๋ฉด, ๋žŒ๋‹ค ํ‘œํ˜„์‹์˜ (์ฒ˜์Œ ๋ฐฐ์šฐ๊ธฐ์—” ์–ด๋ ต์ง€๋งŒ) ๊ฐ„๊ฒฐํ•œ ๋ฌธ๋ฒ•์„ ์ทจํ•˜๋ฉด์„œ ๋™์‹œ์— (์ด๋ฆ„์„ ๋ถ™์ž„์œผ๋กœ์จ) ํ•ด๋‹น ํ•จ์ˆ˜๋ฅผ ์žฌ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ด์ ์ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

 

์˜ˆ์‹œ ์ฝ”๋“œ์— ์žˆ๋Š” (Int) -> Int ๋ฐ (Int, Int) -> Int๋Š” ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ์•„๋‹˜์— ์œ ์˜ํ•œ๋‹ค. ํ•ด๋‹น ํ‘œํ˜„์‹์€ ์ฝ”ํ‹€๋ฆฐ์˜ ํ•จ์ˆ˜ ํƒ€์ž…(Function Type) ํ‘œํ˜„์‹์œผ๋กœ ์–ด๋–ค ํ•จ์ˆ˜๊ฐ€ ๊ฐ€์ง€๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํƒ€์ž…๊ณผ ๋ฐ˜ํ™˜ ํƒ€์ž…์„ ์ •์˜ํ•˜๋Š” ํ‘œํ˜„์‹์ด๋‹ค. ํ™”์‚ดํ‘œ(->)๊ฐ€ ์žˆ๋‹ค๊ณ  ๋‹ค ๋žŒ๋‹ค ํ‘œํ˜„์‹์ธ๊ฒŒ ์•„๋‹ˆ๋‹ค.

 

#1-4 ํƒ€์ž… ์ƒ๋žต

// ํƒ€์ž… ์ƒ๋žต - ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žต
val f = { x: Int -> x + 1 }
val g = { x: Int, y: Int -> x * y + 1 }

// ํƒ€์ž… ์ƒ๋žต - ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์„ ์ƒ๋žต
val f: (Int) -> Int = { x -> x + 1 }
val g: (Int, Int) -> Int = { x, y -> x * y + 1 }

// ํƒ€์ž… ์ƒ๋žต - ๋‘˜ ๋‹ค ์ƒ๋žต (#2-3 ์ฐธ์กฐ)
val f = { println("ํ”๋“ค๋ฆฌ๋Š” ๊ฝƒ๋“ค ์†์—์„œ ๋„ค ์ƒดํ‘ธํ–ฅ์ด ๋А๊ปด์ง„๊ฑฐ์•ผ") }

#1-3์˜ ์ฝ”๋“œ์—์„œ, ์ฝ”ํ‹€๋ฆฐ์ด ์ง€์›ํ•˜๋Š” ํƒ€์ž… ์ถ”๋ก ์— ์˜๊ฑฐํ•ด ์ฝ”๋“œ์˜ ์ผ๋ถ€๋ถ„์„ ์ƒ๋žตํ•  ์ˆ˜๋„ ์žˆ๋‹ค. ๋‹จ ํ•œ๊ฐ€์ง€ ๊ฒฝ์šฐ(#2-3 ์ฐธ์กฐ)๋ฅผ ์ œ์™ธํ•˜๊ณ , ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹๊ณผ ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž… ๋‘˜ ๋‹ค๋ฅผ ์ƒ๋žตํ•  ์ˆ˜๋Š” ์—†๋‹ค. ์ฝ”ํ‹€๋ฆฐ์˜ ์ปดํŒŒ์ผ๋Ÿฌ ์ž…์žฅ์—์„œ ํƒ€์ž… ์ถ”๋ก ์ด ๋ถˆ๊ฐ€๋Šฅํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

 

#2 ๋‹ค์–‘ํ•œ ์ƒํ™ฉ์—์„œ์˜ ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋ฌธ๋ฒ•

#2-1 ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์—†๋Š” ๊ฒฝ์šฐ์˜ ํ‘œํ˜„

// ๊ธฐ๋ณธ (ํƒ€์ž… ์ƒ๋žต ์•ˆ ํ•จ)
val noParameterLambda: () -> String = { () ->

    "Hello, World!"
}

// ํƒ€์ž… ์ƒ๋žต - ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žต
val noParameterLambda = { () ->
    "Hello, World!"
}

// ํƒ€์ž… ์ƒ๋žต - ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์„ ์ƒ๋žต
val noParameterLambda: () -> String = {
    "Hello, World!"
}

๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์—†๋‹ค๋ฉด ()์™€ ๊ฐ™์ด ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์˜ ๊ด„ํ˜ธ ์•ˆ์— ์•„๋ฌด๊ฒƒ๋„ ๋„ฃ์ง€ ์•Š์œผ๋ฉด ๋œ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜, ์ด๋Š” ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์—์„œ๋งŒ ๊ฐ€๋Šฅํ•˜๊ณ  ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž… ๋ถ€๋ถ„์—์„  ๋ฌธ๋ฒ•์ƒ ๋ถˆ๊ฐ€๋Šฅํ•˜๋‹ค. ๊ฐ€๋Šฅํ•˜๊ฒŒ ๋งŒ๋“ค์–ด์ค˜๋„ ๊ดœ์ฐฎ์„ ๊ฒƒ ๊ฐ™์€๋ฐ ์™œ ๋ง‰์•„๋†จ๋Š”์ง€ ์˜๋ฌธ์ด ๋“ ๋‹ค. ์•„๋ฌดํŠผ, ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์—†๋Š” ๊ฒฝ์šฐ ๋ฐ˜๋“œ์‹œ ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์ด ์ƒ๋žต๋œ ํ˜•ํƒœ๋กœ๋งŒ ํ•จ์ˆ˜๋ฅผ ์งค ์ˆ˜ ์žˆ๋‹ค.

 

#2-2 return์„ ํ•˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ (์ž๋ฐ”๋กœ ์น˜๋ฉด, ๋ฆฌํ„ด ํƒ€์ž…์ด void)์˜ ํ‘œํ˜„

// ๊ธฐ๋ณธ (ํƒ€์ž… ์ƒ๋žต ์•ˆ ํ•จ)
val noReturnTypeLambda: (Int, String) -> Unit = { number: Int, text: String ->
    println("Received number: $number and text: $text")
}

// ํƒ€์ž… ์ƒ๋žต -ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žต (์—๋Ÿฌ๊ฐ€ ๋‚˜์ง„ ์•Š์ง€๋งŒ, ์‚ฌ์šฉ์„ ์ง€์–‘ํ•˜์ž.)
val noReturnTypeLambda = { number: Int, text: String ->
    println("Received number: $number and text: $text")
}

// ํƒ€์ž… ์ƒ๋žต - ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์„ ์ƒ๋žต
val noReturnTypeLambda: (Int, String) -> Unit = { number, text ->
    println("Received number: $number and text: $text")
}

ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์—์„œ ํ•จ์ˆ˜์˜ return์ด ์—†๋Š” ๊ฒฝ์šฐ return ํƒ€์ž… ์ž๋ฆฌ์— Unit์„ ๋„ฃ๋Š”๋‹ค. Unit์€ ์ž๋ฐ”์˜ void์— ๋Œ€์‘๋˜๋Š” ํ‚ค์›Œ๋“œ๋‹ค. return์ด ์—†๋Š” ํ•จ์ˆ˜์—์„œ ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žตํ•˜๋ฉด ์ฝ”ํ‹€๋ฆฐ์˜ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ํƒ€์ž… ์ถ”๋ก ์„ ํ†ตํ•ด return ํƒ€์ž…์„ ์ •ํ•œ๋‹ค. ํ•˜์ง€๋งŒ ์›ฌ๋งŒํ•ด์„œ๋Š” ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žตํ•˜์ง€ ๋ง์ž.

 

์ƒ๋žตํ•œ๋‹ค๊ณ  ์—๋Ÿฌ๊ฐ€ ๋‚˜๋Š” ๊ฑด ์•„๋‹ˆ๋‹ค. ์ค‘๊ฐ„์— ์žˆ๋Š” ์ฝ”๋“œ๋ฅผ ๋ณต์‚ฌํ•ด์„œ ์ฝ”ํ‹€๋ฆฐ IDE์— ๋ถ™์—ฌ๋†“์œผ๋ฉด ์ž˜ ์ž‘๋™ํ•˜๋Š” ๋ชจ์Šต์„ ๋ณผ ์ˆ˜ ์žˆ๋‹ค. ํ•˜์ง€๋งŒ, ํ•ด๋‹น ์ฝ”๋“œ๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ์˜ ํ†ต์ œ๋ฅผ ๋ฒ—์–ด๋‚œ ์ฝ”๋“œ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ์–ด๋–ค ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ return ํƒ€์ž…์ด ์—†๋Š” ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค๊ธฐ๋กœ ๋งˆ์Œ๋จน์—ˆ์œผ๋‚˜, ์–ด์ฉŒ๋‹ค ์‹ค์ˆ˜๋กœ ์ค‘๊ด„ํ˜ธ ๋์— { ... "์•„๋ฌด๋ง" }์™€ ๊ฐ™์ด String ๊ฐ์ฒด๋ฅผ ๋ฐฐ์น˜ํ•˜๋ฉด ํƒ€์ž… ์ถ”๋ก ์— ์˜ํ•ด ํ•ด๋‹น ํ•จ์ˆ˜์˜ return ํƒ€์ž…์€ String์ด ๋˜์–ด๋ฒ„๋ฆฐ๋‹ค. ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ํ†ตํ•ด ์–ป์„ ์ˆ˜ ์žˆ๋Š” return ํƒ€์ž…์˜ ๋ช…์‹œ์„ฑ์„ ์ด์šฉํ•˜๋Š” ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ๋˜์ž.

 

#2-3 ๋งค๊ฐœ๋ณ€์ˆ˜๋„ ์—†๊ณ  return๋„ ํ•˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ์˜ ํ‘œํ˜„

// ๊ธฐ๋ณธ (ํƒ€์ž… ์ƒ๋žต ์•ˆ ํ•จ)
val noParaNoReturn: () -> Unit = { () ->

    println("This is a lambda with no parameters and no return type.")
}

// ํƒ€์ž… ์ƒ๋žต - ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹์„ ์ƒ๋žต
val noParaNoReturn = { () ->
    println("This is a lambda with no parameters and no return type.")
}

// ํƒ€์ž… ์ƒ๋žต - ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์„ ์ƒ๋žต
val noParaNoReturn: () -> Unit = {
    println("This is a lambda with no parameters and no return type.")
}

---

// ํƒ€์ž… ์ƒ๋žต - ๋‘˜ ๋‹ค ์ƒ๋žต
val noParaNoReturn = {
    println("ํ”๋“ค๋ฆฌ๋Š” ๊ฝƒ๋“ค ์†์—์„œ ๋„ค ์ƒดํ‘ธํ–ฅ์ด ๋А๊ปด์ง„๊ฑฐ์•ผ")
}

#2-1๊ณผ #2-2์˜ ๊ต์ง‘ํ•ฉ์€, ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์ด ์ƒ๋žต๋œ ํ˜•ํƒœ๋‹ค. ๋”ฐ๋ผ์„œ, ํ•ด๋‹น ํ˜•ํƒœ๋กœ๋งŒ ํ•จ์ˆ˜๋ฅผ ์งค ์ˆ˜ ์žˆ๋‹ค. ์ถ”๊ฐ€๋กœ, ๋งค๊ฐœ๋ณ€์ˆ˜์™€ ๋ฆฌํ„ด์ด ๋‘˜๋‹ค ์—†๋Š” ๊ฒฝ์šฐ์—๋Š” ํ•จ์ˆ˜ ํƒ€์ž… ํ‘œํ˜„์‹๊ณผ ๋žŒ๋‹ค ํ‘œํ˜„์‹ ๋‚ด๋ถ€์˜ ๋งค๊ฐœ๋ณ€์ˆ˜ ํƒ€์ž…์„ ๋‘˜ ๋‹ค ์ƒ๋žตํ•  ์ˆ˜ ์žˆ๋‹ค. ์ด ๋•Œ๋Š” ํ™”์‚ดํ‘œ(->)๋งˆ์ € ์ƒ๋žตํ•œ๋‹ค. ์ด๋Š” ๋‘˜ ๋‹ค ์ƒ๋žตํ•  ์ˆ˜ ์žˆ๋Š” ๋‹จ ํ•œ ๊ฐ€์ง€์˜ ํŠน๋ณ„ ์ผ€์ด์Šค๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ด ํŠน๋ณ„ ์ผ€์ด์Šค์˜ ์กด์žฌ ๋•Œ๋ฌธ์— ๋žŒ๋‹ค์‹์€ ๋ฐ˜๋“œ์‹œ ํ™”์‚ดํ‘œ(->)๋ฅผ ๊ฐ€์ง„๋‹ค๊ณ  ๋งํ•  ์ˆ˜ ์—†๊ฒŒ ๋œ๋‹ค.

 

#2-4 it ํ‚ค์›Œ๋“œ (๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ํ•˜๋‚˜์ธ ๊ฒฝ์šฐ)

// ํ‰๋ฒ”ํ•œ ๋žŒ๋‹ค ํ‘œํ˜„์‹
val f: (Int) -> Int = { x: Int -> x + 1 }

// it์„ ์‚ฌ์šฉํ•œ ๋žŒ๋‹ค ํ‘œํ˜„์‹
val f: (Int) -> Int = { it + 1 }

 it(๊ทธ๊ฑฐ)๋ผ๋Š” ํ‚ค์›Œ๋“œ๋กœ ํ•ด๋‹น ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค. ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ํ•˜๋‚˜์ผ ๋•Œ๋งŒ it ํ‚ค์›Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค. it์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ƒํ™ฉ์ด๋ฉด, ์ค‘๊ด„ํ˜ธ { ... } ๋‚ด๋ถ€์—์„œ ํ™”์‚ดํ‘œ์™€ ๊ทธ ์™ผ์ชฝ ๋ถ€๋ถ„์„ ์ƒ๋žตํ•ด๋„ ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š๋Š”๋‹ค.

 

#2-5 ์†Œ๊ด„ํ˜ธ ์ƒ๋žต (์ธ์ž๋กœ ์“ฐ์ธ ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ๋งˆ์ง€๋ง‰ ์ธ์ž์ธ ๊ฒฝ์šฐ)

class calculator(
    val args1: Int,
    val args2: Int,
    val args3: (Int, Int) -> Int
) {
    fun additionOperation(): Int {
        return args1 + args2
    }
    fun differenceOperation(): Int {
        return Math.abs(args1 - args2)
    }
    fun customOperation(): Int {
        return args3(args1, args2)
    }
}

fun main() {
    val myCalculator1 = calculator(3, 4, {x, y -> (x * x) + y}) // ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ์†Œ๊ด„ํ˜ธ ์•ˆ์— ์žˆ์Œ
    val myCalculator2 = calculator(3, 4) {x, y -> (x * x) + y} // ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ์†Œ๊ด„ํ˜ธ ๋ฐ–์— ์žˆ์Œ
    
    println(myCalculator1.customOperation()) // ์ถœ๋ ฅ ๊ฒฐ๊ณผ: 13
    println(myCalculator2.customOperation()) // ์ถœ๋ ฅ ๊ฒฐ๊ณผ: 13
}

์ฝ”ํ‹€๋ฆฐ์—์„  ์ด์™€ ๊ฐ™์ด ๋žŒ๋‹ค ํ•จ์ˆ˜๋ฅผ ์ธ์ž๋กœ์„œ ์ „๋‹ฌํ•  ์ˆ˜ ์žˆ๋‹ค. ์ด ๋•Œ, ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ๋งˆ์ง€๋ง‰ ์ธ์ž๋กœ ์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ์šฐ์—๋Š” myCalculator2์—์„œ์ฒ˜๋Ÿผ ์†Œ๊ด„ํ˜ธ์—์„œ ๋นผ๊ณ  ๊ทธ ์˜ค๋ฅธ์ชฝ์— ์ ์–ด๋„ ๋œ๋‹ค. ์ด๋Š” ๊ฐ€๋…์„ฑ ํ–ฅ์ƒ์„ ์œ„ํ•ด ์ œ๊ณต๋˜๋Š” ํŽธ์˜์„ฑ ๋ฌธ๋ฒ•์ด๋‹ค.

 

#3 ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค์˜ ๊ตฌํ˜„

// SAM Conversions๋œ ๋‹จ์ผ ์ถ”์ƒ ๋ฉ”์†Œ๋“œ ์ธํ„ฐํŽ˜์ด์Šค
fun interface MyOperation {
    fun operate(x: Int, y: Int): Int
}

fun main() {
    val addition = MyOperation { x, y -> x + y }
    val subtraction = MyOperation { x, y -> x - y }

    val result1 = addition.operate(5, 3)
    val result2 = subtraction.operate(5, 3)

    println("Result of addition: $result1") // ์ถœ๋ ฅ ๊ฒฐ๊ณผ: 8
    println("Result of subtraction: $result2") // ์ถœ๋ ฅ ๊ฒฐ๊ณผ: 2
}

fun ํ‚ค์›Œ๋“œ์™€ ํ•จ๊ป˜ ๋‹จ์ผ ์ถ”์ƒ ๋ฉ”์†Œ๋“œ๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค์ธ ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋Š” ๋žŒ๋‹ค ํ‘œํ˜„์‹์ด ํ™œ์šฉ๋˜๋Š” ๋Œ€ํ‘œ์ ์ธ ์‚ฌ์ฒ˜๋‹ค. ์ฝ”ํ‹€๋ฆฐ์ด ์ง€์›ํ•˜๋Š” ๋ฌธ๋ฒ•์œผ๋กœ ๊ฐ„ํŽธํ•˜๊ฒŒ ๊ตฌํ˜„ ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค. ๊ทธ ๋ฌธ๋ฒ•์€ ๋ฐ”๋กœ ์–ด๋–ค ๋ณ€์ˆ˜์—, ์ธํ„ฐํŽ˜์ด์Šค ์ด๋ฆ„ + ๋žŒ๋‹ค ํ‘œํ˜„์‹์„ ํ• ๋‹นํ•˜๋ฉด ๋์ด๋‹ค. ์ด๋Ÿฌ๋ฉด ๋‚˜๋จธ์ง€๋Š” ์ฝ”ํ‹€๋ฆฐ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์•Œ์•„์„œ ์ž‘์—…ํ•œ๋‹ค. ๊ทธ ์ž‘์—…์€ ๋ฐ”๋กœ, ํ•ด๋‹น ๋žŒ๋‹ค ํ‘œํ˜„์‹ ํ•จ์ˆ˜๋ฅผ ์ธํ„ฐํŽ˜์ด์Šค์˜ ํ•˜๋‚˜ ์žˆ๋Š” ๋ฉ”์†Œ๋“œ๋กœ์„œ ์˜ค๋ฒ„๋ผ์ด๋“œํ•˜๊ณ , ์ต๋ช… ํด๋ž˜์Šค๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒƒ์ด๋‹ค (์—ฌ๊ธฐ์—์„  ๊ทธ ์ต๋ช… ํด๋ž˜์Šค๋ฅผ addition ๋ฐ subtraction์— ํ• ๋‹นํ•จ์œผ๋กœ์จ ์ด๋ฆ„ ์žˆ๋Š” ํด๋ž˜์Šค๋กœ ๋งŒ๋“ค์—ˆ๋‹ค). ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค์— ๋Œ€ํ•œ ์ž์„ธํ•œ ๋‚ด์šฉ์€ ๋‹ค์Œ ๊ฒŒ์‹œ๊ธ€์—์„œ ์‚ดํŽด๋ณผ ์ˆ˜ ์žˆ๋‹ค.

 

 

[Kotlin] ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค (Single Abstract Method Interface)

#1 ์ผ๋ฐ˜ ์ธํ„ฐํŽ˜์ด์Šค #1-1 ํ‰๋ฒ”ํ•œ ์ธํ„ฐํŽ˜์ด์Šค interface MyNormalInterface { fun myFirstMethod(value: Int): String fun mySecondMethod(value1: Int, value2: String): Int ... } ์šฐ๋ฆฌ๊ฐ€ ์ž˜ ์•Œ๊ณ ์žˆ๋Š” ์ธํ„ฐํŽ˜์ด์Šค์˜ ๋ชจ์Šต์ด๋‹ค. #1-2 ํ•จ์ˆ˜

kenel.tistory.com

 

#4 ์š”์•ฝ

๋žŒ๋‹ค ํ‘œํ˜„์‹์€ ์ฒ˜์Œ ๋ฐฐ์šฐ๊ธฐ์—” ๋ถ„๋ช… ์–ด๋ ต์ง€๋งŒ, ์“ฐ๋ฉด ์“ธ์ˆ˜๋ก ๊ทธ ๊ฐ„ํŽธํ•จ์„ ์ธ์ •ํ•˜๊ฒŒ ๋œ๋‹ค.