파이썬 개발자를 위한 Rust: 실무 트레이닝 가이드

학습 목표: 파이썬 개발 환경에서 쌓은 경험을 바탕으로 Rust를 빠르고 정확하게 습득합니다. 동적 타이핑과 가비지 컬렉션(GC)에 익숙한 사고방식을 컴파일 타임 메모리 안전성과 정적 타이핑 중심의 시스템 언어적 사고방식으로 전환하는 데 집중합니다.

📘 이 책을 활용하는 방법

본 가이드는 파이썬의 익숙한 개념을 Rust의 대응 개념과 대조하며 학습하도록 설계되었습니다.

• 1부 (1~6장): 파이썬 개념과 유사한 기초 문법 (변수, 제어 흐름, 데이터 구조)
• 2부 (7~12장): Rust만의 핵심 개념 (소유권, 빌림, 트레이트, 제네릭)
• 3부 (13~16장): 심화 주제 및 파생 기술 (동시성, PyO3를 통한 연동, 마이그레이션)
• 4부 (17장): 캡스톤 프로젝트 (CLI 할 일 관리 도구 제작)

🚀 추천 학습 일정

💡 학습 팁

1. 연습 문제를 직접 풀어보세요: 각 장의 연습 문제는 접이식 메뉴 안에 정답과 함께 들어 있습니다. 먼저 직접 코드를 짜본 뒤 정답을 확인하세요.
2. 컴파일러를 믿으세요: Rust 컴파일러의 에러 메시지는 당신의 스승입니다. 에러가 나면 꼼꼼히 읽어보세요. 대부분의 해결책이 메시지 안에 들어 있습니다.
3. 난이도 가이드:
   • 🟢 초급: 파이썬 지식으로 즉시 이해 가능
   • 🟡 중급: 소유권이나 트레이트 등 Rust 고유 개념 이해 필요
   • 🔴 고급: 수명(Lifetime), 비동기 내부 로직, Unsafe 코드 등 심화 주제

🛠️ 필수 도구 및 리소스

• Rust Playground: 브라우저에서 즉시 코드 실행
• PyO3 문서: Rust와 파이썬 연동을 위한 필수 라이브러리
• Cargo: 빌드 및 패키지 관리 도구 (pip/poetry 대응)

서론 및 동기: 파이썬 개발자가 Rust를 배우는 이유

학습 목표: 파이썬 개발자들이 왜 Rust에 열광하는지, 실제 성능 차이는 어느 정도인지(Dropbox, Discord, Pydantic 사례), 그리고 파이썬을 유지할 때와 Rust로 넘어갈 때의 명확한 기준을 배웁니다. 두 언어의 철학적 차이를 이해하고 Rust가 해결하는 파이썬의 고질적인 문제들을 파악합니다.

1. 성능: 분 단위에서 밀리초 단위로

파이썬은 CPU 집약적인 작업에서 느리기로 유명합니다. Rust는 C 수준의 성능을 제공하면서도 현대적인 언어의 편리함을 유지합니다.

# [Python] 1,000만 번 호출 시 약 2초 소요
def fibonacci(n):
    if n <= 1: return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

#![allow(unused)]
fn main() {
// [Rust] 동일 작업 시 약 0.07초 소요 (30배 이상 빠름)
fn fibonacci(n: u64) -> u64 {
    if n <= 1 { return n; }
    let (mut a, mut b) = (0, 1);
    for _ in 2..=n {
        let temp = b;
        b = a + b;
        a = temp;
    }
    b
}
}

2. 가비지 컬렉터(GC) 없는 메모리 안전성

파이썬의 참조 횟수 계산(Reference Counting) 방식은 순환 참조나 예측 불가능한 __del__ 호출 타이밍 문제를 안고 있습니다. Rust는 소유권(Ownership) 시스템을 통해 컴파일 타임에 모든 메모리 해제 시점을 결정합니다.

3. 파이썬의 고질적 문제와 Rust의 해법

① 런타임 타입 에러

파이썬의 타입 힌트는 단순한 '권고'일 뿐입니다. Rust는 잘못된 타입이 전달되면 아예 빌드조차 되지 않습니다.

② None: 10억 달러짜리 실수

파이썬에서는 어디서나 None이 튀어나와 AttributeError를 일으키곤 합니다. Rust는 Option<T>를 강제하여 값이 없는 경우를 반드시 처리하게 만듭니다.

③ GIL(Global Interpreter Lock)

파이썬의 스레드는 GIL 때문에 진정한 병렬 실행이 불가능합니다. Rust는 GIL이 없으며, 타입 시스템이 데이터 경합(Data Race)을 원천 차단하여 안전하고 빠른 병렬 처리를 보장합니다.

④ 배포의 지옥

venv, pip, 시스템 라이브러리 충돌 등 파이썬 배포는 늘 고통스럽습니다. Rust는 모든 의존성을 포함한 단일 바이너리를 생성하므로 복사만 하면 어디서든 실행됩니다.

4. 언제 Rust를 선택해야 할까?

• Rust 선택: 압도적 성능이 필요할 때, 메모리 비용을 절감해야 할 때, 단일 바이너리 배포가 중요할 때, 고부하 동시성 처리가 필요할 때.
• Python 유지: 빠른 프로토타이핑, 데이터 과학/AI 워크플로우(PyTorch, Pandas 등), 단순한 자동화 스크립트.
• 하이브리드(PyO3): 성능이 중요한 핵심 로직은 Rust로 짜고, 비즈니스 로직과 오케스트레이션은 파이썬으로 구현.

💡 실무 팁: Pydantic V2의 기적

인기 라이브러리인 Pydantic은 핵심 엔진을 Rust(PyO3 활용)로 재작성했습니다. 결과적으로 파이썬 API는 그대로 유지하면서 데이터 검증 속도를 5배에서 50배까지 끌어올렸습니다. 이것이 파이썬 개발자가 Rust를 배워야 하는 가장 현실적인 이유입니다.

시작하기: 설치부터 첫 번째 프로젝트까지

학습 목표: Rust 개발 환경을 구축하고, 파이썬의 pip/Poetry와 대응되는 Cargo 빌드 시스템을 익힙니다. 첫 번째 Hello, World! 프로그램을 작성하며 파이썬과 Rust의 근본적인 문법 차이를 이해하고 핵심 키워드들을 살펴봅니다.

1. Rust 설치 및 도구 비교

