Rust로 배우는 모나드의 개념 | 차정윤 | Samsung Tech Blog

dimohy · 7월 28, 2025, 11:14오후

Rust로 배우는 모나드의 개념: 함수형 프로그래밍의 핵심 이해하기

주요 내용 요약

Android 디바이스 개발 인프라를 구축하는 과정에서 Rust 기반 에이전트 개발 경험을 바탕으로 함수형 프로그래밍의 핵심 개념인 **모나드(Monad)**를 체계적으로 설명한다. 모나드는 복잡해 보이지만 실제로는 Rust에서 이미 널리 사용되는 Option과 Result의 .map(), .and_then() 체이닝 패턴을 수학적으로 정리한 개념이다.

1. 배경 및 동기

실무 환경에서의 필요성

전 세계 Android 디바이스 개발 및 생산: 대규모 디바이스 관리 인프라 구축
웹 브라우저 기반 원격 개발 서비스: 수천 대의 디바이스를 원격으로 제어
수백 대의 노드 머신 관리: 효율적인 상태 관리를 위한 Rust 기반 에이전트 개발
새로운 언어 도입 과정: 시행착오와 깨달음을 통한 함수형 프로그래밍 학습

학습 목표

이 글에서 다루는 핵심 개념들:

모노이드(Monoid): 결합 가능한 연산의 기초
펑터(Functor): 값을 변환하는 방법
엔도펑터(Endofunctor): 같은 범주 내 변환
어플리커티브 펑터(Applicative Functor): 함수를 적용하는 방법
모나드(Monad): 순차적 연산을 체이닝하는 방법

2. 모노이드(Monoid): 결합의 기초

기본 개념

모노이드는 일상에서 매우 자주 사용하는 개념으로, 문자열 이어붙이기, 숫자 덧셈, 리스트 합치기 등이 모두 모노이드 연산이다.

수학적 정의

결합법칙을 만족하는 이항 연산
항등원을 가진 구조

핵심 특징

여러 원소를 순서대로 합칠 수 있음 (결합법칙)
아무것도 없는 상태(빈 값)가 있음 (항등원)

실제 예제

// 문자열 모노이드
trait Monoid {
    fn empty() -> Self;
    fn append(self, other: Self) -> Self;
}

impl Monoid for String {
    fn empty() -> String { String::new() }
    fn append(self, other: String) -> String { 
        format!("{}{}", self, other) 
    }
}

// 숫자 덧셈 모노이드
impl Monoid for i32 {
    fn empty() -> i32 { 0 }
    fn append(self, other: i32) -> i32 { self + other }
}

모노이드의 법칙

결합법칙: (a + b) + c = a + (b + c)
항등원: empty + a = a + empty = a

3. 펑터(Functor): 값을 변환하는 방법

핵심 개념

펑터는 값을 담고 있는 **상자(컨테이너)**가 있을 때, 그 상자를 열지 않고도 안에 있는 값에 함수를 적용할 수 있게 해주는 방법이다.

직관적 설명

선물 상자에 비유하면, 상자를 열어서 선물을 꺼내고 작업한 다음 다시 포장하는 대신, 마법처럼 상자 밖에서 함수를 적용하면 안의 내용물이 변환되는 것이다.

실제 예제

// Option 펑터
impl<T> Functor for Option<T> {
    fn fmap<U, F>(self, f: F) -> Option<U> 
    where F: FnOnce(T) -> U {
        match self {
            Some(value) => Some(f(value)),
            None => None,
        }
    }
}

// Result 펑터
impl<T, E> Functor for Result<T, E> {
    fn fmap<U, F>(self, f: F) -> Result<U, E> 
    where F: FnOnce(T) -> U {
        match self {
            Ok(value) => Ok(f(value)),
            Err(err) => Err(err),
        }
    }
}

펑터의 특징

값 보존: fmap은 컨테이너의 구조를 유지
함수 적용: 상자 안의 값에만 함수를 적용
에러 처리: None이나 Err는 그대로 유지

4. 엔도펑터(Endofunctor): 같은 범주 내 변환

용어 설명

**엔도(Endo)**는 그리스어로 ‘내부의’, '같은 곳의’라는 뜻으로, 의학의 '엔도스코프(내시경)'에서도 사용되는 접두사다.

핵심 개념

엔도펑터는 같은 ‘범주’ 내에서만 변환이 일어나는 펑터를 말한다.

예제 비교

// 엔도펑터 (같은 범주 내 변환)
let option_int: Option<i32> = Some(42);
let option_string: Option<String> = option_int.map(|x| x.to_string());
// Option → Option (같은 범주)

// 비엔도펑터 (다른 범주로 변환)
let option_to_vec: Vec<i32> = option_int.map_or(Vec::new(), |x| vec![x]);
// Option → Vec (다른 범주)

