← 가이드 목록으로 ← Back to guides
🦀 Rust #2

Rust 소유권 심화와 비동기 프로그래밍 완벽 가이드 Rust Ownership Deep Dive & Async Programming Guide

📖 약 18분 읽기 📖 18 min read 🏷️ Ownership, Lifetime, Async, Trait

Rust의 기본 문법을 넘어 메모리 안전성의 핵심인 소유권과 라이프타임을 심층적으로 다룹니다. 또한 async/await를 활용한 비동기 프로그래밍과 트레이트 바운드를 통한 제네릭 프로그래밍을 배웁니다.

Beyond Rust basics, this dives deep into ownership and lifetimes, the core of memory safety. Also learn async programming with async/await and generic programming with trait bounds.

라이프타임 명시적 선언 Explicit Lifetime Annotations

라이프타임은 참조가 유효한 범위를 나타냅니다. 컴파일러가 추론할 수 없는 경우 명시적으로 선언해야 합니다.

Lifetimes indicate the scope for which a reference is valid. When the compiler can't infer them, you must declare them explicitly.

// 두 참조 중 더 짧은 라이프타임 반환
fn longest<'a>(
  x: &'a str,
  y: &'a str,
) -> &'a str {
  if x.len() > y.len() { x } else { y }
}

// 구조체에서 라이프타임
struct ImportantExcerpt<'a> {
  part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
  fn level(&self) -> i32 {
    3
  }
}
// Return shorter lifetime of two references
fn longest<'a>(
  x: &'a str,
  y: &'a str,
) -> &'a str {
  if x.len() > y.len() { x } else { y }
}

// Lifetimes in structs
struct ImportantExcerpt<'a> {
  part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
  fn level(&self) -> i32 {
    3
  }
}

📊 라이프타임 규칙 📊 Lifetime Rules

  • 'static: 프로그램 전체 기간 동안 유효 (문자열 리터럴 등)
  • 'static: Valid for entire program duration (string literals, etc.)
  • 'a: 특정 범위 동안 유효한 참조
  • 'a: Reference valid for a specific scope
  • 출력 라이프타임은 입력 라이프타임 중 하나와 연결되어야 함
  • Output lifetime must be tied to one of the input lifetimes

트레이트 바운드 Trait Bounds

제네릭 타입에 특정 트레이트를 구현해야 한다는 제약을 추가합니다.

Add constraints requiring generic types to implement certain traits.

// 트레이트 바운드 문법
fn print_info<T: Display + Debug>(item: &T) {
  println!("Display: {}", item);
  println!("Debug: {:?}", item);
}

// where 절 사용 (복잡할 때 가독성 향상)
fn compare<T, U>(t: &T, u: &U) -> bool
where
  T: PartialOrd<U>,
  U: Clone,
{
  t > u
}
// Trait bound syntax
fn print_info<T: Display + Debug>(item: &T) {
  println!("Display: {}", item);
  println!("Debug: {:?}", item);
}

// Using where clause (better readability for complex cases)
fn compare<T, U>(t: &T, u: &U) -> bool
where
  T: PartialOrd<U>,
  U: Clone,
{
  t > u
}

async/await 비동기 프로그래밍 Async/Await Programming

Rust의 비동기 프로그래밍은 Future 트레이트 기반입니다. async와 await로 직관적인 비동기 코드를 작성할 수 있습니다.

Rust's async programming is based on the Future trait. Write intuitive async code with async and await.

use tokio;

// async 함수 정의
async fn fetch_data(url: &str) -> Result<String, Error> {
  let response = reqwest::get(url).await?;
  let body = response.text().await?;
  Ok(body)
}

// 여러 작업 동시 실행
async fn fetch_all() {
  let (a, b) = tokio::join!(
    fetch_data("https://api1.com"),
    fetch_data("https://api2.com"),
  );
}
use tokio;

// Define async function
async fn fetch_data(url: &str) -> Result<String, Error> {
  let response = reqwest::get(url).await?;
  let body = response.text().await?;
  Ok(body)
}

// Run multiple tasks concurrently
async fn fetch_all() {
  let (a, b) = tokio::join!(
    fetch_data("https://api1.com"),
    fetch_data("https://api2.com"),
  );
}

에러 처리 패턴 Error Handling Patterns

// ? 연산자로 에러 전파
fn read_file() -> Result<String, io::Error> {
  let content = fs::read_to_string("file.txt")?;
  Ok(content)
}

// 커스텀 에러 타입
use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
  #[error("IO 에러: {0}")]
  Io(#[from] io::Error),

  #[error("파싱 에러: {0}")]
  Parse(String),
}
// Propagate errors with ? operator
fn read_file() -> Result<String, io::Error> {
  let content = fs::read_to_string("file.txt")?;
  Ok(content)
}

// Custom error types
use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
  #[error("IO error: {0}")]
  Io(#[from] io::Error),

  #[error("Parse error: {0}")]
  Parse(String),
}

💡 Rust 타자 연습 팁 💡 Rust Typing Tips

&'a, impl Trait, -> Result<T, E> 패턴을 자주 타이핑해보세요. Rust 문법에 익숙해지면 컴파일러와 싸우는 시간이 줄어듭니다.

Practice typing &'a, impl Trait, -> Result<T, E> patterns often. Getting familiar with Rust syntax reduces time fighting the compiler.

⚠️ 빌림 규칙 주의 ⚠️ Borrowing Rules Warning

하나의 가변 참조 또는 여러 불변 참조만 가능합니다. 동시에 둘 다 가질 수 없습니다. 이 규칙이 데이터 레이스를 컴파일 타임에 방지합니다.

You can have either one mutable reference OR multiple immutable references, but not both at once. This rule prevents data races at compile time.