파이썬 개발자에게 익숙한 도구들이 Rust에서는 어떻게 매칭되는지 확인해 보세요.

2. 첫 번째 프로그램: Hello, World!

파이썬은 스크립트를 바로 실행하지만, Rust는 컴파일 과정을 거칩니다.

// src/main.rs
fn main() {
    // println!은 함수가 아니라 '매크로'입니다 (!가 붙음)
    println!("Hello, World!");
}

# 실행 방법
cargo run

파이썬 개발자가 느끼는 주요 차이점

• 진입점: 파이썬은 파일의 첫 줄부터 실행되지만, Rust는 반드시 main 함수에서 시작합니다.
• 세미콜론: 각 실행문의 끝에는 반드시 ;를 붙여 문장의 끝임을 알려야 합니다.
• 정적 타입: 변수의 타입은 컴파일 타임에 결정됩니다 (파이썬의 mypy가 강제되는 셈입니다).

3. 핵심 키워드 엿보기

파이썬과 비교하여 Rust의 핵심 키워드들을 빠르게 훑어봅니다.

• let / let mut: 변수를 선언합니다. Rust는 기본적으로 모든 변수가 **불변(Immutable)**입니다. 값을 바꾸려면 반드시 mut를 붙여야 합니다.
• match: 파이썬 3.10의 match-case와 유사하지만, 모든 경우의 수를 처리하지 않으면 컴파일 에러가 납니다.
• struct / impl: 파이썬의 클래스와 비슷하지만 데이터(struct)와 로직(impl)을 분리하여 정의합니다.
• pub: 파이썬의 _(private 관례)와 달리, Rust는 pub을 붙이지 않으면 모듈 외부에서 접근할 수 없습니다.

💡 실무 팁: cargo check의 마력

코드를 짤 때 매번 cargo build를 할 필요는 없습니다. cargo check를 사용하면 실행 파일을 만들지 않고 타입 오류만 빠르게 체크해주므로 개발 속도를 획기적으로 높일 수 있습니다.

변수와 기본 타입: 파이썬과 어떻게 다른가

학습 목표: Rust의 핵심 원칙인 '기본 불변성(Immutable-by-default)'을 이해하고, 파이썬의 무한 정수와 대비되는 Rust의 고정 크기 숫자 타입들을 익힙니다. 특히 파이썬 개발자가 가장 생소해하는 String과 &str의 차이점을 명확히 정리합니다.

1. 변수 선언과 가변성

파이썬은 모든 변수가 기본적으로 가변적이고 타입이 동적으로 변하지만, Rust는 정반대입니다.

# [Python] 자유로운 재할당과 타입 변경
count = 0
count = "zero" # 가능

#![allow(unused)]
fn main() {
// [Rust] 불변이 기본, 타입 변경 불가
let count = 0; // i32로 추론, 변경 불가
// count = 1;  // ❌ 에러

let mut count = 0; // mut를 붙여야 가변
count = 1;         // ✅ 가능
// count = "one";  // ❌ 에러: 타입은 못 바꿈
}

2. 기본 타입 비교

3. 문자열의 두 얼굴: String vs &str

파이썬 개발자가 Rust를 배울 때 가장 먼저 부딪히는 벽이 문자열입니다.

• &str (문자열 슬라이스): 문자열의 일부를 빌려온(Borrow) 것입니다. 읽기 전용 뷰라고 생각하면 쉽습니다. 파이썬의 일반적인 문자열 사용 사례와 가장 비슷합니다.
• String (소유한 문자열): 힙(Heap)에 할당된 가변적인 문자열입니다. 데이터를 추가하거나 수정해야 할 때 사용합니다.

#![allow(unused)]
fn main() {
let s1: &str = "Hello";        // 바이너리에 포함된 고정 문자열
let mut s2: String = s1.into(); // 소유권을 가진 String으로 변환
s2.push_str(" World!");        // 수정 가능
}

4. 출력과 포매팅

파이썬의 f-string과 매우 유사한 방식을 사용합니다.

# [Python] f-string
print(f"Name: {name}, Age: {age}")

#![allow(unused)]
fn main() {
// [Rust] println! 매크로
println!("Name: {name}, Age: {age}"); // 변수를 직접 넣거나
println!("Name: {} Age: {}", name, age); // 자리를 비워두고 나중에 넣기
}

💡 실무 팁: 디버그 출력 {:?}

파이썬에서 repr()이나 pprint를 사용하는 것처럼, Rust에서는 {:?} 기호를 사용해 구조체나 리스트의 내부 상태를 쉽게 확인할 수 있습니다. 단, 해당 타입에 #[derive(Debug)]가 붙어 있어야 합니다.

제어 흐름: 조건문, 반복문, 그리고 표현식

학습 목표: Rust의 if, for, match 등이 파이썬과 어떻게 다른지 배옵니다. 특히 모든 블록이 값을 반환할 수 있는 '표현식(Expression)' 중심의 사고방식을 익히고, 세미콜론 유무에 따른 반환값의 차이를 명확히 이해합니다.

1. 조건문 (if, else if, else)

파이썬의 elif 대신 else if를 사용하며, 조건식에 괄호는 필요 없지만 실행 블록의 중괄호({})는 필수입니다.

# [Python]
if temperature > 30:
    status = "hot"
else:
    status = "ok"

#![allow(unused)]
fn main() {
// [Rust] if는 표현식입니다. 값을 바로 변수에 할당할 수 있습니다.
let status = if temperature > 30 {
    "hot"
} else {
    "ok" // 세미콜론이 없으면 이 값이 반환됩니다.
};
}

2. 반복문과 반복자

파이썬의 range, enumerate, 리스트 컴프리헨션 등이 Rust에서 어떻게 구현되는지 비교해 봅니다.

💡 실무 팁: loop에서 값 반환하기

Rust의 loop는 break와 함께 값을 반환할 수 있습니다. 이는 특정 조건을 만족할 때까지 재시도하는 로직에서 매우 유용합니다.

#![allow(unused)]
fn main() {
let result = loop {
    let input = get_input();
    if let Ok(num) = input.parse::<i32>() {
        break num; // 숫자를 파싱하면 루프를 종료하고 값을 반환
    }
};
}

3. 표현식 vs 문장 (The Semicolon Rule)

Rust에서 가장 중요한 규칙 중 하나입니다.

• 표현식(Expression): 세미콜론 없이 끝나며 값을 반환합니다. (함수의 마지막 줄 등)
• 문장(Statement): 세미콜론으로 끝나며 값을 반환하지 않습니다 (단순 실행).