엔도펑터의 특징

F → F (F는 같은 타입 생성자)

구조 보존: 컨테이너의 구조는 그대로 유지

모나드의 기초: 모나드는 엔도펑터의 특별한 경우

5. 어플리커티브 펑터(Applicative Functor): 함수를 적용하는 방법

핵심 개념

일반적인 펑터는 '상자 안의 값’에 '일반 함수’를 적용하는 것인데, 어플리커티브 펑터는 함수 자체도 상자 안에 담긴 상황에서 어떻게 적용할지를 다룬다.

비교 예제

// 일반 펑터 let value = Some(5); let function = |x| x * 2; let result = value.map(function); // Some(10) // 어플리커티브 펑터 let value = Some(5); let function_in_box = Some(|x| x * 2); // 함수와 값이 모두 상자 안에 있는 상황

실제 구현 예제

impl<T> Applicative for Option<T> { fn apply<U, F>(self, f: Option<F>) -> Option<U> where F: FnOnce(T) -> U { match (self, f) { (Some(value), Some(function)) => Some(function(value)), _ => None, } } }

어플리커티브 펑터의 특징

함수 적용: F<A>와 F<A→B>를 조합하여 F<B> 생성

병렬 처리: 여러 값을 동시에 조합 가능

에러 전파: 하나라도 실패하면 전체 실패

참고: Rust에서는 주로 map과 and_then을 사용하므로 어플리커티브 펑터는 이론적 배경으로만 이해하면 된다.

6. 모나드(Monad): 순차적 연산을 체이닝하는 방법

핵심 정의

모나드는 이전 단계의 결과를 보고 다음에 무엇을 할지 결정할 수 있는 똑똑한 체이닝 방법이다.

실제 사용 시나리오

다음과 같은 순차적 처리가 필요한 상황:

사용자 ID로 사용자 정보를 찾는다 → 사용자가 있을 수도, 없을 수도 있음

사용자가 있다면 권한을 확인한다 → 권한이 있을 수도, 없을 수도 있음

권한이 있다면 데이터를 가져온다 → 성공할 수도, 실패할 수도 있음

각 단계가 성공해야만 다음 단계로 진행할 수 있고, 중간에 하나라도 실패하면 전체가 실패해야 하는 조건부 연쇄 실행을 우아하게 처리한다.

실제 구현 예제

// Option 모나드 impl<T> Monad for Option<T> { fn bind<U, F>(self, f: F) -> Option<U> where F: FnOnce(T) -> Option<U> { match self { Some(value) => f(value), None => None, } } } // Result 모나드 impl<T, E> Monad for Result<T, E> { fn bind<U, F>(self, f: F) -> Result<U, E> where F: FnOnce(T) -> Result<U, E> { match self { Ok(value) => f(value), Err(err) => Err(err), } } }

실용적인 체이닝 예제

fn get_user_data(id: u32) -> Option<String> { find_user(id) .and_then(|user| check_permission(user)) .and_then(|user| fetch_data(user)) .map(|data| format_data(data)) }

모나드의 특징

순차적 실행: 이전 연산의 결과가 다음 연산의 입력

에러 전파: 중간에 실패하면 전체 체인이 실패

조건부 실행: 값이 있을 때만 다음 연산 실행

7. 개념들 간의 관계와 계층 구조

계층 구조

모나드는 어플리커티브 펑터를 확장

어플리커티브 펑터는 펑터를 확장

엔도펑터는 펑터의 특별한 경우

모노이드는 별도의 대수적 구조

각각이 해결하는 문제

모노이드: 여러 값을 결합하는 방법

펑터: 값을 변환하는 방법

엔도펑터: 같은 컨테이너 내에서 값을 변환하는 방법

어플리커티브 펑터: 함수를 적용하는 방법

모나드: 순차적 연산을 체이닝하는 방법

8. 모나드의 실무적 장점

1. 에러 처리의 단순화

// 기존 방식 (복잡한 중첩 처리) match find_user(id) { Some(user) => { match check_permission(user) { Some(authorized_user) => { match fetch_data(authorized_user) { Some(data) => Some(format_data(data)), None => None, } }, None => None, } }, None => None, } // 모나드 방식 (깔끔한 체이닝) find_user(id) .and_then(check_permission) .and_then(fetch_data) .map(format_data)

2. 가독성 향상

선형적 코드 흐름: 단계별 처리 과정이 명확

중첩 제거: 깊은 중첩 구조 없이 평면적 코드 작성

의도 표현: 각 단계의 목적이 명확히 드러남

3. 조합 가능성

재사용성: 각 단계를 독립적으로 테스트하고 재사용 가능

