[Rust] Fn, FnMut, FnOnce: 예시를 통한 완벽 비교

Rust에서 Fn, FnMut, FnOnce 완벽 가이드

Rust Iterator는 데이터를 효율적으로 순회하며 처리하는 핵심 도구입니다. 특히, 지연 평가(Lazy Evaluation)와 체인 호출 같은 강력한 기능은 복잡한 작업도 간결하고 최적화된 방식으로 수행할 수 있게 해줍니다. 이 가이드는 Rust의 Fn, FnMut, FnOnce 트레이트 사용법, 시간 복잡도, 예제 코드까지 다뤄, 트레이트 활용을 극대화할 방법을 제공합니다.

---

1. Fn, FnMut, FnOnce의 주요 차이점

Rust의 Fn, FnMut, FnOnce는 클로저가 캡처한 환경을 처리하는 방법에 따라 구분됩니다.

특성	트레이트	메모리 접근 방식	특징
Fn	Fn	불변 참조 (&self)	환경을 읽기 전용으로 캡처. 여러 번 호출 가능.
FnMut	FnMut	가변 참조 (&mut self)	환경을 수정 가능. 여러 번 호출 가능.
FnOnce	FnOnce	소유권 이동 (self)	환경을 소비. 한 번만 호출 가능.

---

2. 각각의 동작 방식

Fn: 불변 참조로 호출

Fn은 클로저가 환경을 읽기 전용으로 캡처하며, 여러 번 호출이 가능합니다.

fn call_with_one<F>(func: F) -> usize
where
    F: Fn(usize) -> usize,
{
    func(1)
}

let double = |x| x * 2;
assert_eq!(call_with_one(double), 2);

FnMut: 가변 참조로 호출

FnMut은 환경을 가변적으로 캡처하며, 내부 상태를 수정할 수 있습니다.

fn do_twice<F>(mut func: F)
where
    F: FnMut(),
{
    func();
    func();
}

let mut counter = 0;
let mut increment = || counter += 1;
do_twice(&mut increment);
assert_eq!(counter, 2);

FnOnce: 소유권 이동

FnOnce는 클로저가 환경의 소유권을 이동하여 소비하며, 한 번만 호출할 수 있습니다.

fn consume_with_relish<F>(func: F)
where
    F: FnOnce() -> String,
{
    println!("Consumed: {}", func());
}

let x = String::from("Hello, Rust!");
let consume = || x;
consume_with_relish(consume);
// consume(); // 에러: 사용 후 이동됨

---

3. Fn, FnMut, FnOnce의 비교

특성	호출 방식	상태 캡처 방식	사용 예제
Fn	읽기 전용	환경을 불변 참조로 캡처	함수 포인터, 읽기만 필요한 클로저
FnMut	가변적으로 호출	환경을 가변 참조로 캡처	카운터 증가, 상태 수정
FnOnce	한 번 호출	환경의 소유권을 이동하여 캡처	리소스 소비, 대규모 데이터 이동

---

4. 실제 활용 예시

예제 1: 함수 포인터로 콜백 처리

fn execute_callback<F>(callback: F)
where
    F: Fn(),
{
    callback();
}

fn say_hello() {
    println!("Hello, world!");
}

execute_callback(say_hello);

설명: Fn을 사용하여 함수 포인터를 전달받아 실행합니다.

예제 2: 클로저로 상태 관리

fn increment_counter<F>(mut action: F)
where
    F: FnMut(),
{
    action();
    action();
}

let mut counter = 0;
let mut add_one = || counter += 1;
increment_counter(&mut add_one);
assert_eq!(counter, 2);

설명: FnMut으로 가변 참조를 받아 내부 상태를 수정합니다.

예제 3: 자원을 소비하는 작업

fn consume_string<F>(consume: F)
where
    F: FnOnce(),
{
    consume();
}

let text = String::from("Rust");
let consume_closure = || println!("{}", text);
consume_string(consume_closure);

설명: FnOnce는 자원을 소비하며, 이후 사용이 불가능합니다.

---

5. 시간 복잡도

각 트레이트는 특정한 호출 방식에 따라 동작하며, 시간 복잡도는 클로저 내부 작업에 의존합니다.

연산	호출 방식	시간 복잡도
Fn	불변 참조 호출	클로저 연산 시간에 의존
FnMut	가변 참조 호출	클로저 연산 시간에 의존
FnOnce	소유권 이동 호출	클로저 연산 시간에 의존

---

F&Q 코너

Q1. Fn과 FnMut를 혼용할 수 있나요?

• 가능하지만, 호출 방식이 Fn 또는 FnMut로 제한됩니다. FnMut는 더 많은 권한(가변 참조)을 요구하므로 Fn으로 다운그레이드할 수 없습니다.
• 추가로, FnMut를 사용하는 경우 클로저 내부에서 상태를 수정하는 작업을 수행할 수 있으나, 불변 참조(Fn)로 호출하려면 상태 변경이 없는 로직으로 설계해야 합니다. 예를 들어, Fn은 읽기 전용 작업에 적합하며, FnMut은 카운터 증가와 같은 작업에서 유용합니다. 따라서 둘의 혼용은 설계 단계에서 목적에 따라 신중히 선택해야 합니다.

Q2. FnOnce는 왜 한 번만 호출할 수 있나요?

• 환경의 소유권을 이동하기 때문에 두 번째 호출 시 이동된 값을 다시 사용할 수 없습니다. 예를 들어, String 같은 타입은 클로저가 소유권을 캡처한 후 더 이상 다른 곳에서 사용할 수 없습니다. 이것은 Rust의 소유권 시스템과 메모리 안전성을 유지하는 핵심 원칙입니다.
• 소유권 이동이 발생하면 데이터가 클로저 내부로 "소모"되므로, 다시 호출하려고 하면 Rust 컴파일러가 이동된 데이터에 접근하려는 시도를 금지합니다. 이를 통해 잠재적 런타임 에러를 컴파일 단계에서 방지합니다.

Q3. 함수와 클로저의 차이는 무엇인가요?

• 함수는 고정된 동작을 수행하며, 클로저는 주변 환경을 캡처하여 더 유연하게 동작합니다. 클로저는 캡처된 데이터를 기반으로 실행할 수 있으므로 동적 동작을 정의할 수 있는 반면, 함수는 항상 동일한 입력과 출력 관계를 가집니다.
• 추가적으로, 클로저는 함수와 달리 다양한 트레이트(Fn, FnMut, FnOnce)를 구현할 수 있어 호출 방식과 캡처 방식에서 더 유연합니다. 예를 들어, 클로저는 데이터를 캡처하여 상태를 유지하거나 조작할 수 있는 반면, 함수는 단순히 전달된 매개변수만 처리합니다.

---

결론

Rust의 Fn, FnMut, FnOnce는 각각 고유한 사용 사례를 가지며, 환경 캡처 방식에 따라 적합한 트레이트를 선택할 수 있습니다. 이를 활용하면 클로저 기반의 유연한 코드를 작성할 수 있으며, Rust의 함수형 프로그래밍 스타일을 극대화할 수 있습니다. Rust 개발자로서 이 세 가지 트레이트의 차이점을 이해하고, 적재적소에 활용하여 더 효율적인 코드를 작성해보세요!