Rust 완전 가이드: 기초부터 커널 적용까지

Rust 언어의 탄생 배경과 설계 철학, 기초 문법(변수, 타입, 소유권, 빌림, 수명, 패턴 매칭, 에러 처리)부터 중급(트레이트, 제네릭, 컬렉션, 반복자, 스마트 포인터, 동시성, 매크로, 메모리 레이아웃), 고급(unsafe, FFI, async/await, Pin, no_std)까지 모든 레벨을 다루고, Linux 커널에서의 Rust 적용(아키텍처, Kbuild 통합, bindgen, 추상화 계층, 드라이버, 테스팅, 디버깅, C→Rust 마이그레이션 전략)을 SVG 다이어그램과 함께 심층 해설합니다.

C vs Rust 핵심 개념 대조표

C 개발자가 Rust를 배울 때 가장 혼란스러운 부분을 한눈에 비교할 수 있는 대조표입니다.

Rust 탄생 배경과 역사

Rust는 2006년 Mozilla 직원 Graydon Hoare의 개인 프로젝트로 시작되었습니다. C/C++의 메모리 안전성 문제를 근본적으로 해결하면서도 시스템 프로그래밍 수준의 성능을 유지하겠다는 목표로 설계되었습니다.

Rust 설계 철학: 안전성·동시성·성능

Rust의 설계 철학은 "안전성과 성능은 트레이드오프가 아니다"라는 명제에 기반합니다. 전통적으로 C/C++은 성능을 위해 안전성을 희생하고, Java/Python은 안전성을 위해 성능을 희생했습니다. Rust는 컴파일 타임 검증을 통해 런타임 비용 없이 안전성을 보장합니다.

핵심 설계 원칙

// 제로 코스트 추상화 예시: 반복자 체인은 수동 루프와 동일한 기계어 생성
let sum: i64 = (1..1000)
    .filter(|n| n % 3 == 0 || n % 5 == 0)
    .sum();  // 컴파일러가 최적의 루프 하나로 변환

// Fearless Concurrency: 소유권 이전으로 데이터 레이스 원천 방지
let data = vec![1, 2, 3];
std::thread::spawn(move || {
    // data의 소유권이 이 스레드로 이동 — 원래 스레드에서 접근 불가
    println!("{:?}", data);
});
// println!("{:?}", data); ← 컴파일 에러! 소유권이 이미 이동함

시스템 프로그래밍 언어 비교

Rust 생태계와 도구

Rust의 강력한 생태계는 언어 자체만큼이나 중요합니다. rustup으로 툴체인을 관리하고, cargo로 빌드·의존성·테스트를 통합 관리하며, crates.io에서 수십만 개의 라이브러리를 활용할 수 있습니다.

# Rust 설치 (공식 방법)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 프로젝트 생성과 빌드
cargo new hello_rust && cd hello_rust
cargo build             # 디버그 빌드
cargo build --release   # 최적화 빌드 (릴리스용)
cargo test              # 모든 테스트 실행
cargo doc --open        # API 문서 생성 후 브라우저 열기

# Cargo.toml 의존성 추가
cargo add serde --features derive  # serde + derive 피처 추가
cargo add tokio --features full    # tokio 비동기 런타임

# Cargo.toml 예시
[package]
name = "hello_rust"
version = "0.1.0"
edition = "2024"    # Rust Edition (2015, 2018, 2021, 2024)

[dependencies]
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
criterion = "0.5"   # 벤치마크 라이브러리

[profile.release]
opt-level = 3       # 최대 최적화
lto = true          # 링크 타임 최적화

변수, 타입 시스템, 섀도잉

Rust에서 변수는 기본적으로 불변(immutable)입니다. 변경이 필요하면 mut 키워드로 명시해야 합니다. 이는 실수로 인한 값 변경을 방지하고, 의도적인 변경을 코드에서 명확히 드러냅니다.

// 변수 선언과 불변성
let x = 5;          // 불변 — 기본값
// x = 6;            // ← 컴파일 에러! 불변 변수에 재대입 불가

let mut y = 10;     // 가변 — mut 명시 필요
y = 20;              // OK

// 상수 — 컴파일 타임에 결정, 타입 명시 필수
const MAX_POINTS: u32 = 100_000;

// 섀도잉(Shadowing) — 같은 이름으로 새 변수를 선언하여 타입 변환도 가능
let spaces = "   ";         // &str 타입
let spaces = spaces.len();   // usize 타입으로 변환 — 같은 이름의 새 변수
// mut와 달리 타입이 변경 가능하고, 새 변수는 불변

let, const, static 비교

Rust에서 값을 바인딩하는 세 가지 키워드의 차이를 이해하는 것이 중요합니다.

// let — 런타임 값 바인딩 (가장 일반적)
let start = std::time::Instant::now();  // 런타임에 결정되는 값 OK

// const — 컴파일 타임 상수 (사용 시마다 값이 인라인 삽입)
const MAX_RETRIES: u32 = 3;        // 타입 명시 필수, 주소 없음
const HEADER: &str = "X-Custom";  // 문자열 리터럴도 가능

// static — 고정 메모리 주소를 가지는 전역 변수
static COUNTER: AtomicU64 = AtomicU64::new(0);  // 주소가 있어 참조 가능
static mut BUFFER: [u8; 1024] = [0; 1024];   // static mut → unsafe 필수!

// 커널에서: const로 ioctl 번호, static으로 전역 구조체 정의
// const IOCTL_GET_INFO: u32 = 0x8004_0001;
// static DEVICE: Mutex<Option<Device>> = Mutex::new(None);

스칼라 타입

복합 타입

// 튜플 — 서로 다른 타입의 값을 묶음
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup;           // 구조 분해
let first = tup.0;             // 인덱스 접근

// 배열 — 같은 타입, 고정 길이 (스택 할당)
let arr: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0; 10];           // [0, 0, 0, ..., 0] — 10개 0으로 초기화
let first = arr[0];            // 인덱스 접근 (범위 검사 포함!)

// 슬라이스 — 배열/벡터의 연속된 부분 참조
let slice: &[i32] = &arr[1..3]; // [2, 3] — 소유권 없이 참조

// 문자열 타입
let s1: &str = "hello";       // 문자열 슬라이스 (불변, 스택/정적 영역)
let s2: String = String::from("hello"); // 소유된 문자열 (힙, 가변 가능)
let s3 = s2.as_str();          // String → &str 변환

// 타입 변환(casting)
let x: i32 = 42;
let y: f64 = x as f64;       // 명시적 변환 필수 (암묵적 변환 없음!)
let z: u8 = 256 as u8;       // 오버플로: 0 (값이 잘림)

// 정수 리터럴 접미사
let a = 42u32;               // u32 타입
let b = 3.14f32;             // f32 타입
let c = 0xFF_u8;             // 16진수 u8
let d = 0b1010_0110;         // 2진수
let e = 1_000_000;           // 밑줄로 자릿수 구분 (가독성)

정수 오버플로 동작

// 명시적 오버플로 제어 메서드 (빌드 모드와 무관하게 동일 동작)
let a: u8 = 250;
a.wrapping_add(10)     // 4 — 항상 래핑
a.checked_add(10)      // None — 오버플로 시 None 반환
a.saturating_add(10)   // 255 — 최대값에서 포화
a.overflowing_add(10)  // (4, true) — 값 + 오버플로 플래그

// 커널에서는 wrapping_* 또는 checked_*를 사용하여
// 정수 오버플로를 명시적으로 처리해야 합니다.

타입 별칭과 const fn

Rust의 type 키워드는 기존 타입에 대한 별칭(alias)을 만듭니다. 새로운 타입을 정의하는 것이 아니라, 긴 타입 표기를 짧게 줄여 가독성을 높이는 용도입니다. const fn은 컴파일 타임에 평가 가능한 함수를 정의하며, 커널처럼 런타임 비용을 최소화해야 하는 환경에서 특히 유용합니다.

// ── 타입 별칭(Type Alias) ──
type Kilometers = i32;  // i32와 완전히 동일한 타입

let distance: Kilometers = 42;
let raw: i32 = 10;
let total = distance + raw;  // OK — 같은 타입이므로 연산 가능

// 복잡한 타입을 줄일 때 유용
type Thunk = Box<dyn Fn() + Send + 'static>;
type Result<T> = std::result::Result<T, std::io::Error>;  // std::io에서 실제 사용

fn spawn_task(f: Thunk) { /* Box<dyn Fn() + Send + 'static> 대신 간결 */ }
fn read_file() -> Result<String> { /* std::result::Result<String, io::Error> */ }

// 커널에서의 타입 별칭
// kernel::Result<T> = core::result::Result<T, kernel::error::Error>
// 커널 코드 전체에서 간결하게 Result<()>, Result<i32> 등으로 사용

// ── const fn: 컴파일 타임 함수 ──

// const: 컴파일 타임 상수 (값만 가능)
const MAX_SIZE: usize = 1024;

// const fn: 컴파일 타임에 평가 가능한 함수
const fn kilobytes(kb: usize) -> usize {
    kb * 1024
}

const BUFFER_SIZE: usize = kilobytes(4);   // 4096 — 컴파일 타임에 계산
let runtime_size = kilobytes(8);           // 런타임에도 호출 가능

// const fn으로 비트 마스크 생성
const fn bit_mask(bits: u32) -> u32 {
    (1u32 << bits) - 1
}

const LOW_4_BITS: u32 = bit_mask(4);   // 0b1111 = 15
const LOW_8_BITS: u32 = bit_mask(8);   // 0xFF = 255

// const fn의 제약 (Rust 안정 채널 기준)
// - 힙 할당 불가 (Box, Vec, String 등)
// - 트레이트 객체 호출 불가
// - 부동소수점 연산 가능 (Rust 1.82+)
// - if/match/loop 사용 가능 (Rust 1.46+)

const fn clamp(val: i32, min: i32, max: i32) -> i32 {
    if val < min { min }
    else if val > max { max }
    else { val }
}

const CLAMPED: i32 = clamp(150, 0, 100);  // 100 — 컴파일 타임에 결정

문자열 타입 심층 (&str vs String)

Rust에는 두 가지 핵심 문자열 타입이 있습니다. String은 힙에 할당된 가변 소유 문자열이고, &str은 UTF-8 바이트 시퀀스에 대한 불변 참조(슬라이스)입니다. C의 char*와 달리 Rust 문자열은 항상 유효한 UTF-8이며, null 종단이 아닌 길이 정보를 함께 저장합니다.

// ── 문자열 생성과 변환 ──
let s1: &str = "hello";                      // 문자열 리터럴: 정적 메모리, 타입은 &'static str
let s2: String = String::from("hello");       // 힙에 복사하여 String 생성
let s3: String = "hello".to_string();          // 동일한 결과
let s4: &str = &s2;                             // Deref 강제: &String → &str 자동 변환
let s5: &str = s2.as_str();                     // 명시적 변환
let s6: &str = &s2[0..3];                      // 슬라이싱 (바이트 인덱스!)

// ── UTF-8 인코딩과 인덱싱 ──
let korean = "한글";
korean.len()          // 6 — 바이트 길이 (한 = 3바이트, 글 = 3바이트)
korean.chars().count() // 2 — 문자(char) 수
// korean[0]          // 컴파일 에러! 인덱싱 불가
// 이유: UTF-8은 가변 길이 인코딩이므로 O(1) 인덱싱이 불가능

// 올바른 문자 순회 방법
for ch in "한글rust".chars() {
    print!("{} ", ch);  // 한 글 r u s t
}
for b in "한글".bytes() {
    print!("{:02x} ", b);  // ed 95 9c ea b8 80
}

// 그래핌 클러스터: 사용자가 인식하는 "문자" 단위
// "é" = 'e' + '\u{0301}' (결합 분음 부호)
// chars()는 2개, 그래핌은 1개 → unicode-segmentation 크레이트 필요

// ── String 조작 메서드 ──
let mut s = String::from("Hello");

// 추가
s.push(' ');                    // char 하나 추가
s.push_str("World");            // &str 추가 → "Hello World"

// 연결
let s1 = String::from("Hello");
let s2 = String::from(" World");
let s3 = s1 + &s2;              // + 연산자: s1 소유권 이동! (s1은 더 이상 사용 불가)
                                 // fn add(self, s: &str) → self를 소비
let s4 = format!("{} {}", "Hello", "World");  // 소유권 이동 없이 연결

// 검색과 변환
let text = "Rust is fast and safe";
text.contains("fast")            // true
text.starts_with("Rust")         // true
text.replace("fast", "efficient") // "Rust is efficient and safe" (새 String 반환)
text.to_uppercase()              // "RUST IS FAST AND SAFE"

// 분할과 트림
let parts: Vec<&str> = "a,b,c".split(',').collect();  // ["a", "b", "c"]
"  hello  ".trim()  // "hello" — 양쪽 공백 제거

// 숫자 변환
let n: i32 = "42".parse().unwrap();     // &str → i32
let s: String = 42.to_string();        // i32 → String

// ── C 문자열과의 비교 및 FFI ──

// C: null 종단 문자열 → strlen()으로 길이 계산 O(n)
// char *s = "hello\0";  // 실제 6바이트 (null 포함)

// Rust String: 길이 저장 → len() 은 O(1)
// String { ptr, len: 5, cap: 8 }  // null 없음, 길이 즉시 반환

// FFI에서 C 문자열과 상호운용
use std::ffi::{CStr, CString};

// Rust → C: CString (소유, null 종단 보장)
let c_string = CString::new("hello").unwrap();  // 내부에 null이 있으면 Err
let ptr: *const c_char = c_string.as_ptr();    // C 함수에 전달

// C → Rust: CStr (빌림, null 종단 가정)
unsafe {
    let c_str = CStr::from_ptr(ptr);              // *const c_char → &CStr
    let rust_str: &str = c_str.to_str().unwrap(); // &CStr → &str (UTF-8 검증)
}

