Kotlin 함수형 완전 정리

Kotlin code

// 함수 타입
val double: (Int) -> Int = { n -> n * 2 }
val greet: (String) -> String = { "Hello, $it!" }  // it: 단일 파라미터
val add: (Int, Int) -> Int = { a, b -> a + b }

// 고차함수 — 함수를 파라미터로 받기
fun transform(list: List<Int>, fn: (Int) -> Int) =
    list.map(fn)

// 고차함수 — 함수를 반환하기
fun multiplier(factor: Int): (Int) -> Int = { it * factor }

// 함수 합성
infix fun <A, B, C> ((A) -> B).then(g: (B) -> C): (A) -> C =
    { g(this(it)) }

// 메서드 참조
fun isPositive(n: Int) = n > 0
val nums = listOf(-3, -1, 0, 2, 5)
val pos = nums.filter(::isPositive)
val strs = nums.map(Int::toString)

fun main() {
    println(transform(listOf(1,2,3), double))   // [2, 4, 6]
    println(transform(listOf(1,2,3)) { it * it }) // trailing lambda

    val triple = multiplier(3)
    println(triple(7))   // 21

    val process = double then { it + 1 } then { "$it!" }
    println(process(5))  // "11!"
}

Kotlin code

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

Kotlin code

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

    fun <R> map(f: (T) -> R): Maybe<R> = when (this) {
        is Just -> Just(f(value))
        is None -> None
    }

    fun <R> flatMap(f: (T) -> Maybe<R>): Maybe<R> = when (this) {
        is Just -> f(value)
        is None -> None
    }

    fun getOrElse(default: @UnsafeVariance T): T = when (this) {
        is Just -> value
        is None -> default
    }
}

fun findUser(id: Int): Maybe<String> =
    if (id > 0) Maybe.Just("User-$id") else Maybe.None

fun findEmail(user: String): Maybe<String> =
    Maybe.Just("$user@example.com")

fun main() {
    val email = findUser(1)
        .flatMap { findEmail(it) }
        .map { it.uppercase() }
    println(email)  // Just(USER-1@EXAMPLE.COM)

    val none = findUser(-1)
        .flatMap { findEmail(it) }
    println(none)   // None
}

Kotlin code

sealed class Either<out L, out R> {
    data class Left<L>(val value: L) : Either<L, Nothing>()
    data class Right<R>(val value: R) : Either<Nothing, R>()

    fun <T> fold(onLeft: (L) -> T, onRight: (R) -> T): T = when (this) {
        is Left -> onLeft(value)
        is Right -> onRight(value)
    }

    fun <T> map(f: (R) -> T): Either<L, T> = when (this) {
        is Left -> this
        is Right -> Right(f(value))
    }

    fun <T> flatMap(f: (R) -> Either<L, T>): Either<L, T> = when (this) {
        is Left -> this
        is Right -> f(value)
    }
}

fun parseInt(s: String): Either<String, Int> =
    s.toIntOrNull()?.let { Either.Right(it) }
        ?: Either.Left("'$s'는 숫자가 아닙니다")

fun divide(a: Int, b: Int): Either<String, Double> =
    if (b == 0) Either.Left("0으로 나눌 수 없습니다")
    else Either.Right(a.toDouble() / b)

fun main() {
    val result = parseInt("10")
        .flatMap { n -> divide(n, 3) }
        .map { "결과: %.2f".format(it) }

    result.fold(
        onLeft = { println("오류: $it") },
        onRight = { println(it) }
    )
}

Kotlin code

fun fetchData(url: String): Result<String> = runCatching {
    if (url.isEmpty()) throw IllegalArgumentException("빈 URL")
    if (!url.startsWith("http")) throw IllegalArgumentException("잘못된 프로토콜")
    "데이터: $url 응답"
}

fun parseJson(data: String): Result<Map<String, Any>> = runCatching {
    mapOf("content" to data, "status" to "ok")
}

fun main() {
    // Result 체이닝
    val result = fetchData("https://api.example.com")
        .mapCatching { parseJson(it).getOrThrow() }
        .map { it["content"] }
        .getOrElse { "기본값" }
    println(result)

    // recover 패턴
    val recovered = fetchData("")
        .recover { ex ->
            println("복구: ${ex.message}")
            "빈 응답"
        }
    println(recovered.getOrNull())

    // fold로 처리
    fetchData("ftp://wrong").fold(
        onSuccess = { println("성공: $it") },
        onFailure = { println("실패: ${it.message}") }
    )
}

