// Rust: 局所型推論
fn calculate_total(items: Vec<f64>) -> f64 {
    let subtotal = items.iter().sum::<f64>();  // f64 と推論
    let tax_rate = 0.1;                        // f64 と推論
    let tax = subtotal * tax_rate;             // f64 と推論
    subtotal + tax                             // 戻り値型は明示
}

// Kotlin: 局所型推論 + スマートキャスト
fun processInput(input: Any): String {
    val result = when (input) {          // String と推論
        is Int -> "整数: ${input * 2}"   // スマートキャスト: Any -> Int
        is String -> "文字列: ${input.uppercase()}"
        is List<*> -> "リスト: ${input.size}件"
        else -> "不明な型"
    }
    return result
}

// TypeScript: Flow Analysis ベースの型推論
function processData(data: unknown) {
    if (typeof data === "string") {
        // この時点で data は string に絞り込まれる
        console.log(data.toUpperCase());
    } else if (Array.isArray(data)) {
        // この時点で data は any[] に絞り込まれる
        console.log(data.length);
    }
}
 
// 複雑な推論
const transform = <T, U>(arr: T[], fn: (item: T) => U) => arr.map(fn);
const result = transform([1, 2, 3], x => x.toString());
// result の型: string[] と推論される

// Go: 限定的型推論（短縮変数宣言）
func processOrder() {
    price := 100.0          // float64 と推論
    quantity := 3            // int と推論
    total := price * float64(quantity)  // float64 と推論
 
    // 構造体リテラルも推論される
    order := struct {
        Total    float64
        Currency string
    }{total, "JPY"}
 
    fmt.Println(order)
}

// Swift: 双方向型推論
let numbers = [1, 2, 3, 4, 5]          // [Int] と推論
let doubled = numbers.map { $0 * 2 }    // [Int] と推論
 
// ジェネリクスと組み合わせた推論
func findFirst<T: Comparable>(_ array: [T], where predicate: (T) -> Bool) -> T? {
    array.first(where: predicate)
}
 
let firstEven = findFirst(numbers) { $0 % 2 == 0 }  // Int? と推論

// Rust: Option<T> 型
fn find_user(id: u64) -> Option<User> {
    let db = get_database();
    db.users.get(&id).cloned()
}
 
fn get_user_email(id: u64) -> String {
    // パターンマッチによる安全な分岐
    match find_user(id) {
        Some(user) => user.email,
        None => String::from("unknown@example.com"),
    }
 
    // メソッドチェーンによる簡潔な記述
    // find_user(id)
    //     .map(|u| u.email)
    //     .unwrap_or_else(|| String::from("unknown@example.com"))
}
 
// ? 演算子による早期リターン
fn process_order(user_id: u64, item_id: u64) -> Option<Receipt> {
    let user = find_user(user_id)?;        // None なら即 return None
    let item = find_item(item_id)?;        // None なら即 return None
    let payment = process_payment(&user)?;  // None なら即 return None
    Some(Receipt::new(user, item, payment))
}

// Kotlin: Nullable型 (?記法)
fun processUserProfile(userId: Long): String {
    val user: User? = findUser(userId)
 
    // 安全呼び出し演算子 ?.
    val nameLength: Int? = user?.name?.length
 
    // エルビス演算子 ?:
    val displayName: String = user?.name ?: "Anonymous"
 
    // スマートキャスト（nullチェック後は自動的にNon-null扱い）
    if (user != null) {
        // ここでは user は User 型（User? ではない）
        println("Welcome, ${user.name}")
    }
 
    // let スコープ関数との組み合わせ
    return user?.let { u ->
        "${u.name} (${u.email})"
    } ?: "ユーザーが見つかりません"
}

// Swift: Optional型
func fetchAndDisplayUser(id: Int) -> String {
    guard let user = findUser(id: id) else {
        return "ユーザーが見つかりません"
    }
    // guard let 以降、user は非Optional として使用可能
 
    // Optional chaining
    let city: String? = user.address?.city
 
    // nil合体演算子
    let displayCity = city ?? "未設定"
 
    // if let による安全なアンラップ
    if let email = user.email {
        sendNotification(to: email)
    }
 
    return "\(user.name) - \(displayCity)"
}

// TypeScript: strictNullChecks
function processConfig(config: Config | undefined): Result {
    // Optional chaining
    const timeout = config?.network?.timeout ?? 3000;
 
    // 型ガード
    if (config === undefined) {
        return { status: "error", message: "設定がありません" };
    }
    // 以降 config は Config 型に絞り込まれる
 
    // Non-null assertion（使用は最小限に）
    // const value = config!.value;  // 危険: 実行時エラーの可能性
 
    return { status: "ok", data: applyConfig(config) };
}

// --- 様々なパターンの種類 ---
 
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { base: f64, height: f64 },
    Polygon { sides: Vec<f64> },
}
 
