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(())
}