#![allow(unused)]
fn main() {
fn add(a: i32, b: i32) -> i32 {
    a + b // 세미콜론이 없으므로 a + b 결과가 return됨
}
}

4. 함수와 메서드

파이썬과 달리 매개변수와 반환값의 타입을 생략할 수 없습니다.

• fn: 함수를 정의합니다.
• &self vs &mut self: 메서드에서 객체를 읽기 전용으로 쓸지(&self), 수정할지(&mut self) 명확히 구분해야 합니다. 파이썬은 모든 self가 가변적이지만 Rust는 엄격히 제한합니다.

💡 실무 팁: 파이썬의 match-case vs Rust match

파이썬 3.10에 도입된 match-case는 Rust의 match를 벤치마킹한 것입니다. Rust의 match는 모든 경우의 수를 처리하지 않으면 컴파일조차 되지 않으므로, 런타임에 처리되지 않은 케이스로 인한 버그가 발생하지 않습니다.

데이터 구조와 컬렉션: 효율적인 데이터 관리

학습 목표: 파이썬의 리스트, 딕셔너리, 튜플이 Rust에서는 어떻게 대응되는지 배웁니다. 특히 파이썬의 클래스를 대체하는 Rust의 구조체(Struct) 시스템과, 힙 메모리를 효율적으로 사용하는 **컬렉션(Vec, HashMap)**의 활용법을 익힙니다.

1. 튜플과 구조 분해 (Tuples & Destructuring)

파이썬의 튜플과 거의 동일하게 작동하지만, Rust의 튜플은 고정된 크기와 타입을 가집니다.

# [Python] 언패킹
point = (10, 20)
x, y = point

#![allow(unused)]
fn main() {
// [Rust] 구조 분해
let point = (10, 20);
let (x, y) = point;

// 인덱스 접근은 대괄호([])가 아닌 점(.)을 사용합니다.
let first = point.0; // 10
}

2. 배열(Array)과 슬라이스(Slice)

파이썬의 리스트 슬라이싱과 비슷해 보이지만, Rust의 슬라이스는 복사하지 않고 원본을 바라보는 '뷰(View)' 역할을 합니다.

• 배열 ([T; N]): 크기가 고정된 스택 할당 데이터.
• 슬라이스 (&[T]): 배열이나 벡터의 일부분을 가리키는 참조자. 파이썬의 data[1:4]가 새 리스트를 만드는 것과 달리, Rust의 슬라이싱은 추가 메모리 할당이 없습니다.

3. 구조체 vs 클래스 (Structs vs Classes)

파이썬의 클래스를 Rust에서는 구조체(struct)와 구현체(impl)로 나누어 정의합니다. 상속은 지원하지 않으며, 대신 **트레이트(Trait)**를 통해 기능을 조합합니다.

💡 메모리 상의 차이

파이썬 객체는 모든 필드가 힙에 흩어져 있고 헤더 정보가 큽니다. 반면 Rust 구조체는 필드들이 메모리에 연속적으로 배치되어 훨씬 빠르고 가볍습니다.

4. 주요 컬렉션: Vec과 HashMap

Vec<T> (파이썬의 list 대응)

동적으로 크기가 변하는 배열입니다.

• 추가: push() (파이썬의 append)
• 제거: pop()
• 포함 확인: contains()

HashMap<K, V> (파이썬의 dict 대응)

키-값 쌍을 저장하는 대시 맵입니다.

• 삽입: insert()
• 값 가져오기: get() (결과가 Option으로 반환됨)
• Entry API: 파이썬의 defaultdict나 setdefault처럼 "값이 없으면 넣고, 있으면 가져오기"를 한 번에 처리합니다.

#![allow(unused)]
fn main() {
// 단어 빈도수 계산 예시 (Entry API)
let mut counts = HashMap::new();
for word in sentence.split_whitespace() {
    *counts.entry(word).or_insert(0) += 1;
}
}

💡 실무 팁: in 연산자 대신 contains

파이썬의 if x in my_list:는 Rust에서 if my_vec.contains(&x) { ... }로 작성합니다. Rust는 값의 소유권을 넘기지 않기 위해 참조자(&)를 사용한다는 점에 주의하세요.

열거형과 패턴 매칭: 데이터에 의미 부여하기

학습 목표: 파이썬 3.10에 도입된 match-case와 Union 타입의 모체가 된 Rust의 강력한 **열거형(Enum)**과 패턴 매칭을 배웁니다. 특히 데이터가 포함된 열거형과 None 에러를 원천 차단하는 Option<T>의 활용법을 익힙니다.

1. 데이터가 포함된 열거형 (Enum with Data)

파이썬의 Union 타입이나 클래스 상속으로 처리하던 복잡한 상태를 Rust는 하나의 열거형으로 우아하게 표현합니다.

# [Python 3.10+] Union 타입과 match
from typing import Union
Shape = Union[Circle, Rectangle]

def area(shape: Shape):
    match shape:
        case Circle(r): return 3.14 * r * r
        case Rectangle(w, h): return w * h
    # 만약 새로운 도형이 추가되었는데 여기서 누락해도 경고가 없습니다.

#![allow(unused)]
fn main() {
// [Rust] 데이터가 포함된 열거형
enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle { base: f64, height: f64 },
}

fn area(shape: &Shape) -> f64 {
    match shape {
        Shape::Circle(r) => 3.14 * r * r,
        Shape::Rectangle(w, h) => w * h,
        Shape::Triangle { base, height } => 0.5 * base * height,
        // 모든 경우(Circle, Rectangle, Triangle)를 처리하지 않으면 빌드가 안 됩니다.
    }
}
}

2. 철저한 매칭 (Exhaustive Matching)

파이썬의 match는 처리되지 않은 케이스가 있어도 런타임에 조용히 None을 반환하고 넘어가지만, Rust는 **철저함(Exhaustiveness)**을 강제합니다. 새로운 상태가 추가되면 컴파일 에러를 통해 수정해야 할 모든 지점을 알려줍니다.

3. None 안전성: Option

파이썬의 가장 큰 골칫거리인 None 참조 에러(AttributeError)를 Rust는 Option<T> 열거형으로 해결합니다.

💡 실무 팁: ? 연산자의 위력

