Kotlin 함수 완전 정리

Kotlin code

// 기본 함수
fun add(a: Int, b: Int): Int {
    return a + b
}

// 단일 표현식 함수 (타입 추론)
fun square(n: Int) = n * n

// 기본값 파라미터
fun greet(
    name: String,
    prefix: String = "안녕하세요",
    suffix: String = "님!"
) = println("$prefix, $name$suffix")

fun main() {
    greet("Kotlin")                    // 안녕하세요, Kotlin님!
    greet("Java", "Hello")             // Hello, Java님!

    // Named argument — 순서 무관, 명확한 호출
    greet(
        name = "Go",
        suffix = "!",
        prefix = "Hi"
    )

    // vararg
    fun sum(vararg nums: Int) = nums.sum()
    println(sum(1, 2, 3, 4, 5))        // 15

    // spread operator (배열 → vararg)
    val arr = intArrayOf(1, 2, 3)
    println(sum(*arr))
}

Kotlin code

// String 확장 함수
fun String.isValidEmail(): Boolean =
    contains("@") && contains(".") && length > 5

// Int 확장 함수
fun Int.isEven() = this % 2 == 0
fun Int.factorial(): Long {
    if (this < 0) throw IllegalArgumentException("음수 불가")
    return (1..this).fold(1L) { acc, n -> acc * n }
}

// Nullable 수신자
fun String?.orEmpty(): String = this ?: ""

// Generic 확장 함수
fun <T> List<T>.secondOrNull(): T? =
    if (size >= 2) this[1] else null

fun main() {
    println("dev@kotlin.io".isValidEmail())  // true
    println(4.isEven())                       // true
    println(5.factorial())                    // 120

    val nullStr: String? = null
    println(nullStr.orEmpty())               // ""

    println(listOf(1, 2, 3).secondOrNull())  // 2
    println(listOf(1).secondOrNull())        // null
}

Kotlin code

data class Person(var name: String, var age: Int, var email: String = "")

// let — it 참조, 변환 결과 반환, null 체크 관용구
val name: String? = "  Kotlin  "
val result = name?.let { it.trim().uppercase() }
// result = "KOTLIN"

// apply — this 참조, 수신자 객체 반환 (빌더 패턴)
val person = Person("", 0).apply {
    name = "Alice"
    age = 30
    email = "alice@example.com"
}

// also — it 참조, 수신자 객체 반환 (부가 작업)
val numbers = mutableListOf(3, 1, 4, 1, 5)
    .also { println("원본: $it") }
    .sorted()
    .also { println("정렬: $it") }

// run — this 참조, 람다 결과 반환
val greeting = person.run {
    "안녕, $name! 당신은 ${age}살입니다."
}

// with — 수신자를 인자로, 람다 결과 반환
val info = with(person) {
    "$name ($age세) — $email"
}

Kotlin code

import kotlin.reflect.KClass