// 커널에서: kernel::str::CStr — 커널 전용 CStr 래퍼
// c_str!("device_name") 매크로로 커널 C 문자열 생성
// kernel::fmt 모듈로 커널 로깅에 문자열 포맷팅

함수, 제어 흐름, 표현식

Rust에서 함수는 fn 키워드로 선언합니다. 모든 매개변수의 타입을 명시해야 하며, 함수 본문의 마지막 표현식이 반환값이 됩니다(세미콜론 없이). Rust는 표현식 기반 언어로, if, match, 블록 {} 모두 값을 반환합니다.

// 함수 선언 — 반환 타입은 -> 뒤에 명시
fn add(a: i32, b: i32) -> i32 {
    a + b  // 세미콜론 없음 = 표현식으로 반환
}

// 표현식 기반: if는 값을 반환함
let number = 7;
let category = if number > 5 { "big" } else { "small" };

// 블록도 표현식 — 마지막 값이 블록의 값
let result = {
    let x = 3;
    let y = 4;
    x * x + y * y  // 25가 result에 대입됨
};

// 반복문
for i in 0..5 {              // 0, 1, 2, 3, 4
    println!("{}", i);
}

for (idx, val) in arr.iter().enumerate() {
    println!("[{}] = {}", idx, val);
}

// loop — 무한 루프 + break로 값 반환
let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;  // 20을 반환
    }
};

// while let — Option/Result 패턴 소진
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("{}", top);  // 3, 2, 1 순서로 출력
}

함수 포인터와 클로저 인자

// 함수 포인터 — C의 함수 포인터와 유사
fn apply(f: fn(i32) -> i32, x: i32) -> i32 {
    f(x)
}
fn double(n: i32) -> i32 { n * 2 }
let result = apply(double, 5);  // 10

// 클로저를 인자로 — 제네릭 바운드 사용
fn apply_closure<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(x)
}
let multiplier = 3;
let result = apply_closure(|n| n * multiplier, 5);  // 15

// 클로저 트레이트 3종류:
// Fn(&self)     — 환경을 불변 빌림 (여러 번 호출 가능)
// FnMut(&mut self) — 환경을 가변 빌림
// FnOnce(self)  — 환경을 소유 (한 번만 호출)

// 발산 함수 — 절대 반환하지 않음 (! 타입)
fn forever() -> ! {
    loop { /* 무한 반복 */ }
}

// 조기 반환 (early return)
fn find_first_positive(nums: &[i32]) -> Option<i32> {
    for &n in nums {
        if n > 0 { return Some(n); }  // 조기 반환
    }
    None
}

클로저 캡처 모드 비교

// move 클로저 — 환경의 소유권을 클로저로 이동
let name = String::from("Rust");
let greet = move || println!("Hello, {}", name);
// name은 이제 사용 불가 (소유권이 클로저로 이동)
greet();  // "Hello, Rust"

// 커널에서의 클로저: 콜백 등록 시 move 클로저 사용 빈번
// 예: workqueue에 작업 등록 시 필요한 데이터를 move로 전달

소유권(Ownership) 심층 해설

소유권은 Rust의 가장 독창적인 기능이자 핵심 개념입니다. GC(Garbage Collector) 없이 메모리를 안전하게 관리하는 컴파일 타임 규칙 체계입니다.

/* C에서의 소유권 없는 메모리 관리 — 런타임 버그 발생 */
char *s1 = malloc(6);
strcpy(s1, "hello");

char *s2 = s1;       /* 두 포인터가 같은 메모리를 가리킴 — 소유자가 불명확! */
free(s1);            /* s1으로 해제 */
printf("%s\n", s2);  /* ← Use-After-Free! 해제된 메모리 접근 (정의되지 않은 동작) */
free(s2);            /* ← Double-Free! 같은 메모리를 두 번 해제 (보안 취약점) */

/* Rust라면: let s2 = s1; 에서 s1이 무효화되어
   위 두 줄 모두 컴파일 에러 → 버그 자체가 불가능 */

소유권 3대 규칙

1. Rust의 각 값에는 소유자(owner)라는 변수가 하나만 존재합니다.
2. 소유자가 스코프를 벗어나면 값이 자동으로 해제(drop)됩니다.
3. 소유권은 이동(move)됩니다 — 대입이나 함수 호출 시 원래 소유자는 무효화됩니다.

// 이동(Move) 의미론 — 힙 할당 타입
let s1 = String::from("hello");
let s2 = s1;            // s1의 소유권이 s2로 이동
// println!("{}", s1);   // ← 컴파일 에러! s1은 더 이상 유효하지 않음
println!("{}", s2);      // OK — s2가 소유자

// 복사(Copy) 의미론 — 스택 타입 (i32, f64, bool, char, 고정 크기 배열 등)
let a: i32 = 42;
let b = a;              // Copy! a도 여전히 유효
println!("a={}, b={}", a, b); // 둘 다 사용 가능

// 소유권 이동과 함수
fn take_ownership(s: String) {
    println!("{}", s);
} // s가 스코프를 벗어남 → 자동 drop

let my_string = String::from("owned");
take_ownership(my_string);     // 소유권 이동
// println!("{}", my_string);  // ← 컴파일 에러!

// 소유권 반환
fn give_back(s: String) -> String {
    s  // 소유권을 호출자에게 반환
}

let s = String::from("return me");
let s = give_back(s);  // 소유권 이동 → 반환 → 재소유

// Clone — 힙 데이터의 깊은 복사 (명시적, 비용 있음)
let s1 = String::from("deep copy");
let s2 = s1.clone();   // 힙 데이터 전체 복사
println!("s1={}, s2={}", s1, s2); // 둘 다 유효

// Drop 트레이트 — 소유자가 스코프를 벗어날 때 자동 호출
struct Resource { name: String }

impl Drop for Resource {
    fn drop(&mut self) {
        println!("자원 해제: {}", self.name);
    }
}

{
    let r1 = Resource { name: String::from("first") };
    let r2 = Resource { name: String::from("second") };
    // 스코프 끝: r2 먼저 해제, 그 다음 r1 해제 (역순!)
    // 출력: "자원 해제: second" → "자원 해제: first"
}
// 커널의 RAII: miscdev::Registration, MutexGuard, irq::Registration 등
// 모두 Drop을 구현하여 자동으로 자원을 해제합니다

부분 이동(Partial Move)과 소유권 분할

구조체의 필드 중 일부만 이동(move)하면, 해당 필드는 사용 불가하지만 나머지 필드는 여전히 접근 가능합니다. 이를 부분 이동(Partial Move)이라 하며, 소유권 시스템의 세밀한 추적 능력을 보여줍니다.

// ── 부분 이동 기본 예제 ──
struct Person {
    name: String,    // 소유 타입 — 이동 가능
    age: u32,        // Copy 타입 — 항상 복사
}

let person = Person {
    name: String::from("Alice"),
    age: 30,
};

// name 필드만 이동
let name = person.name;     // name 소유권 이동
println!("나이: {}", person.age);   // OK — age는 Copy이므로 여전히 사용 가능
// println!("{}", person.name);    // 컴파일 에러! name은 이미 이동됨
// println!("{:?}", person);       // 컴파일 에러! 구조체 전체 사용 불가

// ── 부분 이동 방지: ref 패턴 ──
let person = Person {
    name: String::from("Bob"),
    age: 25,
};

// ref로 빌림 — 소유권을 이동하지 않음
let Person { ref name, age } = person;
println!("이름: {}, 나이: {}", name, age);  // name은 &String
println!("전체: {} {}", person.name, person.age);  // OK — person 아직 유효

// ── 필요한 필드만 clone ──
let person = Person {
    name: String::from("Charlie"),
    age: 35,
};

let name_copy = person.name.clone();  // 복제 — 원본 유지
println!("복사: {}, 원본: {}", name_copy, person.name);  // 둘 다 OK

// ── match에서의 부분 이동 ──
enum Message {
    Text(String),
    Data(Vec<u8>),
}

let msg = Message::Text(String::from("hello"));
match &msg {                // &로 빌림 — msg 소유권 유지
    Message::Text(s) => println!("텍스트: {}", s),   // s는 &String
    Message::Data(d) => println!("데이터: {} 바이트", d.len()),
}
// msg는 여전히 사용 가능 (빌림만 했으므로)

String 내부 구조와 메모리 모델

String은 내부적으로 Vec<u8>의 래퍼이며, 스택에 포인터(ptr), 길이(len), 용량(capacity) 3개 필드를 저장하고 실제 UTF-8 데이터는 힙에 위치합니다. push_str 등으로 문자열이 커질 때 용량이 부족하면 재할당(reallocation)이 발생합니다.

// ── with_capacity로 재할당 최소화 ──
let mut s = String::with_capacity(100);  // 100바이트 미리 할당
println!("len: {}, cap: {}", s.len(), s.capacity());  // len: 0, cap: 100

for _ in 0..10 {
    s.push_str("hello!");  // 60바이트까지는 재할당 없음
}
println!("len: {}, cap: {}", s.len(), s.capacity());  // len: 60, cap: 100

// 실제 사용량에 맞게 용량 축소
s.shrink_to_fit();
println!("축소 후 cap: {}", s.capacity());  // cap: 60

// ── String과 Vec<u8>의 관계 ──
let s = String::from("hello");
let bytes: Vec<u8> = s.into_bytes();          // String → Vec<u8> (이동, 할당 없음)
let s2 = String::from_utf8(bytes).unwrap();  // Vec<u8> → String (UTF-8 검증)

// 안전하지 않은 변환 (UTF-8 검증 생략)
let bytes = vec![72, 101, 108, 108, 111];
let s3 = unsafe { String::from_utf8_unchecked(bytes) };  // "Hello"
// 주의: 잘못된 UTF-8 바이트를 넣으면 정의되지 않은 동작(UB)!

빌림(Borrowing)과 참조

소유권을 이전하지 않고 데이터에 접근하는 방법이 빌림(Borrowing)입니다. 참조(&)를 통해 소유권 없이 데이터를 읽거나 수정할 수 있습니다.

// 공유 참조 (immutable borrow)
fn calculate_length(s: &String) -> usize {
    s.len()  // 읽기만 가능, 수정 불가
}
let s = String::from("hello");
let len = calculate_length(&s);  // 참조 전달 — 소유권 유지
println!("'{}' length = {}", s, len); // s 여전히 유효

// 가변 참조 (mutable borrow)
fn append_world(s: &mut String) {
    s.push_str(", world");
}
let mut s = String::from("hello");
append_world(&mut s);  // 가변 참조 전달
println!("{}", s);      // "hello, world"

// 빌림 규칙 위반 예시
let mut data = vec![1, 2, 3];
let r1 = &data;       // 공유 참조 1
let r2 = &data;       // 공유 참조 2 — OK
println!("{:?} {:?}", r1, r2);  // 여기서 r1, r2 마지막 사용

let w = &mut data;    // 가변 참조 — NLL 덕분에 OK (r1, r2 이미 사용 끝)
w.push(4);

// 댕글링 참조 방지
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // ← 컴파일 에러! s가 함수 끝에서 해제되므로 댕글링 참조
// }

// NLL 이전에는 불가능했던 패턴 — 이제 가능
let mut map = HashMap::new();
map.insert("key", 1);

match map.get("key") {       // &map 빌림 시작
    Some(val) => println!("found: {}", val),  // &map 빌림 끝 (NLL)
    None => {
        map.insert("key", 2);  // &mut map — NLL 덕분에 OK
    }
}

// 빌림 vs 소유권 이전 — 언제 무엇을 쓰나?
// 읽기만 필요:      fn foo(data: &Vec<i32>)       — 공유 참조
// 수정 필요:        fn foo(data: &mut Vec<i32>)   — 가변 참조
// 소유권 넘기기:    fn foo(data: Vec<i32>)         — 소유권 이전 (move)
// 복제:            fn foo(data: Vec<i32>)         — clone() 후 전달

// 슬라이스 빌림 — 컬렉션의 일부를 안전하게 참조
let v = vec![1, 2, 3, 4, 5];
let slice: &[i32] = &v[1..4];  // [2, 3, 4] — 복사 없이 참조

// 커널에서의 빌림: ArcBorrow — Arc 복제 없이 참조
// fn open(shared: &Arc<DeviceState>, file: &File) → Arc를 빌려서 사용
// fn read(shared: &Arc<DeviceState>, ...) → 참조 카운트 증가 없이 접근

재빌림(Reborrowing)

가변 참조(&mut T)는 동시에 하나만 존재할 수 있다는 규칙이 있지만, 재빌림(reborrowing) 덕분에 &mut T를 받는 함수에 기존 가변 참조를 전달할 수 있습니다. 컴파일러가 암묵적으로 원본 참조를 일시 정지하고 새로운 빌림을 생성하기 때문입니다.

// ── 재빌림(Reborrowing) 기본 ──
fn add_one(val: &mut i32) {
    *val += 1;
}

let mut x = 10;
let r = &mut x;

// 재빌림: r을 "일시적으로" 다시 빌려서 add_one에 전달
add_one(r);       // 컴파일러가 암묵적으로 &mut *r 수행
add_one(r);       // 또 다시 재빌림 — OK!
println!("{}", r); // 12 — r은 여전히 유효

// 명시적으로 쓰면 이렇습니다:
add_one(&mut *r);  // 이것이 컴파일러가 내부적으로 하는 것

// ── 왜 이동이 아닌 재빌림인가? ──
fn process(data: &mut Vec<i32>) {
    data.push(42);
}

let mut v = vec![1, 2, 3];
let r = &mut v;

// 만약 재빌림이 없다면, r의 소유권이 process로 이동하여
// 아래 두 번째 호출은 불가능했을 것입니다.
process(r);   // r → 재빌림 → process 완료 → r 다시 활성
process(r);   // OK — r은 소비되지 않았음
r.push(100);  // r 여전히 사용 가능

// 주의: &mut를 소유권처럼 이동시키면 재빌림 불가
fn take_ref(data: &mut Vec<i32>) -> &mut Vec<i32> {
    data  // 반환 시 수명이 함수 시그니처에 묶임
}