함수 내에서 None을 만나면 바로 함수를 종료하고 None을 반환하고 싶을 때, 파이썬처럼 복잡한 if x is None 문을 쓸 필요가 없습니다. 그냥 변수 뒤에 ?를 붙이세요. (단, 함수의 반환 타입이 Option이어야 합니다.)

4. 패턴 매칭의 다양한 기법

• 가드(Guard): match x { n if n > 0 => ... } 처럼 추가 조건을 붙일 수 있습니다. (파이썬의 case x if x > 0:)
• 와일드카드(_): 처리할 필요가 없는 나머지 모든 경우를 묶습니다.
• 범위 매칭: 1..=10 => ... 처럼 연속된 숫자를 쉽게 매칭합니다.

💡 실무 팁: 열거형을 통한 상태 설계

단순히 "에러", "성공" 같은 문자열 상수를 쓰는 대신, Enum을 사용해 보세요. 데이터와 상태를 하나로 묶어 관리할 수 있어 코드가 훨씬 견고해지고 가독성이 좋아집니다.

소유권과 빌림: Rust의 심장

학습 목표: 파이썬 개발자가 가장 어려워하는 개념인 **소유권(Ownership)**을 정복합니다. 가비지 컬렉터(GC) 없이 메모리를 관리하는 원리를 이해하고, '이동(Move)'과 '빌림(Borrow)'의 차이를 통해 런타임 에러 없는 안전한 코드를 작성하는 법을 배웁니다.

1. 소유권이란 무엇인가?

파이썬은 GC가 알아서 메모리를 치워주지만, Rust는 모든 값에 **딱 하나의 주인(Owner)**이 있습니다. 주인이 사라지면 값도 즉시 메모리에서 사라집니다.

# [Python] 여러 변수가 하나의 객체를 가리킴 (참조 횟수 기반)
a = [1, 2, 3]
b = a  # a와 b가 같은 리스트를 바라봄
b.append(4)
print(a) # [1, 2, 3, 4] - a도 같이 바뀜!

#![allow(unused)]
fn main() {
// [Rust] 소유권 이동 (Move)
let a = vec![1, 2, 3];
let b = a; // 소유권이 a에서 b로 '이동'함
// println!("{:?}", a); // ❌ 에러: 더 이상 a를 쓸 수 없음
}

소유권의 세 가지 규칙

1. 모든 값은 각자의 주인이 있다.
2. 주인은 한 번에 딱 한 명뿐이다.
3. 주인이 스코프(Scope)를 벗어나면 값은 메모리에서 자동 해제된다.

2. 빌림 (Borrowing): 빌려주기 vs 소유권 넘기기

매번 소유권을 넘기는 것은 불편합니다. 그래서 Rust는 **참조자(&)**를 사용해 값을 잠시 빌려오는 기능을 제공합니다.

• 불변 빌림 (&T): 읽기 전용으로 빌려옵니다. 여러 명이 동시에 읽을 수 있습니다.
• 가변 빌림 (&mut T): 수정할 수 있게 빌려옵니다. 딱 한 명만 빌려갈 수 있습니다.

#![allow(unused)]
fn main() {
fn print_vec(v: &Vec<i32>) { // 읽기 전용으로 빌림 (소유권 유지)
    println!("{:?}", v);
}

let v = vec![1, 2, 3];
print_vec(&v); // 빌려줌
println!("{:?}", v); // 주인은 여전히 나 (사용 가능)
}

3. 이동(Move) vs 복사(Copy)

파이썬에서는 정수나 불리언 같은 기본 타입은 값이 복사되지만, 리스트나 딕셔너리는 참조가 공유됩니다. Rust도 비슷하지만 기준이 더 엄격합니다.

• Copy 타입: 정수, 부동 소수점, 불리언 등 (크기가 작고 고정됨). 대입 시 값이 복사됩니다.
• Move 타입: String, Vec, HashMap 등 (크기가 가변적임). 대입 시 소유권이 이동합니다. 데이터를 복제하고 싶다면 반드시 .clone()을 명시해야 합니다.

4. 스마트 포인터 (Smart Pointers)

소유권 규칙이 너무 까다로울 때 사용하는 도구들입니다. 파이썬의 객체 모델과 가장 흡사해지는 지점입니다.

• Box<T>: 데이터를 힙(Heap)에 저장하고 소유권은 혼자 가집니다.
• Rc<T>: 여러 명이 소유권을 공유할 때 사용합니다. (파이썬의 참조 횟수 계산 방식과 유사)
• Arc<T>: Rc의 멀티스레드 안전 버전입니다.
• RefCell<T>: 불변 데이터 내부의 값을 가변적으로 바꿀 수 있게 해줍니다. (내부 가변성)

💡 실무 팁: Rc<RefCell<T>>

파이썬처럼 "여러 곳에서 공유하고 어디서든 수정하고 싶다"면 이 조합을 사용합니다. 하지만 성능 오버헤드가 있으므로, 가급적 Rust의 기본 소유권/빌림 규칙을 따르는 설계를 먼저 고민하세요.

💡 실무 팁: 컴파일러의 에러 메시지는 '친구'입니다

빌림 검사기(Borrow Checker)가 내뱉는 에러는 당신을 괴롭히려는 것이 아니라, 나중에 발생할 런타임 버그나 데이터 경합을 미리 막아주는 예방 주사입니다. 에러 메시지를 천천히 읽어보면 대부분 어떻게 수정해야 할지 친절하게 알려줍니다.

크레이트와 모듈: 코드 조직화 및 패키지 관리

학습 목표: 파이썬의 패키지/모듈 시스템이 Rust에서는 어떻게 대응되는지 배웁니다. mod와 use의 차이점, pub 키워드를 통한 엄격한 가시성 제어, 그리고 pip/PyPI를 대체하는 Cargo/crates.io 생태계를 익힙니다.

1. 모듈 시스템: 파이썬 vs Rust

파이썬은 파일 자체가 자동으로 모듈이 되지만, Rust는 명시적인 선언이 필요합니다.

2. 가시성 (Visibility): "우리는 모두 성인이다" vs "컴파일러의 감시"

파이썬은 _를 붙여도 외부에서 접근할 수 있지만, Rust는 pub이 없으면 절대 접근할 수 없습니다.

#![allow(unused)]
fn main() {
pub struct User {
    pub name: String, // 공개 필드
    age: i32,         // 비공개 필드 (모듈 내부에서만 접근 가능)
}

impl User {
    pub fn new(name: &str, age: i32) -> Self {
        User { name: name.into(), age }
    }
}
}

