메이비 모나드와 리스트 모나드 (함수형 프로그래밍)

최근에는 코틀린을 활용한 함수형 프로그래밍이 개발자 사이에서 큰 관심을 받고 있습니다. 이번 포스팅에서는 함수형 프로그래밍의 핵심 개념 중 하나인 모나드를 코틀린을 통해 구현하는 방법을 살펴보겠습니다. 특히, 메이비 모나드(Maybe Monad)와 리스트 모나드(List Monad)의 구현에 초점을 맞췄습니다.

 

 

메이비 모나드란?

메이비 모나드는 함수형 프로그래밍에서 값의 존재 유무를 안전하게 다루기 위한 패턴입니다. 값이 있을 수도 있고, 없을 수도 있는 상황에서 유용하게 사용됩니다. 코틀린에서는 Maybe를 Just와 Nothing 두 가지 경우로 구현하여, 값의 존재 유무를 표현할 수 있습니다.

sealed class Maybe<out A> {

    companion object {
        fun <V> pure(value: V): Maybe<V> = Just.pure(value)
    }
	override fun <V> pure(value: V) : Maybe<V> = Just(value)
    override fun <B> fmap(f: (A) -> B): Maybe<B> = super.fmap(f) as Maybe<B>
    override infix fun <B> flatMap(f: (A) -> Maybe<B>): Maybe<B> = when(this) {
    	is Just -> try { f(value) as Maybe<B> } catch (e: ClassCastException) { Nothing }
        Nothing -> Nothing
    }

    data class Just<out A>(val value: A) : Maybe<A>() {
        override fun toString(): String = "Just($value)"
    }

    object Nothing : Maybe<kotlin.Nothing>() {
        override fun toString(): String = "Nothing"
    }
    
    infix fun <A, B> Maybe<(A) -> B>.apply(f: Maybe<A>): Maybe<B> = when(this) {
   		is Just -> f.fmap(value)
        Nothing -> Nothing
    }
}

 

이 코드는 Maybe 타입을 선언하고, 이 타입의 두 가지 하위 타입인 Just와 Nothing을 정의합니다. fmap과 flatMap, pure 함수를 구현하였습니다.

 

 

리스트 모나드란? 

리스트 모나드는 리스트에 포함된 각각의 요소에 대해 연산을 수행하고, 그 결과를 새로운 리스트 모나드로 합치는 과정을 간소화합니다. 리스트 모나드는 Cons, Nil로 구성되어 있습니다. 코틀린에서 리스트 모나드를 구현하면, 복잡한 리스트 처리 로직을 명확하고 간결하게 표현할 수 있습니다.

sealed class FunList<out A> {
    object Nil : FunList<Nothing>()
    data class Cons<out A>(val head: A, val tail: FunList<A>) : FunList<A>()

    companion object {
        infix fun <V> pure(value: V): FunList<V> = Cons(0, Nil).pure(value)
    }

    override infix fun <V> pure(value: V): FunList<V> = when (this) {
        Nil -> Nil
        is Cons -> Cons(value, Nil)
    }

    fun <B> fmap(f: (A) -> B): FunList<B> = when (this) {
        is Nil -> Nil
        is Cons -> Cons(f(head), tail.fmap(f))
    }

    fun <B> flatMap(f: (A) -> FunList<B>): FunList<B> = when (this) {
        Nil -> Nil
        is Cons -> try {
            f(head) as FunList<B> mappend tail.flatMap(f)
        } catch (e: ClassCastException) {
            Nil
        }
    }

    fun <B> mappend(other: FunList<B>): FunList<B> = when (this) {
        is Nil -> other
        is Cons -> Cons(head, tail.mappend(other))
    }

		infix fun <B> leadTo(m: FunList<B>): FunList<B> = flatMap { m }
}

 

리스트 모나드 구현에서는 FunList 타입을 선언하고, 이를 통해 리스트의 각 요소에 대한 연산을 수행합니다. fmap 함수는 리스트의 각 요소에 함수를 적용하고, flatMap 함수는 각 요소에 함수를 적용한 결과를 하나의 리스트로 합칩니다. mappend는 두 리스트를 합치는 함수입니다.

 

 

모나드 구현의 이점

모나드를 구현함으로써, 코틀린 개발자들은 보다 선언적인 방식으로 프로그래밍할 수 있게 됩니다. 특히, 에러 처리, 비동기 처리, 리스트 처리 등 복잡한 로직을 더욱 쉽고 안전하게 다룰 수 있습니다.

 

 

결론

코틀린으로 함수형 프로그래밍을 탐색하는 것은 개발자로서의 역량을 넓힐 수 있는 훌륭한 방법입니다. 메이비 모나드와 리스트 모나드는 코틀린의 강력한 타입 시스템과 결합하여, 더 안전하고 유지보수가 쉬운 코드를 작성할 수 있게 도와줍니다. 이 포스트가 코틀린을 사용한 함수형 프로그래밍의 세계로 여러분을 안내하는 데 도움이 되길 바랍니다.