// 재빌림은 공유 참조(&T)에서도 동작합니다.
// &T는 Copy이므로 항상 재빌림 없이도 복사 가능하지만,
// &mut T는 Copy가 아니므로 재빌림이 필수적입니다.

빌림 검사기 에러 패턴과 해결책

Rust의 빌림 검사기(borrow checker)는 메모리 안전성을 보장하지만, 처음 접하면 에러 메시지가 난해할 수 있습니다. 아래는 가장 흔한 에러 패턴과 그 해결 방법입니다.

// ── 에러 1: 공유 + 가변 참조 충돌 ──

// 문제 코드
let mut v = vec![1, 2, 3];
let first = &v[0];     // 공유 참조 생성
v.push(4);              // 에러! v를 가변으로 빌리려 하지만 first가 아직 살아있음
// println!("{}", first); // first가 여기서 사용되므로 push 시점에 공존

// 해결: 공유 참조 사용을 먼저 완료
let mut v = vec![1, 2, 3];
let first = v[0];       // i32는 Copy — 값 복사, 빌림 아님
v.push(4);              // OK!
println!("{}", first);  // 1 — 복사된 값

// 또는 스코프 분리
let mut v = vec![1, 2, 3];
{
    let first = &v[0];
    println!("{}", first);  // 여기서 first 사용 완료
}  // first의 빌림이 끝남
v.push(4);  // OK — 더 이상 공유 참조 없음

// ── 에러 2: 빌린 데이터에서 이동 시도 ──

struct Container {
    data: String,
}

// 문제 코드
fn extract(c: &Container) -> String {
    c.data  // 에러! cannot move out of `c.data` which is behind a shared reference
}

// 해결 1: clone
fn extract_v1(c: &Container) -> String {
    c.data.clone()  // 복제하여 새 String 반환
}

// 해결 2: 참조 반환
fn extract_v2(c: &Container) -> &str {
    &c.data  // 빌림으로 반환 — 복사 비용 없음
}

// 해결 3: 소유권을 받아서 이동 (함수가 소유권 소비)
fn extract_v3(c: Container) -> String {
    c.data  // OK — c의 소유권을 받았으므로 필드 이동 가능
}

// ── 에러 3: 지역 변수 참조 반환 ──

// 문제 코드
fn make_greeting() -> &str {
    let s = String::from("hello");
    &s  // 에러! s는 함수 끝에서 해제되므로 참조가 댕글링 포인터가 됨
}

// 해결: 소유 타입 반환
fn make_greeting_v1() -> String {
    String::from("hello")  // 소유권을 호출자에게 이전
}

// 또는 정적 문자열 반환 (리터럴의 수명은 'static)
fn make_greeting_v2() -> &'static str {
    "hello"  // 문자열 리터럴은 프로그램 전체 수명
}

// ── 에러 4: 임시값 참조 ──

// 문제 코드
let r: &str = &String::from("temp");
// 에러! 임시 String이 이 줄 끝에서 해제되지만 r이 참조 중

// 해결: 임시값을 변수에 바인딩
let owned = String::from("temp");
let r: &str = &owned;  // OK — owned가 r보다 오래 살아남

// 커널에서 흔한 패턴: Guard를 변수에 바인딩
// let guard = mutex.lock();  // guard를 변수에 저장해야 락이 유지됨
// let _ = mutex.lock();      // 즉시 해제! 보호가 되지 않음

수명(Lifetime)

수명(Lifetime)은 참조가 유효한 범위를 나타내는 컴파일 타임 표기입니다. 대부분의 경우 컴파일러가 자동으로 추론(elision)하지만, 여러 참조 간의 관계가 모호할 때 명시적으로 지정해야 합니다.

// 수명 매개변수 — 두 참조 중 짧은 수명을 반환 타입에 적용
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
// 'a는 x와 y의 수명 중 짧은 쪽으로 결정됨

// 수명 생략 규칙 (Lifetime Elision Rules)
// 규칙 1: 각 참조 매개변수에 고유 수명 부여
// 규칙 2: 입력 수명이 하나면 출력에 동일 수명 적용
// 규칙 3: &self/&mut self가 있으면 self의 수명 적용

// 생략 전
fn first_word<'a>(s: &'a str) -> &'a str { /* ... */ }
// 생략 후 (규칙 1+2 적용 → 동일한 의미)
fn first_word(s: &str) -> &str { /* ... */ }

// 구조체에서의 수명 — 구조체가 참조를 보유할 때 필수
struct Important<'a> {
    part: &'a str,  // 이 구조체는 참조의 수명보다 오래 살 수 없음
}

impl<'a> Important<'a> {
    fn level(&self) -> i32 {
        3  // 규칙 3: &self의 수명이 반환 참조에 적용
    }
}

// 'static 수명 — 프로그램 전체 기간 유효
let s: &'static str = "I live forever"; // 문자열 리터럴

수명 생략 규칙 (Lifetime Elision Rules)

Rust 컴파일러는 다음 3가지 규칙을 순서대로 적용하여 수명을 자동 추론합니다. 규칙 적용 후에도 모호하면 명시적 수명이 필요합니다.

// === 복잡한 수명 시나리오 ===

// 여러 수명 매개변수 — 입력이 2개 이상이면 규칙2 적용 불가 → 명시 필요
fn select<'a, 'b>(first: &'a str, second: &'b str, use_first: bool) -> &'a str {
    if use_first { first } else {
        // second를 반환하려면 'b: 'a (second가 first보다 오래 살아야 함)
        // 여기서는 first만 반환 → 'a만 출력에 사용
        first
    }
}

// 수명 바운드 — 'b는 최소 'a만큼 살아야 함
fn longest_with_bound<'a, 'b: 'a>(x: &'a str, y: &'b str) -> &'a str {
    if x.len() > y.len() { x } else { y }  // 'b: 'a이므로 y를 'a로 반환 가능
}

// 트레이트 객체의 수명
trait Processor {
    fn process(&self, data: &[u8]) -> Result<(), Error>;
}
// Box<dyn Processor + 'a> → 트레이트 객체도 수명을 가짐
// Box<dyn Processor>는 Box<dyn Processor + 'static>과 동일
fn create_processor<'a>(config: &'a Config) -> Box<dyn Processor + 'a> {
    // 반환된 트레이트 객체는 config의 수명 내에서만 유효
    Box::new(ConfigProcessor { config })
}

// 'static 수명의 세 가지 의미
// 1. 문자열 리터럴: 바이너리에 포함 → 프로그램 전체 수명
let s: &'static str = "hello";
// 2. 소유된 타입: String, Vec 등은 T: 'static을 만족 (참조를 포함하지 않으므로)
fn spawn_thread<F: FnOnce() + Send + 'static>(f: F) { /* ... */ }
// 3. const 프로모션: 컴파일 타임 상수는 암묵적 'static

구조체(Struct)와 열거형(Enum)

구조체와 열거형은 Rust의 기본 데이터 정의 도구입니다. 구조체는 관련 데이터를 묶고, 열거형은 가능한 변형(variant)을 나열합니다.

// 일반 구조체
struct Process {
    pid: u32,
    name: String,
    state: ProcessState,
    priority: i8,
}

// 튜플 구조체 — 필드명 없이 순서로 접근
struct Color(u8, u8, u8);
struct Pid(u32);  // 뉴타입 패턴 — 타입 안전성 강화

// 유닛 구조체 — 필드 없음 (트레이트 구현용)
struct AlwaysEqual;

// 열거형(Enum) — 각 변형이 다른 데이터를 가질 수 있음
enum ProcessState {
    Running,                         // 데이터 없음
    Sleeping { duration_ms: u64 },   // 명명된 필드
    Stopped(i32),                    // 튜플 변형
    Zombie,
}

// impl 블록 — 메서드와 연관 함수 정의
impl Process {
    // 연관 함수 (생성자 패턴) — Self::new()
    fn new(pid: u32, name: String) -> Self {
        Process {
            pid,
            name,
            state: ProcessState::Running,
            priority: 0,
        }
    }

    // 메서드 — &self로 불변 접근
    fn is_running(&self) -> bool {
        matches!(self.state, ProcessState::Running)
    }

    // 가변 메서드 — &mut self
    fn set_priority(&mut self, prio: i8) {
        self.priority = prio;
    }
}

// 사용
let mut proc = Process::new(1, String::from("init"));
proc.set_priority(-20);

// Option<T> — Rust의 null 대체
let some_val: Option<i32> = Some(42);
let no_val: Option<i32> = None;
// unwrap, expect, match, if let, map 등으로 안전하게 접근

// Option 메서드 체이닝
let result = some_val
    .map(|x| x * 2)         // Some(84)
    .filter(|&x| x > 50)     // Some(84)
    .unwrap_or(0);            // 84

// Result<T, E> vs Option<T>
// Option: 값이 있거나(Some) 없음(None)
// Result: 성공(Ok) 또는 에러 정보 포함(Err)

자주 사용하는 derive 매크로

// 열거형 크기 최적화 예시
use std::mem;

// 각 변형의 크기가 다르면, 가장 큰 변형 + 판별자 크기
enum Message {
    Quit,                          // 0 바이트
    Move { x: i32, y: i32 },       // 8 바이트
    Write(String),                 // 24 바이트 (가장 큼)
    Color(u8, u8, u8),            // 3 바이트
}
// Message 크기 = max(0, 8, 24, 3) + 판별자(8) = 32 바이트
// → 큰 변형은 Box로 감싸면 전체 enum 크기 감소

enum OptimizedMessage {
    Quit,
    Move { x: i32, y: i32 },
    Write(Box<String>),        // 8 바이트 (포인터만)
    Color(u8, u8, u8),
}
// OptimizedMessage = max(0, 8, 8, 3) + 판별자 = 16 바이트!

구조체 갱신 문법 (Struct Update Syntax)

Rust에서는 .. 구문(struct update syntax)을 사용하여 기존 구조체의 나머지 필드를 복사할 수 있습니다. 이 문법은 일부 필드만 변경하고 나머지는 그대로 유지할 때 매우 유용합니다.

#[derive(Debug, Clone)]
struct Config {
    width: u32,
    height: u32,
    title: String,
    fullscreen: bool,
    vsync: bool,
    fps_limit: u32,
}

impl Config {
    fn default() -> Self {
        Config {
            width: 1920,
            height: 1080,
            title: String::from("My App"),
            fullscreen: false,
            vsync: true,
            fps_limit: 60,
        }
    }
}

fn main() {
    let default_config = Config::default();

    // 일부 필드만 변경하고 나머지는 default_config에서 복사
    let custom = Config {
        width: 2560,
        height: 1440,
        fullscreen: true,
        ..default_config.clone() // 나머지 필드 복사
    };

    // ⚠️ 주의: String 필드가 있으면 move가 발생!
    let base = Config::default();
    let moved = Config {
        width: 3840,
        ..base // base.title이 move됨 → base 더 이상 사용 불가
    };
    // println!("{:?}", base); // ❌ 컴파일 에러: base가 부분적으로 move됨
    // 하지만 Copy 타입 필드는 개별 접근 가능:
    // println!("{}", base.width); // ✅ u32는 Copy이므로 OK
}

빌더 패턴(Builder Pattern)은 복잡한 구조체를 단계별로 구성할 때 사용하는 Rust의 관용적 설계 패턴입니다. 선택적 필드가 많거나 유효성 검증이 필요할 때 특히 유용합니다.

struct Request {
    url: String,
    method: String,
    headers: Vec<(String, String)>,
    body: Option<Vec<u8>>,
    timeout_ms: u64,
}

struct RequestBuilder {
    url: String,
    method: String,
    headers: Vec<(String, String)>,
    body: Option<Vec<u8>>,
    timeout_ms: u64,
}

impl RequestBuilder {
    // 필수 필드만 받는 생성자
    fn new(url: &str) -> Self {
        RequestBuilder {
            url: url.to_string(),
            method: String::from("GET"),
            headers: Vec::new(),
            body: None,
            timeout_ms: 5000,
        }
    }

    // 각 설정 메서드는 self를 소비하고 반환 → 체이닝 가능
    fn method(mut self, method: &str) -> Self {
        self.method = method.to_string();
        self
    }

    fn header(mut self, key: &str, value: &str) -> Self {
        self.headers.push((key.to_string(), value.to_string()));
        self
    }

    fn body(mut self, data: Vec<u8>) -> Self {
        self.body = Some(data);
        self
    }

    fn timeout(mut self, ms: u64) -> Self {
        self.timeout_ms = ms;
        self
    }

    // 최종 빌드 - 유효성 검증 후 실제 타입 반환
    fn build(self) -> Result<Request, String> {
        if self.url.is_empty() {
            return Err("URL은 비어있을 수 없습니다".to_string());
        }
        Ok(Request {
            url: self.url,
            method: self.method,
            headers: self.headers,
            body: self.body,
            timeout_ms: self.timeout_ms,
        })
    }
}

// 사용 예시 - 메서드 체이닝으로 가독성 있게 구성
let request = RequestBuilder::new("https://api.example.com/data")
    .method("POST")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token123")
    .body(b"{\"key\": \"value\"}".to_vec())
    .timeout(10000)
    .build()
    .expect("유효한 요청");

Display와 Debug 트레이트 구현

Rust에서 타입을 출력하려면 fmt::Display(사용자 친화적 출력)와 fmt::Debug(개발자 디버깅용 출력) 트레이트를 구현해야 합니다. 두 트레이트의 용도와 구현 방식을 비교합니다.

use std::fmt;

struct IpAddr {
    octets: [u8; 4],
}

// Display: 사용자에게 보여줄 형태 (println!("{}", x))
impl fmt::Display for IpAddr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // 점으로 구분된 사람이 읽기 쉬운 형태
        write!(f, "{}.{}.{}.{}",
            self.octets[0], self.octets[1],
            self.octets[2], self.octets[3])
    }
}

// Debug: 디버깅용 상세 형태 (println!("{:?}", x))
impl fmt::Debug for IpAddr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // 구조체 이름과 필드를 포함한 상세 형태
        f.debug_struct("IpAddr")
            .field("octets", &self.octets)
            .finish()
    }
}