3. 필수 크레이트 (Essential Crates)

파이썬 표준 라이브러리나 유명 패키지들에 대응하는 Rust 크레이트 목록입니다.

4. 워크스페이스 (Workspaces)

파이썬의 모노레포(Monorepo) 구성을 Rust에서는 워크스페이스 기능을 통해 공식적으로 지원합니다. 하나의 Cargo.lock 파일을 공유하여 의존성 버전을 통일하고 여러 크레이트를 한 번에 관리할 수 있습니다.

💡 실무 팁: mod.rs vs 파일 이름 모듈

최근 Rust 트렌드는 utils/mod.rs 대신 utils.rs 파일과 utils/ 디렉터리를 같은 계층에 두는 방식을 선호합니다. 프로젝트 구조를 잡을 때 참고하세요.

에러 처리: 예외(Exception)를 넘어 Result로

학습 목표: 파이썬의 try-except 방식과 Rust의 Result<T, E> 기반 에러 처리의 근본적인 차이를 배웁니다. 에러가 발생할 수 있음을 함수 시그니처에 명시하고, ? 연산자를 사용해 예외 전파를 우아하게 처리하는 법을 익힙니다.

1. 예외(Exception) vs Result

파이썬은 어디서든 예외를 던지고(raise) 어디서든 잡을(except) 수 있지만, Rust는 에러를 **반환값(Value)**으로 취급합니다.

2. Result<T, E>의 구조

Result는 성공(Ok) 혹은 실패(Err) 중 하나의 상태를 가지는 열거형입니다.

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),  // 성공 시 결과값
    Err(E), // 실패 시 에러 내용
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("0으로 나눌 수 없습니다".to_string())
    } else {
        Ok(a / b)
    }
}
}

3. ? 연산자: 우아한 에러 전파

파이썬에서 try-except 블록 없이 예외가 위로 전달되는 것처럼, Rust에서는 ? 하나로 에러를 상위 함수로 보낼 수 있습니다.

#![allow(unused)]
fn main() {
fn read_config() -> Result<String, io::Error> {
    // 파일 읽기에 실패하면 즉시 함수를 종료하고 Err을 반환합니다.
    let content = fs::read_to_string("config.txt")?;
    Ok(content)
}
}

4. 커스텀 에러 정의 (thiserror)

실무에서는 thiserror 크레이트를 사용해 여러 종류의 에러를 하나의 열거형으로 묶어서 관리합니다.

#![allow(unused)]
fn main() {
#[derive(thiserror::Error, Debug)]
pub enum MyError {
    #[error("입출력 오류: {0}")]
    Io(#[from] std::io::Error), // io::Error를 자동으로 MyError::Io로 변환
    
    #[error("데이터가 존재하지 않음")]
    NotFound,
}
}

💡 실무 팁: unwrap()은 테스트에서만

값이 반드시 있다고 확신할 때 쓰는 unwrap()은 운영 코드에서 가급적 피해야 합니다. 대신 expect("에러 메시지")를 써서 실패 이유를 명시하거나, ?를 사용하는 것이 Rust다운 방식입니다.

트레이트와 제네릭: 유연하고 안전한 설계

학습 목표: 파이썬의 '덕 타이핑(Duck Typing)'과 Rust의 트레이트(Trait) 방식을 비교하며 정적 타입 시스템에서의 추상화를 배웁니다. 제네릭을 통해 코드 재사용성을 높이고, 컴파일 타임에 모든 타입 제약을 검증하는 법을 익힙니다.

1. 트레이트 vs 덕 타이핑

파이썬은 "오리처럼 걷고 오리처럼 울면 오리다"라고 런타임에 판단하지만, Rust는 "오리처럼 행동하려면 반드시 오리(Duck) 트레이트를 구현해야 한다"라고 컴파일 타임에 선언합니다.

# [Python] 덕 타이핑 (런타임에 메서드 유무 확인)
def total_area(shapes):
    return sum(s.area() for s in shapes)

# area() 메서드가 없는 객체가 들어오면 런타임에 에러!

#![allow(unused)]
fn main() {
// [Rust] 트레이트 (컴파일 타임에 계약 명시)
trait HasArea {
    fn area(&self) -> f64;
}

fn total_area(shapes: &[&dyn HasArea]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

// HasArea를 구현하지 않은 타입을 넣으면 컴파일 에러!
}

2. 제네릭과 트레이트 바운드

파이썬의 TypeVar나 Generic과 유사하지만, Rust는 훨씬 더 강력하고 안전한 제약을 제공합니다.

#![allow(unused)]
fn main() {
// "T는 반드시 Display와 Debug를 구현해야 한다"는 제약을 겁니다.
fn log_and_print<T>(item: &T)
where
    T: std::fmt::Display + std::fmt::Debug,
{
    println!("로그: {:?}", item);
    println!("출력: {}", item);
}
}

3. 주요 표준 트레이트 (파이썬의 매직 메서드 대응)

파이썬에서 __str__이나 __add__ 같은 '던더(Dunder)' 메서드로 하던 일들을 Rust에서는 트레이트 구현으로 처리합니다.

4. 정적 디스패치 vs 동적 디스패치

• 정적 디스패치 (impl Trait): 컴파일 타임에 각 타입에 맞는 코드를 생성합니다. 실행 속도가 가장 빠릅니다. (기본값)
• 동적 디스패치 (dyn Trait): 런타임에 실제 타입을 확인하여 호출합니다. 파이썬의 기본 작동 방식과 비슷합니다.

💡 실무 팁: # [derive(...)] 활용하기

Debug, Clone, PartialEq 등 자주 쓰이는 트레이트들은 일일이 구현할 필요 없이 구조체 위에 #[derive(Debug, Clone)] 처럼 한 줄만 추가하면 컴파일러가 알아서 구현해 줍니다. 파이썬의 dataclass보다 훨씬 강력하고 편리합니다.

From과 Into 트레이트: 타입 변환의 정석

학습 목표: 파이썬의 생성자 기반 타입 변환(int(), str())을 대체하는 Rust의 **From**과 Into 트레이트를 배웁니다. 실패할 수 있는 변환을 처리하는 **TryFrom**의 활용법과, 관용적인 타입 변환 설계 방식을 익힙니다.

1. From과 Into: 안전하고 효율적인 변환

파이썬에서는 Celsius(fahrenheit_value) 처럼 생성자 내에서 변환 로직을 처리하는 경우가 많지만, Rust는 트레이트를 통해 이를 표준화합니다.

• From<T>: T 타입으로부터 현재 타입을 만드는 방법을 정의합니다.
• Into<T>: 현재 타입을 T 타입으로 변환하는 방법을 정의합니다. (보통 From을 구현하면 자동으로 생성됩니다.)

#![allow(unused)]
fn main() {
struct Celsius(f64);
struct Fahrenheit(f64);

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self {
        Celsius((f.0 - 32.0) * 5.0 / 9.0)
    }
}

// 사용 예시
let c = Celsius::from(Fahrenheit(212.0)); // From 방식
let c: Celsius = Fahrenheit(212.0).into(); // Into 방식
}

2. TryFrom: 실패할 수 있는 변환

파이썬에서 int("abc")를 실행하면 런타임에 에러가 나지만, Rust는 TryFrom을 통해 변환 실패 가능성을 컴파일 타임에 강제합니다.

#![allow(unused)]
fn main() {
// 문자열을 정수로 파싱 (실패 가능하므로 Result 반환)
let n: Result<i32, _> = "42".parse(); 

// 커스텀 타입 검증
impl TryFrom<u32> for Port {
    type Error = String;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        if value > 65535 {
            Err("포트 번호 범위를 초과함".to_string())
        } else {
            Ok(Port(value as u16))
        }
    }
}
}