Kotlin code

data class Lens<S, A>(
    val get: (S) -> A,
    val set: (S, A) -> S
) {
    fun modify(source: S, f: (A) -> A): S =
        set(source, f(get(source)))

    infix fun <B> compose(other: Lens<A, B>): Lens<S, B> = Lens(
        get = { s -> other.get(get(s)) },
        set = { s, b -> set(s, other.set(get(s), b)) }
    )
}

data class Address(val city: String, val zip: String)
data class Person(val name: String, val address: Address)

// 렌즈 정의
val personAddress = Lens<Person, Address>(
    get = { it.address },
    set = { person, addr -> person.copy(address = addr) }
)
val addressCity = Lens<Address, String>(
    get = { it.city },
    set = { addr, city -> addr.copy(city = city) }
)

fun main() {
    val person = Person("김철수", Address("서울", "06000"))

    // 렌즈 합성으로 중첩 필드 접근
    val personCity = personAddress compose addressCity
    println(personCity.get(person))  // 서울

    val moved = personCity.set(person, "부산")
    println(moved)
    // Person(name=김철수, address=Address(city=부산, zip=06000))
}

Kotlin code

// 불변 연결 리스트 (구조 공유)
sealed class PList<out T> {
    data object Nil : PList<Nothing>()
    data class Cons<T>(val head: T, val tail: PList<T>) : PList<T>()

    fun prepend(value: @UnsafeVariance T): PList<T> = Cons(value, this)

    fun <R> map(f: (T) -> R): PList<R> = when (this) {
        is Nil -> Nil
        is Cons -> Cons(f(head), tail.map(f))
    }

    fun toList(): List<T> = buildList {
        var current: PList<T> = this@PList
        while (current is Cons) {
            add(current.head)
            current = current.tail
        }
    }
}

fun <T> plistOf(vararg items: T): PList<T> =
    items.foldRight(PList.Nil as PList<T>) { item, acc -> PList.Cons(item, acc) }

fun main() {
    val list1 = plistOf(1, 2, 3)
    val list2 = list1.prepend(0)  // list1은 그대로

    println(list1.toList())  // [1, 2, 3]
    println(list2.toList())  // [0, 1, 2, 3]

    val doubled = list1.map { it * 2 }
    println(doubled.toList())  // [2, 4, 6]
}

Kotlin code

// 순수 함수: 동일 입력 → 동일 출력, 부수 효과 없음
fun calculateDiscount(price: Int, memberLevel: Int): Int = when {
    memberLevel >= 3 -> (price * 0.20).toInt()
    memberLevel >= 2 -> (price * 0.10).toInt()
    memberLevel >= 1 -> (price * 0.05).toInt()
    else -> 0
}

fun calculateTotal(items: List<Pair<String, Int>>, discount: Int): Int =
    items.sumOf { it.second } - discount

// 부수 효과를 경계에서 처리
data class OrderResult(val total: Int, val discount: Int, val items: List<String>)

fun processOrder(items: List<Pair<String, Int>>, level: Int): OrderResult {
    val subtotal = items.sumOf { it.second }
    val discount = calculateDiscount(subtotal, level)
    val total = calculateTotal(items, discount)
    return OrderResult(total, discount, items.map { it.first })
}

// I/O는 경계에서만
fun main() {
    val items = listOf("노트북" to 1500000, "마우스" to 50000)
    val result = processOrder(items, memberLevel = 3)

    // 부수 효과(출력)는 최외곽에서만
    println("주문 결과:")
    println("  항목: ${result.items}")
    println("  할인: ${result.discount}원")
    println("  합계: ${result.total}원")
}

Kotlin code

data class RawRecord(val name: String, val score: String, val dept: String)
data class ValidRecord(val name: String, val score: Int, val dept: String)
data class Report(val dept: String, val avg: Double, val count: Int)

// 파이프라인 단계들 (각각 순수 함수)
val parse: (List<String>) -> List<RawRecord> = { lines ->
    lines.map { line ->
        val (n, s, d) = line.split(",")
        RawRecord(n.trim(), s.trim(), d.trim())
    }
}

val validate: (List<RawRecord>) -> List<ValidRecord> = { records ->
    records.mapNotNull { r ->
        r.score.toIntOrNull()?.let { ValidRecord(r.name, it, r.dept) }
    }
}

val aggregate: (List<ValidRecord>) -> List<Report> = { records ->
    records.groupBy { it.dept }.map { (dept, recs) ->
        Report(dept, recs.map { it.score }.average(), recs.size)
    }
}