// inline — 고차함수 성능 최적화
inline fun measure(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

// reified — 런타임 타입 정보 유지
inline fun <reified T> List<*>.filterIsInstance(): List<T> =
    filter { it is T }.map { it as T }

// reified로 JSON 파싱 패턴
inline fun <reified T> parseJson(json: String): T {
    // 실제로는 Gson/Moshi 사용
    // T::class.java 접근 가능!
    println("파싱 타입: ${T::class.simpleName}")
    TODO("실제 파싱 구현")
}

// noinline — 일부 람다만 인라인 제외
inline fun doWork(
    inlined: () -> Unit,
    noinline notInlined: () -> Unit
) {
    inlined()
    val saved = notInlined  // 객체로 저장 가능
    saved()
}

fun main() {
    val time = measure { Thread.sleep(10) }
    println("${time}ms 소요")

    val mixed = listOf(1, "hello", 2, "world", 3)
    val strings: List<String> = mixed.filterIsInstance()
    println(strings)  // [hello, world]
}

Kotlin code

<span class="cm">// Delegated Properties 심화 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("Delegated Properties 심화") }

Kotlin code

tailrec fun factorial(n: Long, acc: Long = 1L): Long =
    if (n <= 1) acc
    else factorial(n - 1, n * acc)

tailrec fun gcd(a: Int, b: Int): Int =
    if (b == 0) a else gcd(b, a % b)

tailrec fun findIndex(
    list: List<Int>, target: Int, index: Int = 0
): Int = when {
    index >= list.size -> -1
    list[index] == target -> index
    else -> findIndex(list, target, index + 1)
}

fun main() {
    println(factorial(20))        // 2432902008176640000
    println(gcd(48, 18))          // 6
    println(findIndex(listOf(3, 7, 1, 9), 1)) // 2
}

Kotlin code

infix fun Int.power(exp: Int): Long {
    var result = 1L
    repeat(exp) { result *= this }
    return result
}

infix fun <T> T.shouldBe(expected: T) {
    if (this != expected)
        throw AssertionError("Expected $expected but got $this")
    println("✓ $this == $expected")
}

class Route(val path: String) {
    infix fun to(handler: (String) -> String) =
        println("$path → ${handler(path)}")
}

fun main() {
    println(2 power 10)          // 1024
    "Hello" shouldBe "Hello"     // ✓

    Route("/api/users") to { "GET $it" }
}

Kotlin code

data class Money(val amount: Int, val currency: String) {
    operator fun plus(other: Money): Money {
        require(currency == other.currency) { "통화 불일치" }
        return Money(amount + other.amount, currency)
    }
    operator fun compareTo(other: Money): Int {
        require(currency == other.currency) { "통화 불일치" }
        return amount.compareTo(other.amount)
    }
}

// 확장 연산자 함수
operator fun Money.times(factor: Int) =
    Money(amount * factor, currency)

fun main() {
    val a = Money(1000, "KRW")
    val b = Money(2000, "KRW")

    println(a + b)        // Money(3000, KRW)
    println(a * 3)        // Money(3000, KRW)
    println(a > b)        // false (compareTo 사용)
}

Kotlin code

fun validateUser(name: String, email: String, age: Int) {
    // 지역 함수: 외부 파라미터에 직접 접근
    fun validateField(value: String, field: String) {
        if (value.isBlank())
            throw IllegalArgumentException("$field 은(는) 필수입니다")
    }

    fun validateAge() {
        if (age !in 1..150)
            throw IllegalArgumentException("나이($age)가 유효하지 않습니다")
    }

    validateField(name, "이름")
    validateField(email, "이메일")
    validateAge()

    println("검증 통과: $name, $email, $age")
}

fun main() {
    validateUser("김철수", "kim@test.com", 25)
    // validateUser("", "test@test.com", 25) // 예외!
}

Kotlin code

fun main() {
    // 익명 함수: return이 자기 자신에서 반환
    val square = fun(x: Int): Int {
        return x * x
    }

    // 람다: return은 외부 함수에서 반환 (비지역 반환)
    val items = listOf(1, 2, 3, 4, 5)

    // 익명 함수 사용 - 필터링에서 안전
    val evens = items.filter(fun(n: Int): Boolean {
        return n % 2 == 0
    })

    // 여러 반환 지점이 필요한 경우
    val classify = fun(score: Int): String {
        if (score >= 90) return "A"
        if (score >= 80) return "B"
        if (score >= 70) return "C"
        return "F"
    }

    println(square(5))           // 25
    println(evens)               // [2, 4]
    println(classify(85))        // B
}

Kotlin code

fun isEven(n: Int) = n % 2 == 0

data class User(val name: String, val age: Int) {
    fun greet() = "안녕하세요, ${name}입니다"
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    // 함수 참조
    println(numbers.filter(::isEven))      // [2, 4, 6]

    // 생성자 참조
    val names = listOf("김철수", "이영희")
    val users = names.map { User(it, 25) }

    // 멤버 함수 참조
    val greetings = users.map(User::greet)
    println(greetings)

    // 바운드 참조 (특정 인스턴스에 바인딩)
    val user = User("박지성", 30)
    val greetFn: () -> String = user::greet
    println(greetFn())

    // 프로퍼티 참조
    val ages = users.map(User::age)
    println(ages)
}

Kotlin code

// Kotlin fun interface (SAM)
fun interface Transformer<T> {
    fun transform(input: T): T
}

fun interface Validator<T> {
    fun validate(value: T): Boolean
}

fun <T> applyAll(value: T, vararg transforms: Transformer<T>): T =
    transforms.fold(value) { acc, t -> t.transform(acc) }

fun main() {
    // SAM 변환: 람다를 인터페이스로
    val upper: Transformer<String> = Transformer { it.uppercase() }
    val trim: Transformer<String> = Transformer { it.trim() }

    println(applyAll("  hello world  ", trim, upper))
    // "HELLO WORLD"

    // Java Runnable도 SAM 변환
    val thread = Thread { println("별도 스레드 실행") }
    thread.start()

    val isPositive: Validator<Int> = Validator { it > 0 }
    println(isPositive.validate(5))   // true
}

Kotlin code

class Html {
    private val children = mutableListOf<String>()

    fun head(init: Head.() -> Unit) {
        children += Head().apply(init).render()
    }
    fun body(init: Body.() -> Unit) {
        children += Body().apply(init).render()
    }
    fun render() = "<html>
${children.joinToString("
")}
</html>"
}

class Head {
    var title = ""
    fun render() = "  <head><title>$title</title></head>"
}

class Body {
    private val elements = mutableListOf<String>()
    fun h1(text: String) { elements += "    <h1>$text</h1>" }
    fun p(text: String)  { elements += "    <p>$text</p>" }
    fun render() = "  <body>
${elements.joinToString("
")}
  </body>"
}

fun html(init: Html.() -> Unit) = Html().apply(init).render()

fun main() {
    val page = html {
        head { title = "Kotlin DSL" }
        body {
            h1("환영합니다")
            p("타입 안전 빌더 예제입니다")
        }
    }
    println(page)
}

Kotlin code

@DslMarker
annotation class ConfigDsl

@ConfigDsl
class ServerConfig {
    var host = "localhost"
    var port = 8080
    private var dbConfig: DbConfig? = null

    fun database(init: DbConfig.() -> Unit) {
        dbConfig = DbConfig().apply(init)
    }
    override fun toString() = "Server($host:$port, db=$dbConfig)"
}

@ConfigDsl
class DbConfig {
    var url = ""
    var maxPool = 10
    override fun toString() = "DB($url, pool=$maxPool)"
}

fun server(init: ServerConfig.() -> Unit): ServerConfig =
    ServerConfig().apply(init)

fun main() {
    val config = server {
        host = "0.0.0.0"
        port = 9090
        database {
            url = "jdbc:postgresql://localhost/mydb"
            maxPool = 20
            // host = "x" // 컴파일 오류! @DslMarker 덕분
        }
    }
    println(config)
}

Kotlin code

// 커링 유틸리티
fun <A, B, C> ((A, B) -> C).curried(): (A) -> (B) -> C =
    { a -> { b -> this(a, b) } }

fun <A, B, C, D> ((A, B, C) -> D).curried(): (A) -> (B) -> (C) -> D =
    { a -> { b -> { c -> this(a, b, c) } } }

fun add(a: Int, b: Int) = a + b
fun formatLog(level: String, tag: String, msg: String) =
    "[$level][$tag] $msg"

fun main() {
    // 2인자 커링
    val curriedAdd = ::add.curried()
    val add5 = curriedAdd(5)
    println(add5(3))     // 8
    println(add5(10))    // 15

    // 3인자 커링
    val curriedLog = ::formatLog.curried()
    val errorLog = curriedLog("ERROR")
    val dbErrorLog = errorLog("DB")
    println(dbErrorLog("연결 실패"))
    println(dbErrorLog("타임아웃"))
}

Kotlin code

// 부분 적용 유틸리티
fun <A, B, R> partial(f: (A, B) -> R, a: A): (B) -> R =
    { b -> f(a, b) }

fun <A, B, C, R> partial2(f: (A, B, C) -> R, a: A, b: B): (C) -> R =
    { c -> f(a, b, c) }

fun multiply(a: Int, b: Int) = a * b

fun sendEmail(from: String, to: String, body: String) {
    println("From: $from | To: $to | Body: $body")
}

fun main() {
    // 곱셈기 생성
    val double = partial(::multiply, 2)
    val triple = partial(::multiply, 3)
    println(double(5))  // 10
    println(triple(5))  // 15

    // 발신자 고정
    val sendFromAdmin = partial2(::sendEmail, "admin@co.kr", "user@co.kr")
    sendFromAdmin("가입을 환영합니다!")
    sendFromAdmin("비밀번호가 변경되었습니다")

    // 리스트에 적용
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.map(double))  // [2, 4, 6, 8, 10]
}

Kotlin code

fun <T, R> memoize(fn: (T) -> R): (T) -> R {
    val cache = mutableMapOf<T, R>()
    return { input ->
        cache.getOrPut(input) { fn(input) }
    }
}

// 비용이 큰 연산 시뮬레이션
fun expensiveCompute(n: Int): Long {
    println("  계산 중: $n")
    Thread.sleep(100) // 시뮬레이션
    return (1..n.toLong()).fold(1L) { acc, i -> acc * i }
}

fun main() {
    val memoizedFactorial = memoize(::expensiveCompute)

    println("첫 호출:")
    println(memoizedFactorial(10))  // 계산 실행
    println("두번째 호출:")
    println(memoizedFactorial(10))  // 캐시에서 반환

    // 피보나치에도 적용 가능
    lateinit var fib: (Int) -> Long
    fib = memoize { n: Int ->
        if (n <= 1) n.toLong() else fib(n - 1) + fib(n - 2)
    }
    println(fib(40))  // 빠르게 계산
}

Kotlin code

// 함수 합성 연산자
infix fun <A, B, C> ((B) -> C).compose(g: (A) -> B): (A) -> C =
    { a -> this(g(a)) }

infix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C =
    { a -> g(this(a)) }

val trim: (String) -> String = String::trim
val lowercase: (String) -> String = String::lowercase
val addGreeting: (String) -> String = { "안녕하세요, $it!" }

fun main() {
    // compose: 오른쪽부터 실행
    val greetClean = addGreeting compose lowercase compose trim
    println(greetClean("  KOTLIN  "))
    // "안녕하세요, kotlin!"

    // andThen: 왼쪽부터 실행
    val pipeline = trim andThen lowercase andThen addGreeting
    println(pipeline("  WORLD  "))
    // "안녕하세요, world!"

    // 리스트 변환 파이프라인
    val process = { s: String -> s.split(",") } andThen
        { list: List<String> -> list.map { it.trim().toInt() } } andThen
        { nums: List<Int> -> nums.filter { it > 0 }.sum() }
    println(process("1, -2, 3, 4, -5"))  // 8
}

Kotlin code

// 기본 제네릭 함수
fun <T : Comparable<T>> findMax(list: List<T>): T? =
    list.maxOrNull()

// 여러 타입 파라미터
fun <K, V> mapOfPairs(vararg pairs: Pair<K, V>): Map<K, V> =
    pairs.toMap()

// reified: 런타임에 타입 정보 유지
inline fun <reified T> List<*>.filterByType(): List<T> =
    filterIsInstance<T>()

inline fun <reified T> Any.isType(): Boolean = this is T

fun main() {
    println(findMax(listOf(3, 1, 4, 1, 5)))  // 5
    println(findMax(listOf("b", "a", "c")))   // c

    val mixed: List<Any> = listOf(1, "hello", 2.0, "world", 3)
    val strings = mixed.filterByType<String>()
    println(strings)  // [hello, world]

    println("Hello".isType<String>())  // true
    println(42.isType<String>())       // false
}

Kotlin code

// 문자열 확장 프로퍼티
val String.isEmail: Boolean
    get() = matches(Regex("^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$"))

val String.wordCount: Int
    get() = trim().split("\s+".toRegex()).size

// 리스트 확장 프로퍼티
val <T> List<T>.secondOrNull: T?
    get() = if (size >= 2) this[1] else null

val List<Int>.median: Double
    get() {
        val sorted = this.sorted()
        val mid = size / 2
        return if (size % 2 == 0)
            (sorted[mid - 1] + sorted[mid]) / 2.0
        else sorted[mid].toDouble()
    }

fun main() {
    println("user@example.com".isEmail)   // true
    println("not-email".isEmail)          // false
    println("Hello Kotlin World".wordCount) // 3

    println(listOf(10, 20, 30).secondOrNull) // 20
    println(listOf(1, 3, 5, 7).median)       // 4.0
}