2026년 Rust 학습 가이드: 부트캠프 비교 및 독학 리소스 완벽 정리

// 소유권과 빌림의 기본 개념
fn demonstrate_ownership() {
    let original = String::from("Hello, Rust!");
    
    // 소유권 이동(무브)
    let moved = original;
    // println!("{}", original); // 컴파일 오류: 값이 이미 이동됨
    
    // 빌림(참조)
    let borrowed = &moved;
    println!("Borrowed: {}", borrowed);
    println!("Original: {}", moved);
}

fn demonstrate_mutable_borrow() {
    let mut data = vec![1, 2, 3];
    
    // 가변 빌림
    let mutable_ref = &mut data;
    mutable_ref.push(4);
    
    println!("Modified: {:?}", data);
}

// 에러 핸들링 실습 예제
use std::fs::File;
use std::io::{self, Read};

fn read_file_contents(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file_contents("config.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

// Rustlings 스타일 연습 예제
// 이 함수를 수정하여 올바르게 동작하도록 만드세요
fn calculate_average(numbers: &[i32]) -> Option<f64> {
    if numbers.is_empty() {
        return None;
    }
    
    let sum: i32 = numbers.iter().sum();
    let count = numbers.len() as f64;
    
    Some(sum as f64 / count)
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_average() {
        assert_eq!(calculate_average(&[1, 2, 3, 4, 5]), Some(3.0));
        assert_eq!(calculate_average(&[]), None);
    }
}

// 실습 프로젝트: CLI 도구 제작
use std::env;
use std::process;

struct Config {
    query: String,
    filename: String,
    case_sensitive: bool,
}

impl Config {
    fn build(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("Not enough arguments");
        }
        
        let query = args[1].clone();
        let filename = args[2].clone();
        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
        
        Ok(Config {
            query,
            filename,
            case_sensitive,
        })
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    
    let config = Config::build(&args).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {}", err);
        process::exit(1);
    });
    
    println!("Searching for '{}' in '{}'", config.query, config.filename);
}

// 구조체와 메서드 기본
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn new(width: u32, height: u32) -> Self {
        Rectangle { width, height }
    }
    
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle::new(30, 50);
    let rect2 = Rectangle::new(10, 40);
    
    println!("rect1: {:?}", rect1);
    println!("Area: {} square pixels", rect1.area());
    println!("rect1 can hold rect2: {}", rect1.can_hold(&rect2));
}

// 트레이트와 제네릭 활용
trait Summarizable {
    fn summary(&self) -> String;
    
    fn default_summary(&self) -> String {
        String::from("(Read more...)")
    }
}

struct Article {
    title: String,
    author: String,
    content: String,
}

impl Summarizable for Article {
    fn summary(&self) -> String {
        format!("{} by {}", self.title, self.author)
    }
}

fn notify<T: Summarizable>(item: &T) {
    println!("Breaking news! {}", item.summary());
}

fn main() {
    let article = Article {
        title: String::from("Rust in 2026"),
        author: String::from("Tech Writer"),
        content: String::from("Rust continues to grow..."),
    };
    
    notify(&article);
}

// 비동기 프로그래밍 예제
use tokio;

#[derive(Debug)]
struct ApiResponse {
    data: String,
    status: u16,
}

async fn fetch_data(url: &str) -> Result<ApiResponse, Box<dyn std::error::Error>> {
    // 실제 HTTP 요청 시뮬레이션
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    
    Ok(ApiResponse {
        data: format!("Response from {}", url),
        status: 200,
    })
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let urls = vec![
        "https://api.example.com/users",
        "https://api.example.com/posts",
        "https://api.example.com/comments",
    ];
    
    let futures: Vec<_> = urls.iter().map(|url| fetch_data(url)).collect();
    let results = futures::future::join_all(futures).await;
    
    for result in results {
        match result {
            Ok(response) => println!("{:?}", response),
            Err(e) => eprintln!("Error: {}", e),
        }
    }
    
    Ok(())
}