fn describe_shape(shape: &Shape) -> String {
    match shape {
        // 構造体パターン + リテラルパターン
        Shape::Circle { radius } if *radius == 0.0 => {
            "点（半径ゼロの円）".to_string()
        }
 
        // 構造体パターン + ガード節
        Shape::Circle { radius } if *radius > 100.0 => {
            format!("巨大な円（半径: {:.1}）", radius)
        }
 
        // 構造体パターン + 変数束縛
        Shape::Circle { radius } => {
            format!("円（半径: {:.1}, 面積: {:.1}）", radius, std::f64::consts::PI * radius * radius)
        }
 
        // 複数フィールドの分解
        Shape::Rectangle { width, height } if (width - height).abs() < f64::EPSILON => {
            format!("正方形（辺: {:.1}）", width)
        }
 
        Shape::Rectangle { width, height } => {
            format!("長方形（{:.1} x {:.1}）", width, height)
        }
 
        // ネストしたパターン
        Shape::Triangle { base, height } => {
            format!("三角形（面積: {:.1}）", base * height / 2.0)
        }
 
        // ワイルドカードパターン
        Shape::Polygon { sides } if sides.is_empty() => {
            "無効な多角形".to_string()
        }
 
        Shape::Polygon { sides } => {
            format!("{}角形", sides.len())
        }
    }
}
 
// --- タプルパターン ---
fn classify_point(x: i32, y: i32) -> &'static str {
    match (x.signum(), y.signum()) {
        (1, 1)   => "第1象限",
        (-1, 1)  => "第2象限",
        (-1, -1) => "第3象限",
        (1, -1)  => "第4象限",
        (0, 0)   => "原点",
        (0, _)   => "Y軸上",
        (_, 0)   => "X軸上",
        _         => unreachable!(),
    }
}
 
// --- OR パターン ---
fn is_weekend(day: &str) -> bool {
    matches!(day, "Saturday" | "Sunday")
}

// Rust: Zero-cost async/await
use tokio;
 
#[derive(Debug)]
struct User { name: String, email: String }
#[derive(Debug)]
struct Order { id: u64, amount: f64 }
 
async fn fetch_user(id: u64) -> Result<User, Box<dyn std::error::Error>> {
    // HTTP リクエストのシミュレーション
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    Ok(User { name: "田中".into(), email: "tanaka@example.com".into() })
}
 
async fn fetch_orders(user: &User) -> Result<Vec<Order>, Box<dyn std::error::Error>> {
    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
    Ok(vec![
        Order { id: 1, amount: 1500.0 },
        Order { id: 2, amount: 3200.0 },
    ])
}
 
// 構造化並行性: 複数の非同期タスクを同時実行
async fn dashboard(user_id: u64) -> Result<(), Box<dyn std::error::Error>> {
    let user = fetch_user(user_id).await?;
 
    // join! で並行実行
    let (orders, notifications) = tokio::join!(
        fetch_orders(&user),
        fetch_notifications(&user),
    );
 
    println!("ユーザー: {:?}", user);
    println!("注文数: {}", orders?.len());
    Ok(())
}

# Python: asyncio ベースの async/await
import asyncio
from dataclasses import dataclass
 
@dataclass
class User:
    name: str
    email: str
 
@dataclass
class Order:
    id: int
    amount: float
 
async def fetch_user(user_id: int) -> User:
    await asyncio.sleep(0.1)  # I/O シミュレーション
    return User(name="田中", email="tanaka@example.com")
 
async def fetch_orders(user: User) -> list[Order]:
    await asyncio.sleep(0.05)
    return [Order(id=1, amount=1500.0), Order(id=2, amount=3200.0)]
 
async def fetch_notifications(user: User) -> list[str]:
    await asyncio.sleep(0.08)
    return ["新着メッセージ", "セール情報"]
 
# 構造化並行性: TaskGroup (Python 3.11+)
async def dashboard(user_id: int):
    user = await fetch_user(user_id)
 
    # gather で並行実行
    orders, notifications = await asyncio.gather(
        fetch_orders(user),
        fetch_notifications(user),
    )
 
    print(f"ユーザー: {user.name}")
    print(f"注文数: {len(orders)}")
    print(f"通知数: {len(notifications)}")
 
asyncio.run(dashboard(1))

// TypeScript: Promise ベースの async/await
interface User {
    name: string;
    email: string;
}
 
interface Order {
    id: number;
    amount: number;
}
 
async function fetchUser(id: number): Promise<User> {
    const response = await fetch(`/api/users/${id}`);
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return response.json();
}
 
async function fetchOrders(user: User): Promise<Order[]> {
    const response = await fetch(`/api/orders?email=${user.email}`);
    return response.json();
}
 
