// 高レベルなイテレータチェーン
let sum: i32 = (0..1000)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .sum();
 
// コンパイラはこれを手書きのループと同等の機械語に最適化する
// LLVM の最適化パスにより、中間的なイテレータオブジェクトは完全に消去される

// null の代わりに Option を使う
fn find_user(id: u64) -> Option<User> {
    // None を返すことで「見つからなかった」を安全に表現
    if id == 0 { return None; }
    Some(User { id, name: "example".to_string() })
}
 
// 呼び出し側は None のケースを必ず処理する必要がある
match find_user(42) {
    Some(user) => println!("見つかった: {}", user.name),
    None => println!("ユーザーが見つかりません"),
}

// unsafe ブロックでは以下の操作が許可される:
// 1. 生ポインタのデリファレンス
// 2. unsafe な関数・メソッドの呼び出し
// 3. 可変なスタティック変数へのアクセス
// 4. unsafe トレイトの実装
// 5. union のフィールドアクセス
 
fn raw_pointer_example() {
    let mut num = 5;
    let r1 = &num as *const i32;     // 生ポインタ（不変）
    let r2 = &mut num as *mut i32;   // 生ポインタ（可変）
 
    unsafe {
        println!("r1 = {}", *r1);
        *r2 = 10;
        println!("r2 = {}", *r2);
    }
}

fn main() {
    println!("Hello, World!");
}

fn main() {
    let x = 5;          // デフォルトで不変
    // x = 6;           // コンパイルエラー！
    let mut y = 10;     // mut で可変宣言
    y += 1;
    println!("x={}, y={}", x, y);
 
    // シャドウイング: 同じ名前で新しい変数を束縛
    let x = x + 1;      // 新しい x（型を変えることも可能）
    let x = x * 2;
    println!("シャドウイング後の x = {}", x); // 12
 
    // シャドウイングでは型を変更できる
    let spaces = "   ";           // &str 型
    let spaces = spaces.len();    // usize 型に変更
    println!("スペース数: {}", spaces);
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;        // s1 の所有権が s2 にムーブ
    // println!("{}", s1); // コンパイルエラー: s1 は無効
    println!("{}", s2);
}

fn add(a: i32, b: i32) -> i32 {
    a + b   // セミコロンなし = 式として返却
}
 
fn main() {
    let result = add(3, 4);
    println!("3 + 4 = {}", result);
}

enum Direction {
    North,
    South,
    East,
    West,
}
 
fn describe(dir: Direction) -> &'static str {
    match dir {
        Direction::North => "北",
        Direction::South => "南",
        Direction::East  => "東",
        Direction::West  => "西",
    }
}
 
fn main() {
    println!("{}", describe(Direction::North));
}

struct Point {
    x: f64,
    y: f64,
}
 
impl Point {
    // 関連関数（コンストラクタの慣例）
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
 
    // メソッド（&self を受け取る）
    fn distance(&self, other: &Point) -> f64 {
        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
    }
 
    // 原点からの距離
    fn magnitude(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
 
    // 可変メソッド（&mut self を受け取る）
    fn translate(&mut self, dx: f64, dy: f64) {
        self.x += dx;
        self.y += dy;
    }
}
 
fn main() {
    let a = Point::new(0.0, 0.0);
    let b = Point::new(3.0, 4.0);
    println!("距離: {}", a.distance(&b)); // 5.0
    println!("bの大きさ: {}", b.magnitude()); // 5.0
 
    let mut c = Point::new(1.0, 1.0);
    c.translate(2.0, 3.0);
    println!("移動後: ({}, {})", c.x, c.y); // (3.0, 4.0)
}

fn main() {
    // if 式（Rustでは if は式として値を返す）
    let number = 7;
    let kind = if number % 2 == 0 { "偶数" } else { "奇数" };
    println!("{} は {}", number, kind);
 
    // loop（無限ループ、break で値を返せる）
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2; // 20 が result に束縛される
        }
    };
    println!("loop の結果: {}", result);
 
    // while ループ
    let mut n = 5;
    while n > 0 {
        println!("{}!", n);
        n -= 1;
    }
    println!("発射！");
 
    // for ループ（Range）
    for i in 1..=5 {
        print!("{} ", i); // 1 2 3 4 5
    }
    println!();
 
    // for ループ（コレクション）
    let fruits = vec!["りんご", "みかん", "バナナ"];
    for (i, fruit) in fruits.iter().enumerate() {
        println!("{}: {}", i, fruit);
    }
 
    // while let（パターンマッチングと組み合わせ）
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("ポップ: {}", top);
    }
}

fn main() {
    // クロージャ（無名関数）
    let add = |a: i32, b: i32| -> i32 { a + b };
    println!("3 + 4 = {}", add(3, 4));
 
    // 型推論でより簡潔に
    let multiply = |a, b| a * b;
    println!("3 * 4 = {}", multiply(3, 4));
 
    // 環境のキャプチャ
    let offset = 10;
    let add_offset = |x| x + offset;
    println!("5 + 10 = {}", add_offset(5));
 
    // イテレータとの組み合わせ
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter()
        .filter(|&&x| x > 2)
        .map(|&x| x * x)
        .sum();
    println!("2より大きい数の二乗和: {}", sum); // 9 + 16 + 25 = 50
}