3. 문자열 변환 패턴 (String Conversions)

파이썬 개발자가 가장 자주 사용하게 될 변환들입니다.

4. 핵심 규칙: From을 구현하라

항상 From을 구현하세요. 그러면 Into는 컴파일러가 알아서 구현해 줍니다. 반대로 Into를 직접 구현하는 것은 권장되지 않습니다.

💡 실무 팁: impl Into<T>를 활용한 유연한 함수 설계

함수의 매개변수 타입을 impl Into<String>으로 설정하면, 호출하는 쪽에서 &str을 넣든 String을 넣든 컴파일러가 알아서 알맞은 형태로 변환해 줍니다. 라이브러리 설계 시 매우 강력한 도구가 됩니다.

클로저와 반복자: 현대적 프로그래밍의 도구

학습 목표: 파이썬의 lambda와 제너레이터가 Rust에서 어떻게 대응되는지 배웁니다. 더 강력한 **클로저(Closure)**와 지연 연산을 수행하는 반복자(Iterator) 체인을 익히고, 코드 생성을 돕는 매크로(Macro) 시스템의 기초를 파악합니다.

1. 클로저: 파이썬의 람다 그 이상

파이썬의 lambda는 한 줄짜리 표현식만 가능하지만, Rust의 클로저는 여러 줄의 로직을 가질 수 있으며 주변 환경의 변수를 캡처하는 방식도 훨씬 정교합니다.

# [Python] 람다
double = lambda x: x * 2

#![allow(unused)]
fn main() {
// [Rust] 클로저 (|인자| 바디)
let double = |x: i32| x * 2;
let result = double(5); // 10

// 여러 줄 클로저
let complex = |x| {
    let y = x + 1;
    y * 2
};
}

💡 실무 팁: move 키워드

클로저 내부에서 외부 변수의 소유권을 가져와야 할 때(예: 멀티스레드로 전달할 때) move 키워드를 사용합니다. 이는 파이썬의 늦은 바인딩(Late Binding) 문제를 원천적으로 방지합니다.

2. 반복자: 제너레이터와 컴프리헨션의 진화

파이썬의 리스트 컴프리헨션이나 제너레이터 표현식은 Rust에서 반복자 체인으로 표현됩니다.

💡 지연 연산 (Lazy Evaluation)

Rust의 모든 반복자 체인은 .collect()나 반복문에서 실제로 사용되기 전까지는 아무런 동작도 하지 않습니다. 이는 메모리 효율을 극대화하며 복잡한 데이터 처리를 최적화합니다.

3. 매크로: 컴파일 타임의 마법

파이썬이 데코레이터나 메타클래스를 통해 런타임에 동적으로 기능을 추가한다면, Rust는 매크로를 통해 컴파일 타임에 코드를 생성합니다.

• println! / format!: 가변 인자를 지원하는 출력 매크로.
• vec![...]: 벡터를 쉽게 생성하는 매크로.
• #[derive(...)]: Debug, Clone 등 반복적인 트레이트 구현을 자동으로 생성해 주는 매크로 (파이썬의 @dataclass와 유사).

💡 실무 팁: dbg! 매크로를 활용하세요

파이썬에서 디버깅할 때 print(f"{x=}")를 즐겨 쓰시나요? Rust에는 dbg!(x)가 있습니다. 파일 이름, 줄 번호와 함께 변수의 값을 시각적으로 예쁘게 출력해 주며, 값을 그대로 반환하므로 코드 중간에 끼워 넣기 매우 편리합니다.

동시성: GIL의 굴레를 벗어나 진정한 병렬로

학습 목표: 파이썬의 가장 큰 제약 중 하나인 **GIL(Global Interpreter Lock)**의 한계를 이해하고, Rust가 이를 어떻게 극복하여 진정한 멀티코어 병렬 처리를 구현하는지 배웁니다. Send, Sync 트레이트를 통한 안전한 데이터 공유와 async/await의 차이점을 익힙니다.

1. No GIL: 진정한 병렬 처리가 가능한 이유

파이썬의 스레드는 GIL 때문에 한 번에 하나의 스레드만 실행될 수 있지만, Rust는 그런 제약이 없습니다. 4코어 CPU라면 4개의 스레드가 동시에 작업을 처리하여 약 4배의 성능 향상을 얻을 수 있습니다.

# [Python] GIL 때문에 CPU 작업은 여러 스레드를 써도 속도가 같음
import threading
def cpu_bound():
    # 무거운 연산...
threads = [threading.Thread(target=cpu_bound) for _ in range(4)]
# 실행 시간은 싱글 스레드와 거의 동일

#![allow(unused)]
fn main() {
// [Rust] 진정한 병렬 처리
use std::thread;
let handles: Vec<_> = (0..4).map(|_| {
    thread::spawn(|| {
        // 무거운 연산... (각 스레드가 각기 다른 코어에서 병렬 실행)
    })
}).collect();
}

2. 데이터 경합 방지: Send와 Sync

파이썬은 런타임에 데이터 경합(Data Race)이 발생하여 값이 꼬일 수 있지만, Rust는 컴파일 타임에 이를 원천 차단합니다.