val format: (List<Report>) -> String = { reports ->
    reports.sortedByDescending { it.avg }
        .joinToString("
") { "${it.dept}: 평균 %.1f (${it.count}명)".format(it.avg) }
}

fun main() {
    val data = listOf("김철수,85,개발", "이영희,92,마케팅", "박지성,88,개발", "최유리,invalid,인사")

    // 파이프라인 실행
    val result = data.let(parse).let(validate).let(aggregate).let(format)
    println(result)
}

Kotlin code

// Arrow 라이브러리 사용 예시 (개념 코드)
// build.gradle.kts: implementation("io.arrow-kt:arrow-core:1.2.1")

// Either를 활용한 에러 처리
sealed class AppError {
    data class NotFound(val id: String) : AppError()
    data class ValidationError(val msg: String) : AppError()
}

// Arrow 스타일의 Either 활용 (간략화)
fun validateAge(age: Int): Result<Int> =
    if (age in 1..150) Result.success(age)
    else Result.failure(IllegalArgumentException("유효하지 않은 나이"))

fun validateName(name: String): Result<String> =
    if (name.isNotBlank()) Result.success(name.trim())
    else Result.failure(IllegalArgumentException("이름이 비어있음"))

data class Person(val name: String, val age: Int)

fun createPerson(name: String, age: Int): Result<Person> =
    runCatching {
        Person(
            validateName(name).getOrThrow(),
            validateAge(age).getOrThrow()
        )
    }

fun main() {
    createPerson("김철수", 25).fold(
        onSuccess = { println("생성: $it") },
        onFailure = { println("오류: ${it.message}") }
    )
    createPerson("", -1).fold(
        onSuccess = { println("생성: $it") },
        onFailure = { println("오류: ${it.message}") }
    )
}

Kotlin code

data class Prism<S, A>(
    val getOrNull: (S) -> A?,
    val reverseGet: (A) -> S
) {
    fun modify(source: S, f: (A) -> A): S =
        getOrNull(source)?.let { reverseGet(f(it)) } ?: source
}

sealed class Json {
    data class JString(val value: String) : Json()
    data class JNumber(val value: Double) : Json()
    data class JArray(val items: List<Json>) : Json()
    data object JNull : Json()
}

// 프리즘 정의
val jsonString = Prism<Json, String>(
    getOrNull = { (it as? Json.JString)?.value },
    reverseGet = { Json.JString(it) }
)

val jsonNumber = Prism<Json, Double>(
    getOrNull = { (it as? Json.JNumber)?.value },
    reverseGet = { Json.JNumber(it) }
)

fun main() {
    val str: Json = Json.JString("hello")
    val num: Json = Json.JNumber(42.0)

    println(jsonString.getOrNull(str))  // hello
    println(jsonString.getOrNull(num))  // null (안전)

    val upper = jsonString.modify(str) { it.uppercase() }
    println(upper)  // JString(value=HELLO)

    val doubled = jsonNumber.modify(num) { it * 2 }
    println(doubled)  // JNumber(value=84.0)
}

Kotlin code

// 부수 효과를 값으로 표현
sealed class IO<out A> {
    data class Pure<A>(val value: A) : IO<A>()
    data class Suspend<A>(val thunk: () -> A) : IO<A>()
    data class FlatMap<A, B>(val io: IO<A>, val f: (A) -> IO<B>) : IO<B>()

    fun <B> map(f: (A) -> B): IO<B> = flatMap { Pure(f(it)) }
    fun <B> flatMap(f: (A) -> IO<B>): IO<B> = FlatMap(this, f)

    @Suppress("UNCHECKED_CAST")
    fun run(): A = when (this) {
        is Pure -> value
        is Suspend -> thunk()
        is FlatMap<*, *> -> {
            val result = (io as IO<Any?>).run()
            (f as (Any?) -> IO<A>)(result).run()
        }
    }
}

fun readLine(): IO<String> = IO.Suspend { kotlin.io.readlnOrNull() ?: "" }
fun printLine(msg: String): IO<Unit> = IO.Suspend { println(msg) }

fun program(): IO<Unit> =
    printLine("이름을 입력하세요:")
        .flatMap { readLine() }
        .flatMap { name -> printLine("안녕하세요, $name!") }

fun main() {
    // 프로그램은 값일 뿐, run()할 때만 실행
    val prog = printLine("Hello").flatMap { printLine("World") }
    println("아직 실행 안됨")
    prog.run() // 이때 실행
}