Rust lifetime이 어려운 이유와 실전 패턴 5가지

use tokio::task;

#[tokio::main]
async fn main() {
    let url = "https://example.com".to_string();

    // task::spawn은 'static을 요구
    task::spawn(async move {
        // url을 move로 획득 → 'static이 됨
        println!("{}", url);
    }).await.unwrap();
}

lifetime 에러 해결 전략

에러 1: "borrowed value does not live long enough"

fn take_ref(s: &str) -> &str {
    s  // OK
}

fn bad_example() -> &str {
    let s = String::from("hello");
    &s  // 에러: s가 함수 끝에서 drop됨
}

// 해결책 1: String을 반환
fn good_example() -> String {
    String::from("hello")
}

// 해결책 2: 인자에서 참조받기
fn good_example<'a>(input: &'a str) -> &'a str {
    input
}

에러 2: "cannot infer lifetime"

struct Config {
    name: &str,  // 에러: lifetime이 필요
}

// 해결책
struct Config<'a> {
    name: &'a str,
}

에러 3: "lifetime mismatch"

fn combine<'a>(a: &'a str, b: &'a str) -> &'a str {
    // 둘 다 같은 lifetime이어야 함
    if a.len() > b.len() { a } else { b }
}

let a = String::from("hello");
let b = "world";  // 다른 lifetime?

// 일반적으로 작동함 (Rust가 짧은 lifetime으로 조정)

자주 사용하는 lifetime 패턴

패턴 1: Self와 반환값이 같은 lifetime

impl<'a> MyIterator<'a> {
    fn next(&mut self) -> Option<&'a str> {
        // ...
    }
}

패턴 2: 입력과 출력이 다른 lifetime

fn combine<'a, 'b>(a: &'a str, b: &'b str) -> String {
    format!("{}{}", a, b)
}

패턴 3: Trait bound

trait Handler<'a> {
    fn handle(&'a self, data: &'a str);
}

실제 사례: JSON 파서

struct JsonParser<'a> {
    input: &'a str,
    pos: usize,
}

impl<'a> JsonParser<'a> {
    fn new(input: &'a str) -> Self {
        JsonParser { input, pos: 0 }
    }

    fn parse_string(&mut self) -> Result<&'a str, String> {
        // 입력 문자열의 부분을 반환
        // 반환값의 lifetime은 input과 같음
        let start = self.pos;
        // ... 파싱 로직 ...
        Ok(&self.input[start..self.pos])
    }
}

fn main() {
    let json = r#"{"name": "Alice"}"#;
    let mut parser = JsonParser::new(json);
    match parser.parse_string() {
        Ok(s) => println!("{}", s),
        Err(e) => println!("Error: {}", e),
    }
}

lifetime 없이 짜기 (최후의 수단)

정말 복잡하면, String으로 소유권을 가지거나, Rc/Arc를 사용한다:

use std::rc::Rc;

struct Parser {
    input: Rc,  // 참조가 아니라 소유권
}

impl Parser {
    fn new(input: String) -> Self {
        Parser {
            input: Rc::new(input),
        }
    }
}

결론

Rust lifetime이 어려운 이유: 메모리 안전성을 컴파일 타임에 보증하려면, 명시해야 하기 때문이다.

하지만 한 번 이해하면:

• 메모리 버그가 사라진다
• 코드 의도가 명확해진다
• 성능이 예측 가능해진다

오랜 개발 경험에서 얻은 깨달음: lifetime 에러 메시지는 불친절하지만, 거의 항상 옳다. 에러를 읽고 따르면 된다.