// 構造化並行性: Promise.all / Promise.allSettled
async function dashboard(userId: number): Promise<void> {
    const user = await fetchUser(userId);
 
    // Promise.allSettled: 一部失敗しても全結果を取得
    const [ordersResult, notificationsResult] = await Promise.allSettled([
        fetchOrders(user),
        fetchNotifications(user),
    ]);
 
    if (ordersResult.status === "fulfilled") {
        console.log(`注文数: ${ordersResult.value.length}`);
    }
}

// --- ECサイトの注文状態をADTで厳密にモデリング ---
 
// 直和型: 注文の状態を完全に列挙
enum OrderStatus {
    // 各バリアントが異なるデータを持てる
    Pending {
        created_at: DateTime<Utc>,
    },
    Confirmed {
        confirmed_at: DateTime<Utc>,
        estimated_delivery: DateTime<Utc>,
    },
    Shipped {
        shipped_at: DateTime<Utc>,
        tracking_number: String,
        carrier: Carrier,
    },
    Delivered {
        delivered_at: DateTime<Utc>,
        signed_by: Option<String>,
    },
    Cancelled {
        cancelled_at: DateTime<Utc>,
        reason: CancellationReason,
        refund_amount: Option<Money>,
    },
}
 
// 直和型: キャンセル理由
enum CancellationReason {
    CustomerRequest,
    OutOfStock,
    PaymentFailed,
    FraudDetected,
}
 
// 直和型: 配送業者
enum Carrier {
    YamatoTransport,
    SagawaExpress,
    JapanPost,
}
 
// 直積型: 金額（通貨付き）
struct Money {
    amount: u64,      // セント/円単位
    currency: Currency,
}
 
enum Currency { JPY, USD, EUR }
 
// パターンマッチとADTの組み合わせ
fn get_order_summary(status: &OrderStatus) -> String {
    match status {
        OrderStatus::Pending { created_at } => {
            format!("注文受付中（{}）", created_at.format("%Y/%m/%d"))
        }
        OrderStatus::Confirmed { estimated_delivery, .. } => {
            format!("確認済み - 配達予定: {}", estimated_delivery.format("%m/%d"))
        }
        OrderStatus::Shipped { tracking_number, carrier, .. } => {
            let carrier_name = match carrier {
                Carrier::YamatoTransport => "ヤマト運輸",
                Carrier::SagawaExpress => "佐川急便",
                Carrier::JapanPost => "日本郵便",
            };
            format!("配送中 [{}] 追跡: {}", carrier_name, tracking_number)
        }
        OrderStatus::Delivered { signed_by, .. } => {
            match signed_by {
                Some(name) => format!("配達完了（受取人: {}）", name),
                None => "配達完了（置き配）".to_string(),
            }
        }
        OrderStatus::Cancelled { reason, refund_amount, .. } => {
            let reason_text = match reason {
                CancellationReason::CustomerRequest => "お客様のご要望",
                CancellationReason::OutOfStock => "在庫切れ",
                CancellationReason::PaymentFailed => "決済エラー",
                CancellationReason::FraudDetected => "不正検知",
            };
            match refund_amount {
                Some(money) => format!("キャンセル済み（理由: {}, 返金: {}円）", reason_text, money.amount),
                None => format!("キャンセル済み（理由: {}）", reason_text),
            }
        }
    }
}

fn demonstrate_closure_capture() {
    let data = vec![1, 2, 3];
 
    // Fn: 不変参照で捕捉（共有借用）
    let print_data = || {
        println!("データ: {:?}", data);  // &data
    };
    print_data();
    print_data(); // 複数回呼べる
 
    // FnMut: 可変参照で捕捉（排他借用）
    let mut count = 0;
    let mut increment = || {
        count += 1;  // &mut count
        println!("カウント: {}", count);
    };
    increment();
    increment();
 
    // FnOnce: 所有権を移動して捕捉
    let name = String::from("Rust");
    let consume = move || {
        println!("消費: {}", name);  // name の所有権を移動
        drop(name);                  // 所有権を消費
    };
    consume();
    // consume(); // エラー: 既に消費済み
}

// Rust: Result<T, E>
use std::fs;
use std::io;
use std::num::ParseIntError;
 
#[derive(Debug)]
enum AppError {
    IoError(io::Error),
    ParseError(ParseIntError),
    ValidationError(String),
}
 
impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self { AppError::IoError(e) }
}
impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self { AppError::ParseError(e) }
}
 
fn read_config_value(path: &str, key: &str) -> Result<i32, AppError> {
    let content = fs::read_to_string(path)?;   // io::Error → AppError
    let line = content
        .lines()
        .find(|l| l.starts_with(key))
        .ok_or_else(|| AppError::ValidationError(
            format!("キー '{}' が見つかりません", key)
        ))?;
    let value: i32 = line
        .split('=')
        .nth(1)
        .ok_or_else(|| AppError::ValidationError("不正な形式".into()))?
        .trim()
        .parse()?;   // ParseIntError → AppError
    Ok(value)
}