fn main() {
    let addr = IpAddr { octets: [192, 168, 1, 100] };

    // Display: 사용자 친화적
    println!("서버 주소: {}", addr);
    // 출력: 서버 주소: 192.168.1.100

    // Debug: 개발자용
    println!("디버그: {:?}", addr);
    // 출력: 디버그: IpAddr { octets: [192, 168, 1, 100] }

    // Pretty Debug: 들여쓰기된 디버그 출력
    println!("상세:\n{:#?}", addr);
    // 출력:
    // 상세:
    // IpAddr {
    //     octets: [
    //         192,
    //         168,
    //         1,
    //         100,
    //     ],
    // }
}

#[derive(Debug)]를 사용하면 자동으로 Debug 구현을 생성할 수 있지만, Display는 항상 수동 구현이 필요합니다.

// #[derive(Debug)]로 자동 구현 vs 수동 구현 비교

#[derive(Debug)] // 자동 생성: 필드를 그대로 출력
struct AutoDebug {
    name: String,
    values: Vec<i32>,
    active: bool,
}
// {:?} → AutoDebug { name: "test", values: [1, 2, 3], active: true }

// 수동 구현: 민감 정보 숨기기, 커스텀 포맷
struct User {
    name: String,
    email: String,
    password_hash: String,  // 보안상 숨겨야 함
}

impl fmt::Debug for User {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("User")
            .field("name", &self.name)
            .field("email", &self.email)
            .field("password_hash", &"[REDACTED]") // 비밀번호 숨김
            .finish()
    }
}

impl fmt::Display for User {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} <{}>", self.name, self.email)
    }
}

열거형 메서드와 impl

구조체처럼 열거형에도 impl 블록을 사용하여 메서드와 연관 함수를 정의할 수 있습니다. 이를 통해 각 변형(variant)에 대한 유틸리티 메서드를 제공하고, 타입 변환을 구현할 수 있습니다.

#[derive(Debug, Clone, PartialEq)]
enum HttpStatus {
    Ok,                          // 200
    NotFound,                    // 404
    InternalError(String),       // 500 + 메시지
    Redirect { url: String, permanent: bool },
}

impl HttpStatus {
    // 상태 코드 반환
    fn code(&self) -> u16 {
        match self {
            HttpStatus::Ok => 200,
            HttpStatus::NotFound => 404,
            HttpStatus::InternalError(_) => 500,
            HttpStatus::Redirect { permanent: true, .. } => 301,
            HttpStatus::Redirect { permanent: false, .. } => 302,
        }
    }

    // is_* 헬퍼 메서드 패턴 — 변형 판별에 자주 사용
    fn is_success(&self) -> bool {
        matches!(self, HttpStatus::Ok)
    }

    fn is_error(&self) -> bool {
        matches!(self, HttpStatus::NotFound | HttpStatus::InternalError(_))
    }

    fn is_redirect(&self) -> bool {
        matches!(self, HttpStatus::Redirect { .. })
    }

    // 에러 메시지 추출 (해당 변형일 때만 Some 반환)
    fn error_message(&self) -> Option<&str> {
        match self {
            HttpStatus::InternalError(msg) => Some(msg),
            _ => None,
        }
    }

    // 연관 함수: 상태 코드 숫자에서 생성
    fn from_code(code: u16) -> Option<Self> {
        match code {
            200 => Some(HttpStatus::Ok),
            404 => Some(HttpStatus::NotFound),
            500 => Some(HttpStatus::InternalError(String::from("Internal Server Error"))),
            _ => None,
        }
    }
}

// From/Into 트레이트로 타입 변환 구현
impl From<u16> for HttpStatus {
    fn from(code: u16) -> Self {
        match code {
            200 => HttpStatus::Ok,
            404 => HttpStatus::NotFound,
            301 => HttpStatus::Redirect {
                url: String::new(),
                permanent: true,
            },
            _ => HttpStatus::InternalError(
                format!("알 수 없는 상태 코드: {}", code)
            ),
        }
    }
}

// Display 구현으로 사용자 친화적 출력
impl std::fmt::Display for HttpStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HttpStatus::Ok => write!(f, "200 OK"),
            HttpStatus::NotFound => write!(f, "404 Not Found"),
            HttpStatus::InternalError(msg) => write!(f, "500 {}", msg),
            HttpStatus::Redirect { url, permanent } => {
                let code = if *permanent { 301 } else { 302 };
                write!(f, "{} Redirect → {}", code, url)
            }
        }
    }
}

fn main() {
    let status = HttpStatus::InternalError("DB 연결 실패".to_string());

    // is_* 헬퍼로 간결한 조건 분기
    if status.is_error() {
        println!("에러 발생: {} (코드: {})", status, status.code());
        if let Some(msg) = status.error_message() {
            println!("상세: {}", msg);
        }
    }

    // From 트레이트를 통한 변환
    let from_code: HttpStatus = 404.into(); // Into는 From 구현 시 자동 제공
    assert!(from_code.is_error());
}

패턴 매칭 (match, if let, while let)

Rust의 패턴 매칭은 완전성(exhaustiveness)을 보장합니다. match에서 모든 가능한 경우를 처리하지 않으면 컴파일 에러가 발생합니다. C의 switch문과 달리 fall-through가 없고, 구조 분해(destructuring)를 통해 복합 데이터를 우아하게 분석할 수 있습니다.

// match — 완전한 패턴 매칭
fn describe_state(state: &ProcessState) -> &str {
    match state {
        ProcessState::Running => "실행 중",
        ProcessState::Sleeping { duration_ms } => {
            if *duration_ms > 10000 { "깊은 수면" } else { "수면 중" }
        }
        ProcessState::Stopped(code) => "정지됨",
        ProcessState::Zombie => "좀비",
    }
}

// 매치 가드 (match guard)
let num = 4;
match num {
    n if n < 0 => println!("음수"),
    0 => println!("영"),
    n if n % 2 == 0 => println!("양의 짝수: {}", n),
    _ => println!("양의 홀수"),
}

// if let — 하나의 패턴만 관심 있을 때
let config_max: Option<u8> = Some(3);
if let Some(max) = config_max {
    println!("max = {}", max);
}

// let-else (Rust 1.65+) — 매칭 실패 시 조기 반환
fn process_value(opt: Option<i32>) -> i32 {
    let Some(val) = opt else {
        return -1;  // None인 경우 조기 반환
    };
    val * 2
}

// 구조 분해 패턴
let point = (3, 5);
match point {
    (0, 0) => println!("원점"),
    (x, 0) => println!("x축 위: {}", x),
    (0, y) => println!("y축 위: {}", y),
    (x, y) => println!("({}, {})", x, y),
}

// @ 바인딩 — 패턴 매칭하면서 값을 변수에 바인딩
match num {
    n @ 1..=12 => println!("1~12 범위: {}", n),
    n @ 13..=19 => println!("13~19 범위: {}", n),
    _ => println!("범위 밖"),
}

// while let — 패턴이 매칭하는 동안 반복
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("꺼냄: {}", top);  // 3, 2, 1 순서로 출력
}

// 중첩 구조체 분해
struct Rect { origin: (i32, i32), size: (u32, u32) }

let rect = Rect { origin: (10, 20), size: (100, 50) };
let Rect { origin: (x, y), size: (w, h) } = rect;
println!("x={}, y={}, w={}, h={}", x, y, w, h);

// 슬라이스 패턴 (Rust 1.26+)
let nums = [1, 2, 3, 4, 5];
match &nums[..] {
    [] => println!("비어 있음"),
    [single] => println!("하나: {}", single),
    [first, .., last] => println!("첫={}, 끝={}", first, last),
}

// matches! 매크로 — 패턴 매칭 결과를 bool로
let is_letter = matches!('a', 'a'..='z' | 'A'..='Z');  // true

// 커널 코드에서의 패턴 매칭 활용
fn handle_ioctl(cmd: u32, arg: usize) -> Result {
    match cmd {
        IOCTL_GET_INFO => get_device_info(arg),
        IOCTL_SET_CONFIG => set_device_config(arg),
        IOCTL_RESET => reset_device(),
        _ => Err(ENOTTY),  // 지원하지 않는 명령
    }
}

고급 패턴 문법 총정리

Rust의 패턴 문법은 단순한 값 비교를 넘어, 복잡한 중첩 구조를 분해하고, 참조를 다루며, 범위를 지정하는 등 매우 강력한 표현력을 제공합니다. 여기서는 실전에서 자주 사용하는 고급 패턴 문법을 총정리합니다.

// ═══════════════════════════════════════════════════════════════
// 1. 중첩 구조 분해 (Nested Destructuring)
// ═══════════════════════════════════════════════════════════════

struct Point { x: f64, y: f64 }
struct Circle { center: Point, radius: f64 }

enum Shape {
    Rect { top_left: Point, bottom_right: Point },
    Circ(Circle),
}

let shape = Shape::Rect {
    top_left: Point { x: 0.0, y: 10.0 },
    bottom_right: Point { x: 20.0, y: 0.0 },
};

match shape {
    // 중첩된 구조체를 한 번에 분해
    Shape::Rect {
        top_left: Point { x: x1, y: y1 },
        bottom_right: Point { x: x2, y: y2 },
    } => {
        let area = (x2 - x1) * (y1 - y2);
        println!("직사각형 면적: {}", area);
    }
    Shape::Circ(Circle { center: Point { x, y }, radius }) => {
        println!("원: 중심({}, {}), 반지름 {}", x, y, radius);
    }
}

// ═══════════════════════════════════════════════════════════════
// 2. ref와 ref mut — 패턴에서 참조 바인딩
// ═══════════════════════════════════════════════════════════════

let data = Some(String::from("hello"));

// ref를 사용하여 소유권을 가져가지 않고 참조만 바인딩
match &data {
    Some(s) => println!("길이: {}", s.len()), // s: &String (자동 참조)
    None => {}
}
// data는 여전히 사용 가능 (move되지 않음)

let mut value = Some(42);
match &mut value {
    Some(v) => *v += 1,  // v: &mut i32
    None => {}
}
assert_eq!(value, Some(43));

// 레거시 문법 (Rust 2015): ref 키워드 사용
match data {
    Some(ref s) => println!("{}", s), // ref로 명시적 참조 바인딩
    None => {}
}

// ═══════════════════════════════════════════════════════════════
// 3. 다중 참조 레이어 해소
// ═══════════════════════════════════════════════════════════════

let x = 5;
let r1 = &x;
let r2 = &r1;
let r3 = &r2;

// match ergonomics: 자동으로 참조를 벗겨냄
match r3 {
    5 => println!("5입니다"),  // &&&i32와 i32를 자동 비교
    _ => {}
}

// ═══════════════════════════════════════════════════════════════
// 4. 범위 패턴 (Range Patterns)
// ═══════════════════════════════════════════════════════════════

let code: u16 = 404;
let category = match code {
    100..=199 => "정보",        // 100 이상 199 이하 (inclusive)
    200..=299 => "성공",        // ..= 는 양 끝 포함
    300..=399 => "리다이렉트",
    400..=499 => "클라이언트 에러",
    500..=599 => "서버 에러",
    _ => "알 수 없음",
};

// 문자 범위도 가능
let ch = '가';
match ch {
    'a'..='z' => println!("소문자 영문"),
    'A'..='Z' => println!("대문자 영문"),
    '가'..='힣' => println!("한글"),
    _ => println!("기타 문자"),
}

바인딩 모드(Binding Modes)와 match ergonomics는 Rust 2018부터 도입된 기능으로, 패턴에서 참조를 더 편리하게 다룰 수 있게 합니다.

// ═══════════════════════════════════════════════════════════════
// 5. Match Ergonomics (Rust 2018+)
// ═══════════════════════════════════════════════════════════════

// Rust 2015 스타일: 명시적 참조 해제 필요
let values = vec![1, 2, 3];
for val in &values {
    // val: &i32
    match *val {  // 명시적 역참조 필요했음
        1 => println!("하나"),
        _ => {}
    }
}

// Rust 2018 스타일: 자동으로 바인딩 모드 결정
for val in &values {
    match val {  // 역참조 불필요!
        1 => println!("하나"),  // 컴파일러가 자동으로 &1과 비교
        _ => {}
    }
}

// Option<&T>에서의 ergonomics
let names: Vec<String> = vec!["Alice".into(), "Bob".into()];
if let Some(first) = names.first() {
    // first: &String (자동으로 참조 바인딩)
    println!("첫 번째: {}", first);
}

// ═══════════════════════════════════════════════════════════════
// 6. let-else 패턴 (Rust 1.65+)
// ═══════════════════════════════════════════════════════════════

use std::collections::HashMap;

fn process_config(config: &HashMap<String, String>) -> Result<u16, String> {
    // let-else: 패턴 매칭 실패 시 반드시 분기(return, break, continue, panic)
    let Some(port_str) = config.get("port") else {
        return Err("port 설정이 없습니다".to_string());
    };

    let Ok(port) = port_str.parse::<u16>() else {
        return Err(format!("유효하지 않은 포트: {}", port_str));
    };

    // port_str과 port는 이후 코드에서 바로 사용 가능
    println!("포트: {} (원본: {})", port, port_str);
    Ok(port)
}

// let-else vs if-let 비교
fn example(input: Option<&str>) {
    // ❌ if-let: 깊은 들여쓰기 (pyramid of doom)
    if let Some(s) = input {
        if let Ok(n) = s.parse::<i32>() {
            if n > 0 {
                println!("양수: {}", n);
            }
        }
    }

    // ✅ let-else: 일직선 흐름 (early return)
    let Some(s) = input else { return };
    let Ok(n) = s.parse::<i32>() else { return };
    if n <= 0 { return; }
    println!("양수: {}", n);
}

패턴이 사용되는 모든 위치