• Send: 이 타입은 다른 스레드로 소유권을 넘길 수 있음.
• Sync: 이 타입은 여러 스레드에서 동시에 참조할 수 있음.

컴파일러가 이 속성을 자동으로 검사하므로, 안전하지 않은 방식으로 데이터를 공유하려고 하면 빌드조차 되지 않습니다.

3. 동시성 도구 비교 (Python vs Rust)

4. 비동기 프로그래밍 (async/await)

파이썬의 asyncio는 싱글 스레드 기반의 이벤트 루프를 사용하지만, Rust의 비동기 런타임(예: Tokio)은 기본적으로 멀티스레드 워커 풀을 사용합니다. 즉, 비동기 작업 중에도 CPU 연산을 병렬로 처리할 수 있습니다.

💡 실무 팁: Rayon의 마법

CPU 집약적인 작업을 처리할 때, Rust에서는 Rayon 크레이트를 써보세요. 기존의 .iter()를 .par_iter()로 바꾸기만 해도 자동으로 모든 CPU 코어를 사용하는 병렬 반복문으로 변신합니다. 별도의 멀티프로세싱 설정이나 직렬화 오버헤드 없이 압도적인 성능을 낼 수 있습니다.

Unsafe Rust와 FFI: 파이썬과의 공생

학습 목표: Rust의 안전 장치를 잠시 해제하는 **unsafe**의 개념을 이해하고, 이를 활용해 파이썬의 성능 병목 지점을 Rust로 대체하는 PyO3 라이브러리 사용법을 익힙니다. 또한 런타임 테스트를 위한 테스트 프레임워크 활용법을 배웁니다.

1. Unsafe Rust: 안전 장치 풀기

unsafe는 컴파일러가 검증할 수 없는 동작을 개발자가 책임지고 수행하겠다고 선언하는 도구입니다. 주로 하드웨어 제어나 파이썬과 같은 타 언어와의 통신(FFI) 시에 사용됩니다.

// C 언어의 abs 함수 호출 예시
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    // C 함수는 Rust 컴파일러가 안전성을 보장할 수 없으므로 unsafe 블록이 필요합니다.
    let result = unsafe { abs(-42) };
    println!("{result}"); // 42
}

2. PyO3: 파이썬 개발자를 위한 무기

PyO3를 사용하면 Rust 코드를 파이썬 모듈처럼 만들어서 쓸 수 있습니다. 이는 느린 파이썬 로직을 Rust로 재작성할 때 가장 강력한 방법입니다.

#![allow(unused)]
fn main() {
// Rust로 작성된 파이썬 확장 모듈 예시
use pyo3::prelude::*;

#[pyfunction]
fn rust_fibonacci(n: u32) -> u32 {
    // Rust의 빠른 연산 로직...
    n
}

#[pymodule]
fn my_extension(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(rust_fibonacci, m)?)?;
    Ok(())
}
}

3. 테스트와 벤치마킹

파이썬의 pytest에 대응하는 Rust의 내장 테스트 시스템을 사용합니다.

• 인라인 테스트: 코드 파일 안에 직접 테스트 코드를 작성합니다.
• cargo test: 모든 테스트를 한 번에 실행합니다.
• mockall: 인터페이스를 가짜로 만들어 테스트하는 모킹 기반 라이브러리.

4. 핵심 전략: 외부로 노출되는 API는 항상 'Safe'하게

내부적으로 unsafe를 썼더라도, 외부 사용자에게는 불완전한 상태로 노출되지 않도록 안전한 인터페이스로 감싸(Wrapping)는 것이 Rust의 공식적인 권장 패턴입니다.

💡 실무 팁: maturin을 기억하세요

PyO3로 만든 프로젝트를 빌드하고 설치할 때는 maturin이라는 도구를 사용합니다. maturin develop 한 번이면 Rust 코드가 컴파일되어 현재 파이썬 가상 환경에 패키지로 즉시 설치됩니다. 개발 흐름이 매우 매끄러워집니다.

마이그레이션 패턴: 파이썬 코드를 Rust로 옮기는 기술

학습 목표: 파이썬에서 즐겨 쓰던 관용구(Idioms)들이 Rust에서 어떻게 구현되는지 배웁니다. 딕셔너리, 컨텍스트 매니저, 데코레이터 등의 개념을 Rust의 구조체, RAII, 트레이트로 변환하는 구체적인 마이그레이션 전략을 익힙니다.

1. 주요 패턴 변환 (Python → Rust)

① Dictionary → Struct

파이썬에서 데이터를 담는 용도로 쓰던 딕셔너리는 Rust에서 타입이 명확한 **구조체(Struct)**로 변환합니다.

# [Python] 딕셔너리 기반 데이터 관리
user = {"name": "Alice", "age": 30}

#![allow(unused)]
fn main() {
// [Rust] 구조체 기반 데이터 관리
struct User {
    name: String,
    age: i32,
}
}

② Context Manager (with 문) → RAII (Drop 트레이트)

파이썬의 with 문을 통한 리소스 해제는 Rust에서 변수가 스코프를 벗어날 때 자동으로 실행되는 **Drop 트레이트(RAII)**가 담당합니다. 별도의 with 문 없이도 파일 닫기나 세션 해제가 보장됩니다.

③ Decorator → 고차 함수 또는 매크로

함수를 감싸는 데코레이터 패턴은 Rust에서 함수를 인자로 받는 고차 함수나, 컴파일 타임에 코드를 변형하는 매크로로 대체합니다.

2. 단계별 마이그레이션 전략

전체 서비스를 한 번에 옮기는 것은 위험합니다. 다음과 같은 단계별 접근을 권장합니다.

1. 프로파일링: 파이썬 코드에서 CPU를 가장 많이 사용하는 '병목 지점'을 찾습니다.
2. PyO3 확장 작성: 해당 병목 로직만 Rust로 작성하여 파이썬 모듈로 만듭니다.
3. 부분 교체: 기존 파이썬 함수를 새로 만든 Rust 함수로 바꿉니다. (성능 10~100배 향상)
4. 점진적 확장: 이 과정을 반복하며 점차 Rust의 비중을 높여갑니다.

3. 마이그레이션 결정 매트릭스

💡 실무 팁: serde는 필수입니다