trait Printable {
    fn format_string(&self) -> String;
 
    // デフォルト実装
    fn print(&self) {
        println!("{}", self.format_string());
    }
}
 
struct Article {
    title: String,
    content: String,
}
 
impl Printable for Article {
    fn format_string(&self) -> String {
        format!("【記事】{}\n{}", self.title, self.content)
    }
}
 
struct Tweet {
    user: String,
    message: String,
}
 
impl Printable for Tweet {
    fn format_string(&self) -> String {
        format!("@{}: {}", self.user, self.message)
    }
}
 
// トレイト境界を使った関数
fn display_item(item: &impl Printable) {
    item.print();
}
 
fn main() {
    let article = Article {
        title: "Rust入門".to_string(),
        content: "Rustは素晴らしい言語です".to_string(),
    };
    let tweet = Tweet {
        user: "rustlang".to_string(),
        message: "Rust 1.0 released!".to_string(),
    };
 
    display_item(&article);
    display_item(&tweet);
}

use std::fs;
use std::io;
 
fn read_username_from_file() -> Result<String, io::Error> {
    let content = fs::read_to_string("username.txt")?;
    Ok(content.trim().to_string())
}
 
fn main() {
    match read_username_from_file() {
        Ok(name) => println!("ユーザー名: {}", name),
        Err(e) => eprintln!("エラー: {}", e),
    }
 
    // Option の活用例
    let numbers = vec![10, 20, 30];
    let first = numbers.first();
    match first {
        Some(n) => println!("最初の要素: {}", n),
        None => println!("空のベクタ"),
    }
 
    // if let による簡潔なパターンマッチ
    if let Some(n) = numbers.get(1) {
        println!("2番目の要素: {}", n);
    }
}

// src/lib.rs
pub mod config;       // config.rs を読み込む
pub mod utils;        // utils/mod.rs を読み込む
 
// src/utils/mod.rs
pub mod parser;       // utils/parser.rs を読み込む
pub mod formatter;    // utils/formatter.rs を読み込む
 
// src/main.rs
use my_project::config::Config;
use my_project::utils::parser::parse;
 
fn main() {
    let config = Config::load("settings.toml").unwrap();
    let data = parse(&config.input_file).unwrap();
    println!("パース完了: {} 件", data.len());
}

# プロジェクト作成
cargo new my_project          # バイナリプロジェクト
cargo new my_lib --lib        # ライブラリプロジェクト
cargo init                    # 既存ディレクトリで初期化
 
# ビルドと実行
cargo build                   # デバッグビルド
cargo build --release         # リリースビルド（最適化あり）
cargo run                     # ビルドして実行
cargo run --release           # リリースモードで実行
cargo run -- arg1 arg2        # 引数付き実行
 
# テスト
cargo test                    # 全テスト実行
cargo test test_name          # 特定テスト実行
cargo test -- --nocapture     # println! を表示
cargo test --doc              # ドキュメントテストのみ
 
# 品質ツール
cargo clippy                  # 静的解析
cargo fmt                     # コードフォーマット
cargo doc --open              # ドキュメント生成・表示
cargo audit                   # セキュリティ監査（要インストール）
 
# 依存関係
cargo add serde               # 依存関係追加（cargo-edit）
cargo update                  # 依存関係更新
cargo tree                    # 依存関係ツリー表示
 
# その他
cargo bench                   # ベンチマーク実行
cargo clean                   # ビルド成果物を削除
cargo check                   # コンパイルチェック（バイナリ生成なし・高速）

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
authors = ["Your Name <you@example.com>"]
description = "A useful project"
license = "MIT"
repository = "https://github.com/user/my_project"
 
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"
clap = { version = "4", features = ["derive"] }
 
[dev-dependencies]
criterion = "0.5"
mockall = "0.12"
 
[profile.release]
opt-level = 3      # 最大最適化
lto = true          # リンク時最適化
codegen-units = 1   # コード生成ユニット数（遅いがより最適化）
strip = true        # デバッグシンボル除去
 
[profile.dev]
opt-level = 0       # 最適化なし（ビルド高速）
debug = true        # デバッグ情報あり

// BAD: 所有権エラーを全て clone で回避
fn process(data: Vec<String>) {
    let copy = data.clone(); // 不必要なヒープアロケーション
    for item in data.clone() {
        println!("{}", item);
    }
}
 
// GOOD: 参照を活用する
fn process_good(data: &[String]) {
    for item in data {
        println!("{}", item);
    }
}

// BAD: 本番コードで unwrap は危険
fn read_config() -> String {
    std::fs::read_to_string("config.toml").unwrap() // パニック！
}
 
// GOOD: Result を適切に伝播
fn read_config_good() -> Result<String, std::io::Error> {
    std::fs::read_to_string("config.toml")
}