Rust에서 패턴은 match뿐만 아니라 다양한 위치에서 사용됩니다. 각 위치마다 반박 가능(refutable) 패턴과 반박 불가능(irrefutable) 패턴의 허용 여부가 다릅니다.

// ═══════════════════════════════════════════════════════════════
// 패턴이 사용되는 6가지 위치
// ═══════════════════════════════════════════════════════════════

// 1. let 문 — 반박 불가능(irrefutable) 패턴만
let (a, b, c) = (1, 2, 3);           // ✅ 튜플 분해
let Point { x, y } = point;            // ✅ 구조체 분해
let [first, .., last] = [1,2,3,4,5];  // ✅ 슬라이스 분해
// let Some(x) = option;              // ❌ 컴파일 에러: refutable 패턴

// 2. 함수 매개변수 — 반박 불가능 패턴만
fn print_point(&(x, y): &(i32, i32)) {
    println!("({}, {})", x, y);
}
fn first_element([first, ..]: [i32; 3]) -> i32 { first }

// 3. for 루프 — 반박 불가능 패턴만
let pairs = vec![("key1", 1), ("key2", 2)];
for (key, value) in &pairs {
    println!("{}: {}", key, value);
}
for (idx, (key, val)) in pairs.iter().enumerate() {
    println!("[{}] {}: {}", idx, key, val);
}

// 4. while let — 반박 가능(refutable) 패턴 허용
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("꺼낸 값: {}", top);
}

// 5. if let — 반박 가능 패턴 허용
let config_value: Option<i32> = Some(42);
if let Some(val) = config_value {
    println!("설정값: {}", val);
}

// 6. match — 반박 가능 패턴 허용 (모든 경우 포함 필수)
match config_value {
    Some(v) if v > 0 => println!("양수: {}", v),
    Some(v) => println!("음수 또는 0: {}", v),
    None => println!("값 없음"),
}

에러 처리 기초 (Result, Option, ? 연산자)

Rust는 예외(exception) 대신 Result<T, E>와 Option<T> 열거형으로 에러를 처리합니다. ? 연산자는 에러 전파를 간결하게 만듭니다.

// Result<T, E> — 성공(Ok) 또는 실패(Err)
use std::fs;
use std::io;

fn read_username(path: &str) -> Result<String, io::Error> {
    let mut file = fs::File::open(path)?;  // ? = Err이면 즉시 반환
    let mut name = String::new();
    file.read_to_string(&mut name)?;         // ?로 에러 전파
    Ok(name.trim().to_string())
}

// 더 간결한 방법
fn read_username_short(path: &str) -> Result<String, io::Error> {
    fs::read_to_string(path)  // 한 줄로!
}

// Option<T> — 값이 있거나(Some) 없음(None)
fn find_process(pid: u32) -> Option<Process> {
    if pid == 0 { None } else { Some(Process::new(pid, "found".into())) }
}

// Option 체이닝
let name = find_process(1)
    .map(|p| p.name.to_uppercase())
    .unwrap_or_else(|| "UNKNOWN".to_string());

// match로 Result/Option 처리
match read_username("/etc/hostname") {
    Ok(name) => println!("호스트: {}", name),
    Err(e) => eprintln!("에러: {}", e),
}

// unwrap/expect — 실패 시 panic (프로토타입/테스트 전용)
let val = Some(42).unwrap();          // 42, None이면 panic
let val = Some(42).expect("있어야 함"); // 42, None이면 메시지와 함께 panic

// 커스텀 에러 타입
#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Parse(std::num::ParseIntError),
    Custom(String),
}

impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self { AppError::Io(e) }
}
// From 구현으로 ? 연산자가 자동 변환

Option / Result 주요 메서드 비교

panic!과 백트레이스

panic!은 복구 불가능한 에러 상황에서 프로그램을 즉시 종료하는 메커니즘입니다. Result와의 사용 구분, 백트레이스 활용, panic 전략(unwinding vs abort)을 이해하는 것이 중요합니다.

// ═══════════════════════════════════════════════════════════════
// 1. panic!의 기본 사용과 발생 상황
// ═══════════════════════════════════════════════════════════════

// 명시적 panic
panic!("치명적 에러 발생");
panic!("인덱스 {} 가 범위 {} 를 초과", idx, len);

// 암시적 panic이 발생하는 경우
let v = vec![1, 2, 3];
let _ = v[99];          // 인덱스 범위 초과 → panic
let _ = 0_i32 / 0;     // 0으로 나누기 → panic (디버그 모드)
let x: Option<i32> = None;
x.unwrap();              // None에 unwrap → panic

// ═══════════════════════════════════════════════════════════════
// 2. RUST_BACKTRACE로 백트레이스 확인
// ═══════════════════════════════════════════════════════════════

// 터미널에서 실행:
// $ RUST_BACKTRACE=1 cargo run     → 간략한 백트레이스
// $ RUST_BACKTRACE=full cargo run  → 전체 백트레이스 (라이브러리 프레임 포함)

// 출력 예시:
// thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99'
// stack backtrace:
//    0: std::panicking::begin_panic
//    1: my_app::process_data         ← 에러 발생 위치
//            at src/main.rs:42:5
//    2: my_app::main
//            at src/main.rs:10:3

// ═══════════════════════════════════════════════════════════════
// 3. panic hook 커스터마이징
// ═══════════════════════════════════════════════════════════════

use std::panic;

// 커스텀 panic handler 설치
panic::set_hook(Box::new(|info| {
    // 에러 로깅, 알림 전송 등
    if let Some(msg) = info.payload().downcast_ref::<&str>() {
        eprintln!("[FATAL] Panic: {}", msg);
    }
    if let Some(loc) = info.location() {
        eprintln!("  위치: {}:{}", loc.file(), loc.line());
    }
}));

// panic 캐치 (테스트/서버 등에서 사용)
let result = panic::catch_unwind(|| {
    panic!("테스트 panic");
});
match result {
    Ok(_) => println!("정상 완료"),
    Err(_) => println!("panic이 발생했지만 복구됨"),
}

커스텀 에러 타입 설계 패턴

실전 프로젝트에서는 String이나 Box<dyn Error> 대신 구조화된 커스텀 에러 타입을 정의하여, 에러 분류, 원인 추적, 사용자 친화적 메시지를 제공합니다.

use std::fmt;
use std::io;
use std::num::ParseIntError;

// ═══════════════════════════════════════════════════════════════
// 1. 커스텀 에러 타입 정의
// ═══════════════════════════════════════════════════════════════

#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Parse(ParseIntError),
    Config { key: String, message: String },
    NotFound(String),
    Auth(String),
}

// Display 구현: 사용자에게 보여줄 에러 메시지
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::Io(e) => write!(f, "I/O 에러: {}", e),
            AppError::Parse(e) => write!(f, "파싱 에러: {}", e),
            AppError::Config { key, message } =>
                write!(f, "설정 에러 [{}]: {}", key, message),
            AppError::NotFound(name) => write!(f, "'{}' 을(를) 찾을 수 없음", name),
            AppError::Auth(msg) => write!(f, "인증 실패: {}", msg),
        }
    }
}

// std::error::Error 구현: 에러 체인 지원
impl std::error::Error for AppError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            AppError::Io(e) => Some(e),     // 원인 에러 추적 가능
            AppError::Parse(e) => Some(e), // 원인 에러 추적 가능
            _ => None,                       // 원인 에러 없음
        }
    }
}

// ═══════════════════════════════════════════════════════════════
// 2. From 변환으로 ? 연산자 지원
// ═══════════════════════════════════════════════════════════════

impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self {
        AppError::Io(e)
    }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self {
        AppError::Parse(e)
    }
}

// From 구현 덕분에 ? 연산자가 자동으로 에러를 변환
fn read_config_port(path: &str) -> Result<u16, AppError> {
    let content = std::fs::read_to_string(path)?;  // io::Error → AppError::Io
    let port: u16 = content.trim().parse()?;       // ParseIntError → AppError::Parse
    Ok(port)
}

// ═══════════════════════════════════════════════════════════════
// 3. 에러 체인 출력
// ═══════════════════════════════════════════════════════════════

fn print_error_chain(err: &dyn std::error::Error) {
    eprintln!("에러: {}", err);
    let mut source = err.source();
    while let Some(cause) = source {
        eprintln!("  원인: {}", cause);
        source = cause.source();
    }
}
// 출력:
// 에러: I/O 에러: No such file or directory (os error 2)
//   원인: No such file or directory (os error 2)

thiserror와 anyhow는 에러 처리의 보일러플레이트를 줄여주는 대표적인 크레이트입니다. 라이브러리에는 thiserror를, 애플리케이션에는 anyhow를 사용하는 것이 일반적입니다.

// ═══════════════════════════════════════════════════════════════
// thiserror: 라이브러리용 — 구조화된 에러 타입 자동 생성
// ═══════════════════════════════════════════════════════════════

// Cargo.toml: thiserror = "1"
use thiserror::Error;

#[derive(Debug, Error)]
enum DbError {
    #[error("연결 실패: {0}")]           // Display 자동 생성
    Connection(String),

    #[error("쿼리 에러: {query}")]
    Query { query: String },

    #[error("I/O 에러")]
    Io(#[from] io::Error),             // From 자동 구현 + source()

    #[error(transparent)]              // Display와 source를 내부 에러에 위임
    Other(#[from] Box<dyn std::error::Error + Send + Sync>),
}

// ═══════════════════════════════════════════════════════════════
// anyhow: 애플리케이션용 — 빠른 프로토타이핑과 에러 컨텍스트
// ═══════════════════════════════════════════════════════════════

// Cargo.toml: anyhow = "1"
use anyhow::{Context, Result, bail};

fn load_user_config() -> Result<Config> {  // anyhow::Result
    let path = "~/.config/app.toml";
    let content = std::fs::read_to_string(path)
        .context("설정 파일을 읽을 수 없습니다")?;  // 컨텍스트 추가

    let config: Config = parse_toml(&content)
        .with_context(|| format!("{} 파싱 실패", path))?;

    if config.port == 0 {
        bail!("포트 번호가 0입니다");  // return Err(anyhow!(...))의 단축
    }

    Ok(config)
}

// ═══════════════════════════════════════════════════════════════
// Box<dyn Error>: 빠른 프로토타이핑용
// ═══════════════════════════════════════════════════════════════

type GenericResult<T> = Result<T, Box<dyn std::error::Error>>;

fn quick_prototype() -> GenericResult<()> {
    let file = std::fs::read_to_string("data.txt")?;  // io::Error 자동 변환
    let num: i32 = file.trim().parse()?;              // ParseIntError 자동 변환
    println!("값: {}", num);
    Ok(())
}

실전 에러 처리 전략

프로젝트 규모와 코드 위치(라이브러리 vs 애플리케이션)에 따라 적절한 에러 처리 전략이 다릅니다. unwrap을 언제 사용해도 되는지, Result 컴비네이터를 어떻게 체이닝하는지, 그리고 이터레이터에서 Result를 수집하는 방법을 다룹니다.

// ═══════════════════════════════════════════════════════════════
// 1. unwrap()을 사용해도 되는 경우
// ═══════════════════════════════════════════════════════════════

// ✅ 테스트 코드에서
#[test]
fn test_parse() {
    let result = "42".parse::<i32>().unwrap();
    assert_eq!(result, 42);
}

// ✅ 논리적으로 실패가 불가능한 경우
let home = std::env::var("HOME")
    .expect("HOME 환경변수가 설정되지 않음"); // Unix에서 거의 항상 존재

// ✅ 정적으로 유효성을 증명 가능한 경우
let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap(); // 정규식 리터럴

// ✅ 프로토타이핑 / 빠른 실험
fn main() {
    let data = std::fs::read_to_string("input.txt").unwrap(); // TODO: 나중에 수정
}

// ═══════════════════════════════════════════════════════════════
// 2. Result 컴비네이터 체이닝
// ═══════════════════════════════════════════════════════════════

fn get_user_age(db: &Database, id: u64) -> Result<String, AppError> {
    db.find_user(id)
        // map: Ok 값을 변환
        .map(|user| user.age)
        // and_then: Ok 값을 Result를 반환하는 함수에 전달
        .and_then(|age| {
            if age > 0 && age < 150 {
                Ok(format!("나이: {}세", age))
            } else {
                Err(AppError::Config {
                    key: "age".into(),
                    message: format!("유효하지 않은 나이: {}", age),
                })
            }
        })
        // map_err: Err 값을 변환
        .map_err(|e| {
            eprintln!("사용자 {} 조회 실패: {}", id, e);
            e
        })
}

// or_else: Err일 때 대체 시도
fn get_config_value(key: &str) -> Result<String, AppError> {
    read_from_env(key)
        .or_else(|_| read_from_file(key))       // 환경변수 실패 → 파일에서 시도
        .or_else(|_| read_from_defaults(key))   // 파일 실패 → 기본값에서 시도
}

// ═══════════════════════════════════════════════════════════════
// 3. Iterator에서 Result 수집
// ═══════════════════════════════════════════════════════════════

let strings = vec!["1", "2", "3", "4"];

// 방법 1: collect로 Vec<Result> → Result<Vec> 변환
// 하나라도 Err이면 전체가 Err (첫 번째 에러 반환)
let numbers: Result<Vec<i32>, _> = strings.iter()
    .map(|s| s.parse::<i32>())
    .collect();
assert_eq!(numbers, Ok(vec![1, 2, 3, 4]));

// 방법 2: 에러 무시하고 성공한 것만 수집
let mixed = vec!["1", "abc", "3", "xyz"];
let valid: Vec<i32> = mixed.iter()
    .filter_map(|s| s.parse().ok())  // ok(): Result → Option, Err는 None
    .collect();
assert_eq!(valid, vec![1, 3]);

// 방법 3: 성공/실패 분리
let (successes, failures): (Vec<_>, Vec<_>) = mixed.iter()
    .map(|s| s.parse::<i32>())
    .partition(Result::is_ok);
let values: Vec<i32> = successes.into_iter().map(|r| r.unwrap()).collect();
println!("성공: {:?}, 실패 수: {}", values, failures.len());

트레이트(Trait)와 제네릭(Generics)

트레이트는 공유 동작을 정의하는 Rust의 인터페이스 시스템입니다. 제네릭과 결합하여 타입 안전하면서도 유연한 코드를 작성할 수 있으며, 단형화(monomorphization)를 통해 런타임 오버헤드가 없습니다.

// 트레이트 정의
trait Summary {
    fn summarize(&self) -> String;

    // 기본 구현 — 구현체에서 오버라이드 가능
    fn preview(&self) -> String {
        format!("{}...", &self.summarize()[..20])
    }
}

// 트레이트 구현
struct Article { title: String, content: String }

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.title, &self.content[..50])
    }
}