모듈화: 복잡한 로직을 작은 단위로 분해

확장성: 새로운 단계를 쉽게 추가 가능

9. 실제 Rust에서의 모나드 활용

Option 모나드

fn safe_divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator != 0.0 { Some(numerator / denominator) } else { None } } // 체이닝 예제 let result = Some(10.0) .and_then(|x| safe_divide(x, 2.0)) .and_then(|x| safe_divide(x, 2.0)) .map(|x| x.round());

Result 모나드

use std::fs::File; use std::io::Read; fn read_file_contents(path: &str) -> Result<String, std::io::Error> { File::open(path)? .read_to_string(&mut String::new()) .map(|_| contents) }

Iterator 모나드

let numbers = vec![1, 2, 3, 4, 5]; let result: Vec<i32> = numbers .iter() .filter(|&&x| x % 2 == 0) .map(|&x| x * x) .collect();

10. 실용적인 팁과 주의사항

실용적 팁

작은 함수로 분해: 각 단계를 독립적인 함수로 만들기

타입 힌트 활용: 복잡한 체이닝에서는 중간 타입을 명시

에러 타입 통일: Result를 사용할 때 일관된 에러 타입 사용

테스트 용이성: 각 단계를 개별적으로 테스트 가능하도록 설계

주의사항

과도한 체이닝 주의: 너무 긴 체이닝은 오히려 가독성을 해칠 수 있음

성능 고려: 많은 변환이 있는 경우 성능 영향 검토 필요

에러 정보 손실: 체이닝 과정에서 구체적인 에러 정보가 손실될 수 있음

학습 곡선: 팀원들의 함수형 프로그래밍 이해도 고려

11. 학습 리소스 및 참고 자료

공식 Rust 문서

The Rust Programming Language: Option과 Result 활용법

Rust by Example: 실용적인 예제 모음

Rust Standard Library: Iterator, Option, Result API 문서

함수형 프로그래밍 이론

Category Theory for Programmers: 범주론 기초

Learn You a Haskell: 하스켈을 통한 함수형 프로그래밍 학습

Functional Programming in Scala: 스칼라를 통한 함수형 프로그래밍

Rust 생태계의 함수형 라이브러리

itertools: Iterator 확장 기능

anyhow: 에러 처리 라이브러리

thiserror: 커스텀 에러 타입 생성

다음 단계 학습 주제

모나드 변환자(Monad Transformers): 여러 모나드의 조합

렌즈(Lenses)와 프리즘(Prisms): 복잡한 데이터 구조 조작

카테고리 이론의 고급 개념: 코모나드, 애로우 등

12. 실무 활용 사례

에러 처리

fn process_user_request(user_id: u32) -> Result<ProcessedData, AppError> { authenticate_user(user_id)? .validate_permissions()? .fetch_user_data()? .process_data()? .save_results() }

널 안전성

fn get_user_email(user_id: u32) -> Option<String> { users_database .find_user(user_id) .and_then(|user| user.profile) .and_then(|profile| profile.email) .map(|email| email.to_lowercase()) }

비동기 처리

async fn fetch_and_process_data(url: &str) -> Result<ProcessedData, RequestError> { http_client .get(url).await? .json::<RawData>().await? .validate()? .transform() .save_to_cache() }

파싱

fn parse_config_file(content: &str) -> Result<Config, ParseError> { content .parse::<toml::Value>()? .try_into::<ConfigRaw>()? .validate()? .into() }

결론

모나드는 처음에는 복잡해 보이지만, 실제로는 우리가 일상에서 자주 사용하는 패턴을 수학적으로 정리한 것이다. 특히 Rust의 강력한 타입 시스템과 함께 사용하면 더욱 안전하고 읽기 쉬운 코드를 작성할 수 있다.

핵심 요약

모노이드: 결합 가능한 연산의 기초

펑터: 값을 변환하는 방법

엔도펑터: 같은 범주 내 변환

어플리커티브 펑터: 함수를 적용하는 방법

모나드: 순차적 연산을 체이닝하는 방법

실무 활용의 핵심 가치

에러 처리: Result 모나드로 깔끔한 에러 처리

널 안전성: Option 모나드로 null pointer error 예방

비동기 처리: Future 모나드로 복잡한 비동기 로직 단순화

파싱: Parser 모나드로 복잡한 파싱 로직 구성

Android 디바이스 개발 인프라라는 대규모 시스템에서 Rust 기반 에이전트를 개발하며 얻은 경험처럼, 모나드는 복잡한 실무 환경에서 코드의 안전성과 가독성을 동시에 보장하는 강력한 도구이다. 어려운 수학 이론보다는 Rust가 제공하는 풍부한 예제와 함께 함수형 프로그래밍의 세계에 한 걸음 더 들어가보자.