Thinkful vs Bloc：2026年にRustを学ぶためのブートキャンプ比較と独学ガイド

// Rustの所有権システムの基本例
fn main() {
    let original = String::from("Hello, Rust!");
    let moved = original; // 所有権が移動
    // println!("{}", original); // コンパイルエラー
    println!("{}", moved); // 正常に動作
}

// Thinkfulカリキュラムで学ぶエラーハンドリング
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.toml") {
        Ok(contents) => println!("ファイル内容: {}", contents),
        Err(e) => eprintln!("エラー: {}", e),
    }
}

// Blocのプロジェクトで構築するCLIツールの例
use std::env;
use std::process;

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

impl Config {
    fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("引数が不足しています");
        }
        let query = args[1].clone();
        let filename = args[2].clone();
        Ok(Config { query, filename })
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let config = Config::new(&args).unwrap_or_else(|err| {
        eprintln!("引数解析エラー: {}", err);
        process::exit(1);
    });
    println!("検索: {} in {}", config.query, config.filename);
}

// 非同期プログラミングの例
use tokio;

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(async {
        println!("タスク1開始");
        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
        println!("タスク1完了");
    });

    let task2 = tokio::spawn(async {
        println!("タスク2開始");
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
        println!("タスク2完了");
    });

    let _ = tokio::join!(task1, task2);
}

// 基礎段階で理解すべき構造体とメソッド
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.area());
    println!("rect1はrect2を含める: {}", rect1.can_hold(&rect2));
}

// ジェネリクスとトレイトの実践
trait Summary {
    fn summarize(&self) -> String;
}

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

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

fn notify<T: Summary>(item: &T) {
    println!("速報: {}", item.summarize());
}

// Actix-webを使用したシンプルなWebサーバー
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn health_check() -> impl Responder {
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "version": "1.0.0"
    }))
}

async fn greet(name: web::Path<String>) -> impl Responder {
    HttpResponse::Ok().body(format!("こんにちは、{}さん!", name))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/health", web::get().to(health_check))
            .route("/greet/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

// 面接でよく問われるライフタイムの理解
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("長い文字列");
    let result;
    {
        let string2 = String::from("短い");
        result = longest(string1.as_str(), string2.as_str());
        println!("最長: {}", result);
    }
}