// BAD: 引数に String を要求する
fn greet(name: String) {
    println!("こんにちは、{}さん", name);
}
 
// GOOD: &str を受け取れば String も &str も渡せる
fn greet_good(name: &str) {
    println!("こんにちは、{}さん", name);
}
 
fn main() {
    let owned = String::from("太郎");
    let borrowed = "花子";
 
    greet_good(&owned);    // String → &str (自動 Deref)
    greet_good(borrowed);  // &str そのまま
}

// BAD: match のネストが深い
fn process_data(input: Option<Result<String, io::Error>>) {
    match input {
        Some(result) => {
            match result {
                Ok(data) => {
                    match data.parse::<i32>() {
                        Ok(num) => println!("{}", num),
                        Err(e) => eprintln!("パースエラー: {}", e),
                    }
                }
                Err(e) => eprintln!("IOエラー: {}", e),
            }
        }
        None => eprintln!("入力なし"),
    }
}
 
// GOOD: 早期リターンやコンビネータで平坦化
fn process_data_good(input: Option<Result<String, io::Error>>) -> Result<(), Box<dyn std::error::Error>> {
    let data = input.ok_or("入力なし")?;
    let text = data?;
    let num: i32 = text.parse()?;
    println!("{}", num);
    Ok(())
}

// BAD: インデックスベースのループ
fn sum_vec(v: &[i32]) -> i32 {
    let mut sum = 0;
    for i in 0..v.len() {
        sum += v[i]; // 毎回境界チェックが走る
    }
    sum
}
 
// GOOD: イテレータを使う
fn sum_vec_good(v: &[i32]) -> i32 {
    v.iter().sum()
}

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
 
pub fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("ゼロ除算エラー".to_string())
    } else {
        Ok(a / b)
    }
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-1, 1), 0);
        assert_eq!(add(0, 0), 0);
    }
 
    #[test]
    fn test_divide_success() {
        let result = divide(10.0, 2.0);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), 5.0);
    }
 
    #[test]
    fn test_divide_by_zero() {
        let result = divide(10.0, 0.0);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "ゼロ除算エラー");
    }
 
    #[test]
    #[should_panic(expected = "index out of bounds")]
    fn test_out_of_bounds() {
        let v = vec![1, 2, 3];
        let _ = v[10]; // パニック！
    }
 
    #[test]
    fn test_with_result() -> Result<(), String> {
        let result = divide(10.0, 2.0)?;
        assert_eq!(result, 5.0);
        Ok(())
    }
}

/// 2つの数値を加算する。
///
/// # 引数
///
/// * `a` - 最初の数値
/// * `b` - 2番目の数値
///
/// # 戻り値
///
/// 2つの数値の合計
///
/// # 例
///
/// ```
/// use my_crate::add;
/// assert_eq!(add(2, 3), 5);
/// assert_eq!(add(-1, 1), 0);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]

// Axum を使ったシンプルな Web サーバー
use axum::{routing::get, Router};
 
async fn hello() -> &'static str {
    "Hello, World!"
}
 
#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(hello));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

// ビルダーパターン
struct ServerConfig {
    host: String,
    port: u16,
    max_connections: u32,
    timeout_ms: u64,
}
 
struct ServerConfigBuilder {
    host: String,
    port: u16,
    max_connections: u32,
    timeout_ms: u64,
}
 
impl ServerConfigBuilder {
    fn new() -> Self {
        Self {
            host: "localhost".to_string(),
            port: 8080,
            max_connections: 100,
            timeout_ms: 30000,
        }
    }
 
    fn host(mut self, host: &str) -> Self {
        self.host = host.to_string();
        self
    }
 
    fn port(mut self, port: u16) -> Self {
        self.port = port;
        self
    }
 
    fn max_connections(mut self, max: u32) -> Self {
        self.max_connections = max;
        self
    }
 
    fn timeout_ms(mut self, timeout: u64) -> Self {
        self.timeout_ms = timeout;
        self
    }
 
    fn build(self) -> ServerConfig {
        ServerConfig {
            host: self.host,
            port: self.port,
            max_connections: self.max_connections,
            timeout_ms: self.timeout_ms,
        }
    }
}
 
fn main() {
    let config = ServerConfigBuilder::new()
        .host("0.0.0.0")
        .port(3000)
        .max_connections(1000)
        .build();
 
    println!("サーバー: {}:{}", config.host, config.port);
}

// ニュータイプパターン
struct Email(String);
struct UserId(u64);
 
impl Email {
    fn new(email: &str) -> Result<Self, String> {
        if email.contains('@') {
            Ok(Email(email.to_string()))
        } else {
            Err("無効なメールアドレス".to_string())
        }
    }
 
    fn as_str(&self) -> &str {
        &self.0
    }
}
 
fn send_email(to: &Email, subject: &str) {
    println!("送信先: {}, 件名: {}", to.as_str(), subject);
}
 
fn main() {
    let email = Email::new("user@example.com").unwrap();
    send_email(&email, "テスト");
    // send_email(&"invalid", "テスト"); // コンパイルエラー！型が違う
}