// 제네릭 함수 + 트레이트 바운드
fn notify<T: Summary>(item: &T) {
    println!("속보: {}", item.summarize());
}

// where 절 — 복잡한 바운드를 읽기 쉽게
fn complex<T, U>(t: &T, u: &U) -> String
where
    T: Summary + Clone,
    U: Display + Debug,
{
    format!("{} — {}", t.summarize(), u)
}

// 제네릭 구조체
struct Pair<T> { first: T, second: T }

impl<T: PartialOrd> Pair<T> {
    fn larger(&self) -> &T {
        if self.first >= self.second { &self.first } else { &self.second }
    }
}

// 트레이트 객체 (동적 디스패치) — 런타임 다형성
fn print_summary(items: &[&dyn Summary]) {
    for item in items {
        println!("{}", item.summarize());
    }
}

// derive 매크로 — 자동 트레이트 구현
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct Config {
    name: String,
    value: i32,
}

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

// 정적 디스패치 — 컴파일러가 타입별 코드 생성 (제로 코스트)
fn process_static(item: impl Summary) {
    println!("{}", item.summarize());
}
// process_static(article) → process_static_Article() 생성
// process_static(tweet)   → process_static_Tweet() 생성

// 동적 디스패치 — 런타임에 vtable로 메서드 호출
fn process_dynamic(item: &dyn Summary) {
    println!("{}", item.summarize());  // vtable을 통한 간접 호출
}

// 이종 컬렉션 — dyn Trait만 가능
let items: Vec<Box<dyn Summary>> = vec![
    Box::new(article),
    Box::new(tweet),  // 서로 다른 타입을 하나의 컬렉션에!
];

수퍼트레이트, 블랭킷 구현, 연관 타입

Rust의 트레이트 시스템은 수퍼트레이트(Supertrait)로 트레이트 간 의존성을 표현하고, 블랭킷 구현(Blanket Implementation)으로 제네릭한 범위에 대해 일괄 구현하며, 연관 타입(Associated Type)으로 트레이트의 출력 타입을 지정합니다. 이 세 가지를 이해하면 표준 라이브러리와 커널 트레이트 설계를 깊이 파악할 수 있습니다.

// ═══════════════════════════════════════════════════════════════
// 1. 수퍼트레이트 — trait A: B + C
// ═══════════════════════════════════════════════════════════════

use std::fmt;

// Error 트레이트는 Display + Debug를 수퍼트레이트로 요구
// → Error를 구현하려면 Display와 Debug도 반드시 구현해야 함
trait Printable: fmt::Display + fmt::Debug {
    fn print_both(&self) {
        println!("Display: {}, Debug: {:?}", self, self);
    }
}

#[derive(Debug)]
struct Point { x: f64, y: f64 }

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

// Display + Debug 모두 구현했으므로 Printable 구현 가능
impl Printable for Point {}

// 수퍼트레이트를 활용한 트레이트 바운드
fn log_item(item: &dyn Printable) {
    // Printable을 받으면 Display와 Debug 메서드도 사용 가능
    println!("[LOG] {}", item);        // Display
    println!("[DBG] {:?}", item);       // Debug
    item.print_both();                  // Printable 자체 메서드
}

// ═══════════════════════════════════════════════════════════════
// 2. 블랭킷 구현 (Blanket Implementation)
// ═══════════════════════════════════════════════════════════════

// 표준 라이브러리의 대표적 블랭킷 구현:
// impl<T: Display> ToString for T { ... }
// → Display를 구현한 모든 타입은 자동으로 ToString도 갖게 됨!

trait Greet {
    fn greet(&self) -> String;
}

// Display를 구현한 모든 타입에 Greet을 일괄 구현
impl<T: fmt::Display> Greet for T {
    fn greet(&self) -> String {
        format!("안녕하세요, {}님!", self)
    }
}

// String, &str, i32 등 Display 구현 타입은 모두 greet() 사용 가능
assert_eq!("Rust".greet(), "안녕하세요, Rust님!");
assert_eq!(42.greet(), "안녕하세요, 42님!");

// ═══════════════════════════════════════════════════════════════
// 3. Orphan Rule (고아 규칙 / 일관성)
// ═══════════════════════════════════════════════════════════════

// ✅ 허용: 내 트레이트 + 외부 타입
trait MyTrait {}
impl MyTrait for Vec<i32> {}   // OK — MyTrait은 내 크레이트 소속

// ✅ 허용: 외부 트레이트 + 내 타입
impl fmt::Display for Point {}  // OK — Point는 내 크레이트 소속

// ❌ 금지: 외부 트레이트 + 외부 타입
// impl fmt::Display for Vec<i32> {}  // 컴파일 에러!
// → 두 크레이트가 동시에 같은 구현을 만들면 충돌 발생

// 우회 방법: 뉴타입 패턴 (Newtype Pattern)
struct Wrapper(Vec<i32>);  // 내 타입으로 감싸기
impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.iter()
            .map(|n| n.to_string())
            .collect::<Vec<_>>()
            .join(", "))
    }
}

// ═══════════════════════════════════════════════════════════════
// 4. 연관 타입 vs 제네릭 매개변수
// ═══════════════════════════════════════════════════════════════

// 연관 타입: 구현당 하나의 타입만 지정 (1:1 관계)
trait Iterator {
    type Item;  // 연관 타입 — 구현 시 고정
    fn next(&mut self) -> Option<Self::Item>;
}

// Counter는 항상 u32를 반환 — Item이 고정됨
impl Iterator for Counter {
    type Item = u32;  // 구현 시 결정, 변경 불가
    fn next(&mut self) -> Option<u32> { /* ... */ }
}

// 제네릭 매개변수: 같은 타입에 여러 구현 가능 (1:N 관계)
trait From<T> {
    fn from(val: T) -> Self;
}

// 같은 타입이 From<u32>와 From<String> 모두 구현 가능
impl From<u32> for Point {
    fn from(v: u32) -> Self { Point { x: v as f64, y: 0.0 } }
}
impl From<(f64, f64)> for Point {
    fn from((x, y): (f64, f64)) -> Self { Point { x, y } }
}

컬렉션 (Vec, HashMap, BTreeMap, HashSet)

Rust의 표준 컬렉션은 소유권 시스템과 통합되어 메모리 안전합니다. 모든 힙 할당 컬렉션은 스코프 종료 시 자동 해제됩니다.

// Vec<T> — 가변 길이 배열 (가장 많이 사용)
let mut v: Vec<i32> = Vec::new();
v.push(1); v.push(2); v.push(3);

let v2 = vec![1, 2, 3];  // 매크로로 초기화

// 안전한 접근
let third: Option<&i32> = v.get(2);  // None if out of bounds
let third: &i32 = &v[2];              // panic if out of bounds

// HashMap<K, V> — 키-값 저장소
use std::collections::HashMap;
let mut scores: HashMap<String, i32> = HashMap::new();
scores.insert("Alice".to_string(), 100);
scores.insert("Bob".to_string(), 85);

// entry API — 키가 없을 때만 삽입
scores.entry("Alice".to_string()).or_insert(0);
*scores.entry("Charlie".to_string()).or_insert(0) += 50;

// BTreeMap — 키 기준 정렬 (O(log n) 탐색)
use std::collections::BTreeMap;
let mut sorted: BTreeMap<i32, &str> = BTreeMap::new();
sorted.insert(3, "c"); sorted.insert(1, "a"); sorted.insert(2, "b");
// 순회 시 키 순서 보장: 1→2→3

// HashSet — 중복 없는 값 집합
use std::collections::HashSet;
let a: HashSet<i32> = [1, 2, 3].into();
let b: HashSet<i32> = [2, 3, 4].into();
let union: HashSet<&i32> = a.union(&b).collect();        // {1, 2, 3, 4}
let inter: HashSet<&i32> = a.intersection(&b).collect();  // {2, 3}

// VecDeque — 양방향 큐 (O(1) 앞뒤 삽입/삭제)
use std::collections::VecDeque;
let mut deque = VecDeque::new();
deque.push_back(1);  deque.push_front(0);
// [0, 1]

std vs kernel 컬렉션 API 비교

// === 커널 Vec 패턴: 모든 할당이 실패 가능 ===
use kernel::prelude::*;

fn collect_data(count: usize) -> Result<Vec<u32>> {
    let mut data = Vec::new();
    data.try_reserve(count)?;  // 미리 용량 확보 시도

    for i in 0..count {
        data.try_push(i as u32)?;  // push 대신 try_push
    }
    Ok(data)
}

// === 반복 패턴 — 컬렉션과 반복자 조합 ===
let v = vec![10, 20, 30, 40, 50];

// 소유권 이동 반복 (원본 소멸)
for val in v { /* val: i32, v 사용 불가 */ }

// 불변 참조 반복 (원본 유지)
for val in &v { /* val: &i32 */ }

// 가변 참조 반복 (원소 수정)
for val in &mut v { *val *= 2; }

Vec 내부 구조와 용량 관리

Vec<T>는 Rust에서 가장 많이 사용하는 컬렉션입니다. 내부적으로 포인터(ptr), 길이(len), 용량(capacity) 세 필드로 구성되며, 힙에 연속된 메모리 블록을 할당합니다. 용량 초과 시 2배 전략(doubling strategy)으로 재할당하며, with_capacity()로 미리 예약하면 불필요한 재할당을 방지할 수 있습니다.

// ═══════════════════════════════════════════════════════════════
// 1. with_capacity()로 재할당 최소화
// ═══════════════════════════════════════════════════════════════

// 나쁜 예: 반복적 재할당 발생 (0→4→8→16→32→64→128→...)
let mut slow = Vec::new();
for i in 0..1000 {
    slow.push(i);  // 약 10번의 재할당 + 데이터 복사 발생
}

// 좋은 예: 한 번만 할당
let mut fast = Vec::with_capacity(1000);
for i in 0..1000 {
    fast.push(i);  // 재할당 없음!
}
assert_eq!(fast.len(), 1000);
assert!(fast.capacity() >= 1000);

// ═══════════════════════════════════════════════════════════════
// 2. drain(), retain(), dedup() 활용
// ═══════════════════════════════════════════════════════════════

let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8];

// drain: 범위 요소를 제거하며 Iterator로 반환
let middle: Vec<i32> = v.drain(2..5).collect();  // [3, 4, 5]
assert_eq!(v, vec![1, 2, 6, 7, 8]);               // 원본에서 제거됨

// retain: 조건에 맞는 요소만 남김 (in-place filter)
let mut nums = vec![1, 2, 3, 4, 5, 6];
nums.retain(|&x| x % 2 == 0);  // 짝수만 유지
assert_eq!(nums, vec![2, 4, 6]);

// dedup: 연속 중복 제거 (정렬 후 사용해야 효과적)
let mut data = vec![3, 1, 4, 1, 5, 3, 3];
data.sort();    // [1, 1, 3, 3, 3, 4, 5]
data.dedup();   // [1, 3, 4, 5] — 연속 중복만 제거

// dedup_by_key: 키 함수 기반 중복 제거
let mut words = vec!["apple", "APPLE", "banana", "Banana"];
words.dedup_by_key(|s| s.to_lowercase());
assert_eq!(words, vec!["apple", "banana"]);

// ═══════════════════════════════════════════════════════════════
// 3. Vec<u8> — 바이트 버퍼로 활용
// ═══════════════════════════════════════════════════════════════

// 네트워크/파일 I/O에서 흔히 사용하는 패턴
let mut buf: Vec<u8> = Vec::with_capacity(4096);

// extend_from_slice로 효율적 데이터 추가
buf.extend_from_slice(b"HTTP/1.1 200 OK\r\n");
buf.extend_from_slice(b"Content-Type: text/plain\r\n\r\n");
buf.extend_from_slice(b"Hello, World!");

// Vec<u8> ↔ String 변환
let text = String::from_utf8(buf.clone()).unwrap();
let bytes: Vec<u8> = text.into_bytes();

// 커널에서: kmalloc 대신 Vec<u8> 사용
// let mut kernel_buf: Vec<u8> = Vec::new();
// kernel_buf.try_reserve(PAGE_SIZE)?;

// ═══════════════════════════════════════════════════════════════
// 4. 내부 포인터와 안전한 슬라이스 변환
// ═══════════════════════════════════════════════════════════════

let v = vec![10, 20, 30];
let ptr: *const i32 = v.as_ptr();       // 내부 포인터 획득
let slice: &[i32] = v.as_slice();       // &[i32]로 변환
let (left, right) = v.split_at(2);     // [10,20] / [30]
assert_eq!(left, &[10, 20]);
assert_eq!(right, &[30]);

반복자(Iterator)와 클로저(Closure)

반복자와 클로저는 Rust의 함수형 프로그래밍 도구입니다. 지연 평가(lazy evaluation)와 제로 코스트 추상화 덕분에 가독성을 유지하면서 최적의 성능을 달성합니다.

// 클로저(Closure) — 환경을 캡처하는 익명 함수
let multiplier = 3;
let multiply = |x: i32| x * multiplier;  // multiplier를 참조로 캡처
println!("{}", multiply(5));  // 15

// 클로저의 세 가지 트레이트 (캡처 방식에 따라 자동 결정)
// Fn:     &self   — 환경을 불변 참조로 캡처
// FnMut:  &mut self — 환경을 가변 참조로 캡처
// FnOnce: self    — 환경의 소유권을 가져감 (한 번만 호출 가능)