// Kotlin: sealed class による Result 相当
sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Failure(val error: AppError) : Result<Nothing>()
 
    fun <R> map(transform: (T) -> R): Result<R> = when (this) {
        is Success -> Success(transform(value))
        is Failure -> this
    }
 
    fun <R> flatMap(transform: (T) -> Result<R>): Result<R> = when (this) {
        is Success -> transform(value)
        is Failure -> this
    }
}
 
// kotlin.Result も標準で用意されている
fun readConfigValue(path: String, key: String): Result<Int> {
    return try {
        val content = java.io.File(path).readText()
        val line = content.lines().find { it.startsWith(key) }
            ?: return Result.Failure(AppError.NotFound("キー '$key' が見つかりません"))
        val value = line.split("=")[1].trim().toInt()
        Result.Success(value)
    } catch (e: Exception) {
        Result.Failure(AppError.IoError(e.message ?: "不明なエラー"))
    }
}

// --- 悪い例: 過度にメソッドチェーンを連結 ---
fn bad_example(data: &[Order]) -> HashMap<String, Vec<(String, f64)>> {
    data.iter()
        .filter(|o| o.status != OrderStatus::Cancelled)
        .filter(|o| o.created_at > Utc::now() - Duration::days(30))
        .map(|o| (o.category.clone(), o.items.clone()))
        .flat_map(|(cat, items)| items.into_iter().map(move |i| (cat.clone(), i)))
        .map(|(cat, item)| (cat, (item.name, item.price * (1.0 - item.discount))))
        .fold(HashMap::new(), |mut acc, (cat, item)| {
            acc.entry(cat).or_insert_with(Vec::new).push(item);
            acc
        })
}
 
// --- 良い例: 意味のある中間変数を使う ---
fn good_example(data: &[Order]) -> HashMap<String, Vec<(String, f64)>> {
    let thirty_days_ago = Utc::now() - Duration::days(30);
 
    let active_orders: Vec<&Order> = data.iter()
        .filter(|o| o.status != OrderStatus::Cancelled)
        .filter(|o| o.created_at > thirty_days_ago)
        .collect();
 
    let mut result: HashMap<String, Vec<(String, f64)>> = HashMap::new();
 
    for order in active_orders {
        for item in &order.items {
            let discounted_price = item.price * (1.0 - item.discount);
            result
                .entry(order.category.clone())
                .or_insert_with(Vec::new)
                .push((item.name.clone(), discounted_price));
        }
    }
 
    result
}

// --- 悪い例: unwrap() の乱用 ---
fn bad_process(config_path: &str) -> String {
    let content = std::fs::read_to_string(config_path).unwrap();  // パニック！
    let config: Config = serde_json::from_str(&content).unwrap(); // パニック！
    let db_url = config.database.unwrap().url.unwrap();           // パニック！
    let conn = Database::connect(&db_url).unwrap();               // パニック！
    conn.query("SELECT 1").unwrap().to_string()                   // パニック！
}
 
// --- 良い例: 適切なエラーハンドリング ---
fn good_process(config_path: &str) -> Result<String, AppError> {
    let content = std::fs::read_to_string(config_path)
        .map_err(|e| AppError::Io(format!("設定ファイル読み込み失敗: {}", e)))?;
 
    let config: Config = serde_json::from_str(&content)
        .map_err(|e| AppError::Parse(format!("JSON パース失敗: {}", e)))?;
 
    let db_url = config.database
        .as_ref()
        .and_then(|db| db.url.as_ref())
        .ok_or_else(|| AppError::Config("DB URLが設定されていません".into()))?;
 
    let conn = Database::connect(db_url)
        .map_err(|e| AppError::Database(format!("DB接続失敗: {}", e)))?;
 
    conn.query("SELECT 1")
        .map(|r| r.to_string())
        .map_err(|e| AppError::Database(format!("クエリ失敗: {}", e)))
}

// --- 悪い例: 型注釈が一切ない ---
const process = (data) =>
    data.filter(x => x.active).map(x => ({
        ...x,
        score: x.points * (x.bonus ? 1.5 : 1.0)
    })).sort((a, b) => b.score - a.score);
 
// --- 良い例: 関数境界に型注釈を付ける ---
interface User {
    name: string;
    active: boolean;
    points: number;
    bonus: boolean;
}
 
interface ScoredUser extends User {
    score: number;
}
 
const process = (data: User[]): ScoredUser[] =>
    data
        .filter(x => x.active)
        .map(x => ({
            ...x,
            score: x.points * (x.bonus ? 1.5 : 1.0)
        }))
        .sort((a, b) => b.score - a.score);

function getCity(user: any): string {
    return user.address.city.toUpperCase();
}