파이썬 프로젝트를 Rust로 옮길 때 가장 먼저 도입해야 할 크레이트는 serde입니다. JSON, YAML, TOML 등 모든 데이터 포맷을 정적 타입 구조체로 변환해 주어, 파이썬의 동적 타입으로 인한 런타임 에러를 획기적으로 줄여줍니다.

모범 사례: 파이썬 개발자를 위한 관용적인 Rust

학습 목표: 파이썬의 습관을 버리고 Rust다운 코드를 짜기 위한 10가지 수칙을 배웁니다. 흔히 저지르는 실수들과 그 해결책, 그리고 3개월간의 점진적 학습 로드맵을 통해 숙련된 Rustacean으로 거듭나는 과정을 안내합니다.

1. 지켜야 할 10가지 습관

1. if isinstance() 대신 match 사용: 타입 검사보다는 패턴 매칭이 훨씬 안전하고 명확합니다.
2. 컴파일러 에러 메시지를 정독하라: Rust 컴파일러는 세상에서 가장 친절한 선생님입니다. 에러 원인뿐만 아니라 해결책까지 알려줍니다.
3. 함수 파라미터는 String보다 &str: 더 넓은 범위의 인자를 효율적으로 받을 수 있습니다.
4. 인덱스 반복문보다 반복자(Iterator): for i in 0..len 보다는 .iter()를 사용한 체이닝이 더 안전하고 빠릅니다.
5. Option과 Result를 사랑하라: unwrap() 사용을 최소화하고 에러 처리를 타입 시스템에 맡기세요.
6. #[derive]를 적극 활용하라: Debug, Clone, Default 등의 트레이트는 컴파일러에게 맡기는 게 가장 빠르고 정확합니다.
7. cargo clippy를 믿으라: 파이썬의 ruff보다 훨씬 강력한 정적 분석 도구입니다. 제안하는 내용을 코드에 반영해 보세요.
8. 빌림 검사기(Borrow Checker)와 싸우지 마라: 막힌다면 데이터 구조 자체에 문제가 있을 확률이 높습니다. 소유권을 명확히 재설계하세요.
9. 상태 관리는 열거형(Enum)으로: 불리언 플래거나 문자열 상수 대신 Enum을 써서 모든 경우의 수를 강제하세요.
10. 일단 복사(Clone)하고 나중에 최적화하라: 학습 초기에는 소유권에 막혀 진도가 안 나가는 것보다 .clone()을 써서 끝까지 구현해 보는 게 중요합니다.

2. 성능 비교: 파이썬 vs Rust (Release 빌드)

3. 학습 로드맵 (3개월 완성)

• 1~2주차 (기초): 설치, 기본 타입, 제어 흐름 익히기. (컴파일 에러와 친해지는 기간)
• 3~4주차 (핵심): 구조체, 열거형, 소유권 개념 정립. (파이썬 코드를 Rust로 조금씩 옮겨보기)
• 2개월차 (중급): 에러 처리, 트레이트, 반복자 활용. (PyO3를 이용한 파이썬 확장 모듈 작성)
• 3개월차 (고급): 동시성, 비동기(Tokio), 테스트 및 최적화. (실제 프로젝트에 Rust 도입)

💡 실무 팁: 마지막 조언

파이썬에서 누리던 '유연함'은 Rust에서 '안전함'으로 치환됩니다. 처음에는 컴파일러가 사사건건 간섭하는 것처럼 느껴지겠지만, 어느 순간 "실행되는 코드는 무조건 올바르다"는 강력한 확신을 갖게 될 것입니다. Rust는 여러분을 단순히 성능 좋은 프로그램을 개발하게 해줄 뿐만 아니라, 더 나은 프로그래머로 성장시켜 줄 것입니다.

캡스톤 프로젝트: CLI 할 일 관리 도구 만들기

학습 목표: 지금까지 배운 모든 개념(구조체, 열거형, 소유권, 에러 처리, 반복자 등)을 총동원하여 실제 사용 가능한 CLI 애플리케이션을 구축합니다. 파이썬의 argparse와 json 라이브러리로 만들던 도구를 Rust로 어떻게 더 안전하고 빠르게 구현하는지 직접 체험합니다.

1. 프로젝트 개요: rustdo

rustdo는 JSON 파일에 할 일을 저장하고 관리하는 간단한 CLI 도구입니다.

• 데이터 모델: 할 일(Task)과 우선순위(Priority) 정의
• 저장소: 로컬 JSON 파일 읽기/쓰기 (Serde 활용)
• 명령어 처리: add, list, done, remove 등 패턴 매칭으로 구현
• 비즈니스 로직: 반복자와 클로저를 활용한 데이터 필터링 및 가공

2. 구현 단계별 핵심 포인트

① 데이터 모델링 (구조체와 열거형)

파이썬의 @dataclass와 Enum 대신 Rust의 struct와 enum을 사용하고, #[derive(Serialize, Deserialize)]를 통해 직렬화 기능을 즉시 부여합니다.

② 저장소 계층 (에러 처리)

파일이 없을 때의 처리나 JSON 파싱 에러 등을 Result<T, E>와 ? 연산자로 우아하게 전파합니다. 파이썬의 try-except보다 명확한 흐름을 가집니다.

③ 명령어 파싱 (패턴 매칭)

사용자 입력을 match 문으로 분석하여 각 기능으로 분기합니다. 이 과정에서 Rust 특유의 '철저한 검사' 덕분에 예외적인 입력을 놓칠 리가 없습니다.

④ 비즈니스 로직 (반복자의 힘)

할 일 목록 중 완료되지 않은 것만 골라내거나(filter), 전체 개수를 세는(count) 작업 등을 반복자 체인 하나로 깔끔하게 처리합니다.

3. 프로젝트를 마치며 연습해 볼 것들

기본 기능을 완성했다면 다음 기능들을 직접 추가해 보세요:

• 날짜 필터링: chrono 라이브러리를 사용해 마감일 기준 정렬하기
• 색상 출력: colored 크레이트로 우선순위에 따라 터미널 색상 입히기
• 고급 파싱: clap 라이브러리를 도입하여 본격적인 CLI 인터페이스 구축하기

💡 실무 팁: "이제 당신은 Rustacean입니다"

이 프로젝트를 무사히 마쳤다면, 당신은 단순히 Rust를 아는 파이썬 개발자가 아닙니다. 두 언어의 장단점을 명확히 이해하고, 상황에 맞는 최적의 도구를 선택할 줄 아는 숙련된 엔지니어가 된 것입니다. 축하합니다!