// move 클로저 — 환경 변수의 소유권을 강제 이동
let name = String::from("thread-1");
let handle = std::thread::spawn(move || {
    println!("I'm {}", name);  // name의 소유권이 클로저로 이동
});

// 반복자 어댑터 체인 — 가독성과 성능을 모두 확보
let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 짝수만 필터 → 제곱 → 합계
let sum: i32 = data.iter()
    .filter(|&&n| n % 2 == 0)
    .map(|&n| n * n)
    .sum();  // 4 + 16 + 36 + 64 + 100 = 220

// enumerate — 인덱스와 값을 동시에
for (i, val) in data.iter().enumerate() {
    println!("[{}] = {}", i, val);
}

// collect — Iterator를 다양한 컬렉션으로 변환
let doubled: Vec<i32> = data.iter().map(|&x| x * 2).collect();
let set: HashSet<i32> = data.into_iter().collect();

// zip — 두 반복자를 병렬 결합
let keys = vec!["a", "b", "c"];
let vals = vec![1, 2, 3];
let map: HashMap<&&str, &i32> = keys.iter().zip(vals.iter()).collect();

// fold — 초기값 + 누적 함수
let product = (1..=5).fold(1, |acc, x| acc * x);  // 120 (5!)

주요 반복자 어댑터/소비자 정리

// 커스텀 Iterator 구현
struct Counter {
    count: u32,
    max: u32,
}

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None  // 반복 종료
        }
    }
}

// 커스텀 반복자도 모든 어댑터/소비자 자동 사용 가능!
let sum: u32 = Counter { count: 0, max: 5 }
    .filter(|&n| n % 2 == 0)
    .sum();  // 2 + 4 = 6

클로저 트레이트(Fn/FnMut/FnOnce)와 고급 반복자 패턴

클로저는 환경을 캡처하는 방식에 따라 Fn, FnMut, FnOnce 중 하나의 트레이트를 자동으로 구현합니다. 이 세 트레이트는 계층 관계를 형성하며, 반복자와 결합하면 제로 코스트 추상화(zero-cost abstraction)를 통해 C 수준의 성능을 유지하면서도 고수준의 가독성을 확보할 수 있습니다.

// ═══════════════════════════════════════════════════════════════
// 1. Fn, FnMut, FnOnce 각각의 예시
// ═══════════════════════════════════════════════════════════════

// Fn — 환경을 불변 참조로 캡처 (여러 번 호출 가능, 동시 호출 가능)
let name = String::from("커널");
let greet = || println!("안녕, {}!", name);  // &name 캡처
greet();  // 여러 번 호출 가능
greet();  // name은 불변 참조이므로 반복 사용 OK

// FnMut — 환경을 가변 참조로 캡처
let mut count = 0;
let mut counter = || {
    count += 1;  // &mut count 캡처 — 값을 변경
    count
};
assert_eq!(counter(), 1);
assert_eq!(counter(), 2);  // 여러 번 호출 가능하지만 &mut이므로 동시 호출 불가

// FnOnce — 환경의 소유권을 가져감 (한 번만 호출 가능)
let data = String::from("소유권 이동");
let consume = || {
    let _moved = data;  // data의 소유권을 클로저 내부로 이동
    println!("소비됨: {}", _moved);
};
consume();  // OK — 첫 호출
// consume();  // 컴파일 에러! 이미 소유권이 이동됨

// ═══════════════════════════════════════════════════════════════
// 2. 함수 매개변수로 클로저 트레이트 사용
// ═══════════════════════════════════════════════════════════════

// Fn: 반복 호출 필요 (이벤트 핸들러, 콜백 등)
fn repeat_action(action: impl Fn(), times: usize) {
    for _ in 0..times { action(); }
}

// FnMut: 상태 누적 필요 (sort_by, for_each 등)
fn apply_mut<F: FnMut(i32) -> i32>(mut f: F, val: i32) -> i32 {
    f(val)
}

// FnOnce: 한 번만 호출 (thread::spawn, unwrap_or_else 등)
fn execute_once<F: FnOnce() -> String>(f: F) -> String {
    f()  // 소유권을 소비하므로 한 번만 호출
}

// ═══════════════════════════════════════════════════════════════
// 3. move 키워드의 효과
// ═══════════════════════════════════════════════════════════════

let data = vec![1, 2, 3];

// move 없이: 참조로 캡처 → 스레드에 전달 불가 (수명 문제)
// let handle = std::thread::spawn(|| println!("{:?}", data)); // 에러

// move 사용: 소유권을 클로저로 강제 이동
let handle = std::thread::spawn(move || {
    println!("{:?}", data);  // data의 소유권이 클로저로 이동
});
// data는 여기서 더 이상 사용 불가
handle.join().unwrap();

// 주의: move는 캡처 방식(값/참조)만 변경, 트레이트 종류는 바꾸지 않음
// move || x + 1  → Fn 구현 (x가 Copy이므로 복사되어 이동)
// move || drop(s) → FnOnce 구현 (s의 소유권 소비)

// ═══════════════════════════════════════════════════════════════
// 4. 반복자 vs 루프: 제로 코스트 추상화 증명
// ═══════════════════════════════════════════════════════════════

// C 스타일 루프
let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut sum_loop = 0;
for i in 0..data.len() {
    if data[i] % 2 == 0 {
        sum_loop += data[i] * data[i];
    }
}

// 반복자 체인 — 동일한 성능, 더 나은 가독성
let sum_iter: i32 = data.iter()
    .filter(|&&n| n % 2 == 0)
    .map(|&n| n * n)
    .sum();

// 두 결과는 동일: 220
// LLVM이 반복자 체인을 루프와 동일한 기계어로 컴파일!
// → "추상화 비용 = 0" (Zero-Cost Abstraction)
assert_eq!(sum_loop, sum_iter);

// ═══════════════════════════════════════════════════════════════
// 5. IntoIterator 구현 — for 루프 지원
// ═══════════════════════════════════════════════════════════════

struct Matrix {
    data: Vec<Vec<f64>>,
}

// IntoIterator를 구현하면 for 루프에서 직접 사용 가능
impl IntoIterator for Matrix {
    type Item = Vec<f64>;
    type IntoIter = std::vec::IntoIter<Vec<f64>>;

    fn into_iter(self) -> Self::IntoIter {
        self.data.into_iter()  // 행 단위로 반복
    }
}

// 참조에 대한 IntoIterator — 소유권 유지
impl<'a> IntoIterator for &'a Matrix {
    type Item = &'a Vec<f64>;
    type IntoIter = std::slice::Iter<'a, Vec<f64>>;

    fn into_iter(self) -> Self::IntoIter {
        self.data.iter()
    }
}

// 사용
let m = Matrix { data: vec![vec![1.0, 2.0], vec![3.0, 4.0]] };
for row in &m {          // &Matrix에 대한 IntoIterator 호출
    println!("{:?}", row);  // m은 빌림이므로 이후에도 사용 가능
}

// ═══════════════════════════════════════════════════════════════
// 6. 실전 반복자 어댑터: windows, chunks, peekable
// ═══════════════════════════════════════════════════════════════

let data = [1, 2, 3, 4, 5];

// windows(n): 슬라이딩 윈도우 (겹치는 부분 배열)
for w in data.windows(3) {
    println!("{:?}", w);
    // [1, 2, 3] → [2, 3, 4] → [3, 4, 5]
}

// 이동 평균 계산
let prices = [100.0, 102.5, 98.0, 105.0, 101.0];
let moving_avg: Vec<f64> = prices.windows(3)
    .map(|w| w.iter().sum::<f64>() / w.len() as f64)
    .collect();  // [100.17, 101.83, 101.33]

// chunks(n): 겹치지 않는 고정 크기 블록
let bytes = [0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE];
for chunk in bytes.chunks(2) {
    println!("{:02X}{:02X}", chunk[0], chunk[1]);
    // DEAD → BEEF → CAFE
}

// peekable(): 다음 요소를 소비하지 않고 미리 확인
let mut iter = vec![1, 2, 3].into_iter().peekable();
assert_eq!(iter.peek(), Some(&1));  // 소비하지 않고 확인
assert_eq!(iter.next(), Some(1));   // 이제 소비
assert_eq!(iter.peek(), Some(&2));  // 다음 요소 미리보기

// peekable 실전: 파서에서 토큰 미리보기
fn parse_numbers(input: &str) -> Vec<i32> {
    let mut chars = input.chars().peekable();
    let mut result = Vec::new();
    while let Some(&c) = chars.peek() {
        if c.is_ascii_digit() {
            let num: String = chars
                .by_ref()
                .take_while(|c| c.is_ascii_digit())
                .collect();
            result.push(num.parse().unwrap());
        } else {
            chars.next();
        }
    }
    result
}

스마트 포인터 (Box, Rc, Arc, RefCell, Cow)

스마트 포인터는 포인터처럼 동작하면서 추가 메타데이터와 기능을 제공합니다. Rust의 소유권 시스템과 통합되어 메모리 안전성을 보장합니다.

// Box<T> — 힙 할당 + 단일 소유
let b = Box::new(5);  // 힙에 i32 할당
println!("{}", b);     // Deref로 자동 역참조

// 재귀 타입에 필수 — 컴파일 타임에 크기를 알 수 없는 경우
enum List {
    Cons(i32, Box<List>),
    Nil,
}

// Rc<T> — 단일 스레드 참조 카운팅
use std::rc::Rc;
let shared = Rc::new(42);
let clone1 = Rc::clone(&shared);  // 참조 카운트: 2
let clone2 = Rc::clone(&shared);  // 참조 카운트: 3
println!("참조 수: {}", Rc::strong_count(&shared));  // 3

// RefCell<T> — 내부 가변성 (런타임 빌림 검사)
use std::cell::RefCell;
let cell = RefCell::new(vec![1, 2, 3]);
cell.borrow_mut().push(4);  // 불변 컨텍스트에서도 내부 변경 가능
println!("{:?}", cell.borrow());  // [1, 2, 3, 4]
// 주의: 규칙 위반 시 컴파일 에러가 아닌 런타임 panic!

// Rc + RefCell 조합 — 다중 소유 + 가변성
let shared = Rc::new(RefCell::new(vec![1]));
let clone = Rc::clone(&shared);
shared.borrow_mut().push(2);
clone.borrow_mut().push(3);
println!("{:?}", shared.borrow());  // [1, 2, 3]

// Cow (Clone on Write) — 읽기는 빌림, 변경 시에만 복사
use std::borrow::Cow;
fn process(input: &str) -> Cow<str> {
    if input.contains(' ') {
        Cow::Owned(input.replace(' ', "_"))  // 변경 필요 → 복사
    } else {
        Cow::Borrowed(input)  // 변경 불필요 → 빌림만
    }
}

스마트 포인터 선택 가이드

Deref 강제 변환, Drop, Weak 참조

스마트 포인터의 핵심 동작은 Deref, DerefMut, Drop 트레이트에 의해 결정됩니다. 또한 Weak<T>는 순환 참조 문제를 해결하는 핵심 도구입니다.

Deref 트레이트와 강제 변환(Deref Coercion)

Deref 트레이트를 구현하면 스마트 포인터를 일반 참조처럼 사용할 수 있습니다. 컴파일러가 자동으로 역참조 강제 변환(deref coercion) 체인을 적용합니다.

// Deref 강제 변환 체인 예시
use std::ops::Deref;

// String → &str 자동 변환
fn greet(name: &str) {
    println!("안녕하세요, {}!", name);
}

let owned = String::from("Rust");
greet(&owned);  // &String → &str (Deref 자동 적용)

// Box<T> → &T 자동 변환
let boxed = Box::new(String::from("world"));
greet(&boxed);  // &Box<String> → &String → &str (연쇄 변환!)

// DerefMut 예시 — 가변 역참조
fn push_exclaim(s: &mut String) {
    s.push('!');
}

let mut boxed_str = Box::new(String::from("hello"));
push_exclaim(&mut boxed_str);  // &mut Box<String> → &mut String (DerefMut)

// 사용자 정의 Deref 구현
struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}

let my = MyBox(String::from("hello"));
greet(&my);  // &MyBox<String> → &String → &str

Drop 트레이트: 소멸 순서와 규칙

Drop 트레이트는 값이 스코프를 벗어날 때 자동으로 호출됩니다. 선언 역순으로 드롭되며, Copy와 상호 배타적입니다.

// Drop 순서: 선언의 역순 (스택 LIFO)
struct Resource {
    name: String,
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("해제: {}", self.name);
    }
}

{
    let a = Resource { name: "A".into() };  // 1번째 선언
    let b = Resource { name: "B".into() };  // 2번째 선언
    let c = Resource { name: "C".into() };  // 3번째 선언
}
// 출력 순서: 해제: C → 해제: B → 해제: A (역순!)

// 명시적 조기 해제: std::mem::drop()
let lock = mutex.lock().unwrap();
// ... 임계 영역 작업 ...
drop(lock);  // 스코프 끝까지 기다리지 않고 즉시 해제
// 이후 다른 스레드가 락 획득 가능

// ⚠️ Drop + Copy 상호 배타
// #[derive(Copy, Clone)]  // 컴파일 에러!
// struct Resource { ... } // Drop이 있으면 Copy 불가
// 이유: Copy는 비트 복사, Drop은 정리 로직 → 이중 해제 위험

Weak<T>: 순환 참조 해결

Rc<T>나 Arc<T>만 사용하면 순환 참조가 발생하여 메모리 누수가 생길 수 있습니다. Weak<T>는 참조 카운트를 증가시키지 않으므로 이 문제를 해결합니다.

use std::rc::{Rc, Weak};
use std::cell::RefCell;

// 트리 구조: 부모는 Weak, 자식은 Rc
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,     // ← Weak로 부모 참조 (순환 방지!)
    children: RefCell<Vec<Rc<Node>>>, // ← Rc로 자식 소유
}

let parent = Rc::new(Node {
    value: 1,
    parent: RefCell::new(Weak::new()),
    children: RefCell::new(vec![]),
});

let child = Rc::new(Node {
    value: 2,
    parent: RefCell::new(Rc::downgrade(&parent)),  // Weak 생성
    children: RefCell::new(vec![]),
});

parent.children.borrow_mut().push(Rc::clone(&child));

// 부모 접근: Weak → Option<Rc<Node>>
if let Some(p) = child.parent.borrow().upgrade() {
    println!("부모 값: {}", p.value);  // 부모 값: 1
}

// 참조 카운트 확인
println!("parent strong={}, weak={}",
    Rc::strong_count(&parent),  // 1 (child의 Weak는 카운트 안 함!)
    Rc::weak_count(&parent));   // 1 (child가 Weak 보유)

// 원본이 해제된 후 Weak 사용
let weak_ref: Weak<i32>;
{
    let strong = Rc::new(42);
    weak_ref = Rc::downgrade(&strong);
    assert!(weak_ref.upgrade().is_some());  // Some(42)
}   // strong 해제됨
assert!(weak_ref.upgrade().is_none());  // None — 안전하게 실패!

동시성 프로그래밍 (Thread, Channel, Mutex, RwLock)

Rust의 "Fearless Concurrency"는 소유권 시스템이 데이터 레이스를 컴파일 타임에 방지하므로, 동시성 프로그래밍에서 흔히 발생하는 버그를 원천 차단합니다.

// 스레드 생성과 join
use std::thread;

let handle = thread::spawn(|| {
    println!("다른 스레드에서 실행");
    42
});
let result = handle.join().unwrap();  // 42

// Arc + Mutex — 멀티스레드 공유 상태
use std::sync::{Arc, Mutex};

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    handles.push(thread::spawn(move || {
        let mut num = counter.lock().unwrap();
        *num += 1;
        // MutexGuard가 스코프를 벗어나면 자동 unlock (RAII)
    }));
}
for h in handles { h.join().unwrap(); }
println!("결과: {}", *counter.lock().unwrap());  // 10

// 채널 (mpsc: Multiple Producer, Single Consumer)
use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
let tx2 = tx.clone();  // 다중 전송자

thread::spawn(move || { tx.send("hello").unwrap(); });
thread::spawn(move || { tx2.send("world").unwrap(); });

for msg in rx.iter().take(2) {
    println!("수신: {}", msg);
}

// scoped thread (Rust 1.63+) — 부모 스택 데이터를 안전하게 빌림
let data = vec![1, 2, 3];
thread::scope(|s| {
    s.spawn(|| { println!("스레드 1: {:?}", &data); });
    s.spawn(|| { println!("스레드 2: {:?}", &data); });
});
// 스코프 종료 시 자동 join — data 여전히 유효

// RwLock — 동시 읽기 허용, 쓰기는 배타적
use std::sync::RwLock;

let config = Arc::new(RwLock::new(Config::default()));

// 여러 스레드가 동시에 읽기 가능
let read_guard = config.read().unwrap();
println!("설정: {:?}", *read_guard);
drop(read_guard);  // 명시적 해제 (보통 스코프가 하지만)

// 쓰기는 모든 읽기가 끝난 후 배타적으로
let mut write_guard = config.write().unwrap();
*write_guard = Config::new("updated");

// Atomic — 잠금 없는(lock-free) 동기화
use std::sync::atomic::{AtomicUsize, Ordering};

static REQUEST_COUNT: AtomicUsize = AtomicUsize::new(0);

fn handle_request() {
    let count = REQUEST_COUNT.fetch_add(1, Ordering::Relaxed);
    println!("요청 #{}", count + 1);
}

// Ordering 종류 (동기화 강도 순)
// Relaxed: 순서 보장 없음 (카운터에 적합)
// Acquire: 이후 읽기/쓰기가 이전으로 재배치 안 됨
// Release: 이전 읽기/쓰기가 이후로 재배치 안 됨
// AcqRel: Acquire + Release
// SeqCst: 모든 스레드에서 동일한 순서 보장 (가장 강력, 가장 느림)

Mutex 패턴, 데드락 방지, 조건 변수

실전 동시성 프로그래밍에서는 Mutex 중독(poisoning), 데드락(deadlock), 조건부 대기 등 다양한 문제에 대응해야 합니다. Rust의 타입 시스템이 데이터 레이스를 방지하지만, 논리적 데드락은 프로그래머가 직접 관리해야 합니다.

Mutex Poisoning (중독)

스레드가 Mutex를 잡고 있는 상태에서 패닉하면, 해당 Mutex는 중독(poisoned) 상태가 됩니다. 이후 lock() 호출은 PoisonError를 반환합니다.

use std::sync::{Arc, Mutex};
use std::thread;

let data = Arc::new(Mutex::new(0));

// 스레드가 락을 잡고 패닉
let data_clone = Arc::clone(&data);
let _ = thread::spawn(move || {
    let mut guard = data_clone.lock().unwrap();
    *guard = 42;
    panic!("스레드 패닉!");  // 락을 잡은 채 패닉 → Mutex 중독
}).join();

// 중독된 Mutex 접근 — Err(PoisonError) 반환
match data.lock() {
    Ok(guard) => println!("정상: {}", *guard),
    Err(poisoned) => {
        // 복구 패턴 1: 중독된 데이터에 접근
        let guard = poisoned.into_inner();
        println!("복구된 값: {}", *guard);  // 복구된 값: 42
    }
}

// 복구 패턴 2: unwrap_or_else로 간결하게
let mut guard = data.lock().unwrap_or_else(|e| {
    eprintln!("Mutex 중독 복구: {:?}", e);
    e.into_inner()  // 중독 상태 무시하고 데이터 접근
});
*guard = 0;  // 데이터를 안전한 상태로 리셋

데드락 방지 전략

Rust 컴파일러는 데이터 레이스를 방지하지만, 데드락은 타입 시스템으로 감지할 수 없습니다. 프로그래머가 직접 방지 전략을 적용해야 합니다.

use std::sync::{Arc, Mutex};

// ❌ 데드락 발생: 락 순서가 서로 다름
let lock_a = Arc::new(Mutex::new(1));
let lock_b = Arc::new(Mutex::new(2));

// Thread 1: A → B 순서로 락
// Thread 2: B → A 순서로 락  ← 데드락!

// ✅ 해결 1: 항상 같은 순서로 락 획득
// 모든 스레드에서 반드시 lock_a → lock_b 순서 유지
let _guard_a = lock_a.lock().unwrap();
let _guard_b = lock_b.lock().unwrap();

// ✅ 해결 2: try_lock()으로 비차단 시도
let guard_a = lock_a.lock().unwrap();
match lock_b.try_lock() {
    Ok(guard_b) => {
        // 두 락 모두 획득 성공 — 작업 수행
        println!("A={}, B={}", *guard_a, *guard_b);
    }
    Err(_) => {
        // lock_b 획득 실패 — guard_a도 해제하고 재시도
        drop(guard_a);
        eprintln!("락 획득 실패, 재시도 필요");
    }
}

// ✅ 해결 3: 스코프를 줄여서 락 보유 시간 최소화
let value = {
    let guard = lock_a.lock().unwrap();
    *guard  // 값을 복사하고 즉시 락 해제
};
// 이후 value는 락 없이 자유롭게 사용

Condvar (조건 변수)

Condvar는 특정 조건이 충족될 때까지 스레드를 효율적으로 대기시킵니다. 바쁜 대기(busy-wait) 대신 OS 수준에서 스레드를 잠재웁니다.

use std::sync::{Arc, Mutex, Condvar};
use std::thread;

// 생산자-소비자 패턴
let pair = Arc::new((Mutex::new(false), Condvar::new()));

// 소비자: 조건이 true가 될 때까지 대기
let pair_clone = Arc::clone(&pair);
let consumer = thread::spawn(move || {
    let (lock, cvar) = &*pair_clone;
    let mut ready = lock.lock().unwrap();
    while !*ready {
        ready = cvar.wait(ready).unwrap();  // 락 해제 + 대기 + 재획득
    }
    println!("데이터 준비 완료!");
});

// 생산자: 조건을 true로 설정하고 알림
let (lock, cvar) = &*pair;
{
    let mut ready = lock.lock().unwrap();
    *ready = true;
}
cvar.notify_one();  // 대기 중인 스레드 하나 깨움
// cvar.notify_all(); — 모든 대기 스레드 깨움

consumer.join().unwrap();

Barrier: 스레드 동기화 지점

use std::sync::{Arc, Barrier};
use std::thread;

// 4개 스레드가 모두 도착해야 진행
let barrier = Arc::new(Barrier::new(4));
let mut handles = vec![];

for i in 0..4 {
    let b = Arc::clone(&barrier);
    handles.push(thread::spawn(move || {
        println!("스레드 {} 작업 시작", i);
        // ... 1단계 작업 ...
        b.wait();  // 모든 스레드가 여기 도달할 때까지 대기
        println!("스레드 {} 2단계 진행", i);  // 모두 동시에 시작
    }));
}

for h in handles { h.join().unwrap(); }

실전 패턴: 생산자-소비자 (mpsc)

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

// mpsc: Multiple Producer, Single Consumer
let (tx, rx) = mpsc::channel();

// 다중 생산자 — tx를 clone하여 여러 스레드에서 전송
for i in 0..3 {
    let tx_clone = tx.clone();
    thread::spawn(move || {
        thread::sleep(Duration::from_millis(i * 100));
        tx_clone.send(format!("메시지 {}", i)).unwrap();
    });
}
drop(tx);  // 원본 tx 해제 — 모든 생산자 종료 시 rx가 종료됨

// 소비자 — 모든 메시지 수신 (채널 닫힐 때까지)
for msg in rx {
    println!("수신: {}", msg);
}

// 동기 채널: sync_channel(버퍼_크기)
let (tx, rx) = mpsc::sync_channel(2);  // 버퍼 2개
// 버퍼가 가득 차면 send()가 블록됨 → 배압(backpressure) 제공

동기화 프리미티브 비교

모듈 시스템과 크레이트

Rust의 모듈 시스템은 코드를 논리적으로 구조화하고, 가시성(visibility)을 제어합니다. 크레이트(crate)는 컴파일의 최소 단위입니다.

// 모듈 선언 — 파일 시스템과 매핑
// src/lib.rs (크레이트 루트)
pub mod network {       // → src/network.rs 또는 src/network/mod.rs
    pub mod tcp {        // → src/network/tcp.rs
        pub fn connect() { /* ... */ }
        fn internal() { /* 비공개 */ }
    }
    pub mod udp;         // → src/network/udp.rs
}

// 가시성 (Visibility)
pub            // 어디서든 접근 가능
pub(crate)     // 같은 크레이트 내에서만
pub(super)     // 부모 모듈에서만
pub(in path)   // 지정한 경로에서만
               // (기본) 같은 모듈 내에서만 — 비공개

// use — 경로 단축
use std::collections::HashMap;
use std::io::{Read, Write, BufReader};  // 그룹 임포트
use crate::network::tcp;  // 절대 경로 (크레이트 루트 기준)
use super::config;       // 상대 경로 (부모 모듈 기준)
use std::fmt::Result as FmtResult;  // 이름 충돌 방지

// 크레이트 타입
// - 바이너리 크레이트: src/main.rs (실행 파일)
// - 라이브러리 크레이트: src/lib.rs (라이브러리)
// - 워크스페이스: 여러 크레이트를 하나의 프로젝트로 관리

Cargo.toml과 의존성 관리

# Cargo.toml — 크레이트 매니페스트 파일
[package]
name = "my-project"
version = "0.1.0"
edition = "2021"     # Rust 에디션 (2015, 2018, 2021, 2024)

[dependencies]
serde = { version = "1.0", features = ["derive"] }  # 기능 선택
tokio = { version = "1", features = ["full"] }

[dev-dependencies]           # 테스트/벤치마크에서만 사용
criterion = "0.5"

[workspace]                  # 워크스페이스 (다수 크레이트 관리)
members = ["core", "cli", "web"]

Rust 에디션(Edition) 비교

모듈 재내보내기, 워크스페이스, Cargo 기능

대규모 Rust 프로젝트에서는 모듈 재내보내기(re-export)로 깔끔한 공개 API를 구성하고, Cargo 워크스페이스로 다중 크레이트를 관리하며, feature 플래그로 조건부 컴파일을 제어합니다.

pub use를 이용한 API 파사드 패턴

내부 모듈 구조를 숨기고 사용자에게 평탄한 API를 제공하는 패턴입니다. 라이브러리의 lib.rs에서 내부 모듈의 타입을 최상위로 재내보내기 합니다.

// src/lib.rs — 라이브러리 진입점
mod internal {
    pub mod parser {
        pub struct Parser { /* ... */ }
        pub struct Token { /* ... */ }
        pub fn parse(input: &str) -> Vec<Token> { /* ... */ vec![] }
    }
    pub mod codegen {
        pub struct Generator { /* ... */ }
        pub fn emit(tokens: &[super::parser::Token]) -> String { String::new() }
    }
}

// 사용자는 mylib::Parser로 접근 (mylib::internal::parser::Parser 대신)
pub use internal::parser::{Parser, Token, parse};
pub use internal::codegen::{Generator, emit};

// 선택적 재내보내기 — 이름 변경도 가능
pub use internal::parser::Parser as MainParser;

모듈 가시성 경계와 구조 모범 사례

// 권장 프로젝트 구조
// src/
//   lib.rs          ← pub use로 공개 API 정의
//   error.rs        ← pub(crate) 에러 타입
//   config.rs       ← pub(crate) 설정
//   parser/
//     mod.rs        ← parser 모듈 진입점
//     lexer.rs      ← pub(super) 내부 구현
//     ast.rs        ← pub(super) AST 정의
//   codegen/
//     mod.rs
//     backend.rs

mod parser;
mod codegen;
mod error;

// 공개 API만 재내보내기
pub use parser::Parser;
pub use codegen::Generator;
pub use error::Error;