#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
// C: 手動メモリ管理 — malloc/free の対で管理
typedef struct {
    char* name;
    int age;
    char** tags;
    int tag_count;
} User;
 
User* user_create(const char* name, int age) {
    User* user = (User*)malloc(sizeof(User));
    if (!user) return NULL;  // メモリ確保失敗
 
    user->name = strdup(name);  // 文字列のコピーを確保
    if (!user->name) {
        free(user);
        return NULL;
    }
 
    user->age = age;
    user->tags = NULL;
    user->tag_count = 0;
    return user;
}
 
int user_add_tag(User* user, const char* tag) {
    // realloc で配列を拡張
    char** new_tags = (char**)realloc(
        user->tags,
        sizeof(char*) * (user->tag_count + 1)
    );
    if (!new_tags) return -1;  // メモリ確保失敗
 
    user->tags = new_tags;
    user->tags[user->tag_count] = strdup(tag);
    if (!user->tags[user->tag_count]) return -1;
 
    user->tag_count++;
    return 0;
}
 
void user_destroy(User* user) {
    if (!user) return;
 
    free(user->name);
    for (int i = 0; i < user->tag_count; i++) {
        free(user->tags[i]);
    }
    free(user->tags);
    free(user);
}
 
// 使用例
void example(void) {
    User* alice = user_create("Alice", 30);
    if (!alice) {
        fprintf(stderr, "メモリ確保失敗\n");
        return;
    }
 
    user_add_tag(alice, "admin");
    user_add_tag(alice, "developer");
 
    printf("Name: %s, Age: %d\n", alice->name, alice->age);
 
    user_destroy(alice);  // 必ず解放する（忘れるとメモリリーク）
    // alice = NULL;      // ダングリングポインタ防止（推奨）
}
 
// 典型的なCのバグ: Use After Free
void dangerous_example(void) {
    char* name = strdup("Alice");
    free(name);
    // printf("%s\n", name);  // 未定義動作！ 解放後のメモリにアクセス
}
 
// 典型的なCのバグ: バッファオーバーフロー
void buffer_overflow(void) {
    char buf[10];
    // strcpy(buf, "This is a very long string");  // 危険！
    strncpy(buf, "This is a very long string", sizeof(buf) - 1);  // 安全
    buf[sizeof(buf) - 1] = '\0';
}
 
// 典型的なCのバグ: ダブルフリー
void double_free_example(void) {
    char* ptr = malloc(100);
    free(ptr);
    // free(ptr);  // 未定義動作！ 二重解放
}

#include <string>
#include <memory>
#include <vector>
#include <iostream>
#include <optional>
 
// C++: RAII (Resource Acquisition Is Initialization)
// コンストラクタで獲得、デストラクタで解放
 
class User {
public:
    User(std::string name, int age)
        : name_(std::move(name)), age_(age) {}
 
    // デストラクタ — スコープを抜けると自動呼び出し
    ~User() {
        std::cout << "User " << name_ << " destroyed" << std::endl;
    }
 
    void add_tag(std::string tag) {
        tags_.push_back(std::move(tag));
    }
 
    const std::string& name() const { return name_; }
    int age() const { return age_; }
    const std::vector<std::string>& tags() const { return tags_; }
 
private:
    std::string name_;      // std::string が内部メモリを管理
    int age_;
    std::vector<std::string> tags_;  // vector が配列メモリを管理
};
 
// スマートポインタの使い分け
void smart_pointer_example() {
    // unique_ptr: 唯一の所有権（最も一般的）
    auto alice = std::make_unique<User>("Alice", 30);
    alice->add_tag("admin");
 
    // 所有権の移動（ムーブ）
    auto owner = std::move(alice);
    // alice はもう使えない（nullptr）
 
    // shared_ptr: 共有所有権（参照カウント）
    auto bob = std::make_shared<User>("Bob", 25);
    {
        auto bob_ref = bob;  // 参照カウント +1
        std::cout << "ref count: " << bob.use_count() << std::endl;  // 2
    }
    // bob_ref がスコープを抜けて参照カウント -1
    std::cout << "ref count: " << bob.use_count() << std::endl;  // 1
 
    // weak_ptr: 循環参照の防止
    std::weak_ptr<User> weak = bob;
    if (auto locked = weak.lock()) {
        std::cout << "User still alive: " << locked->name() << std::endl;
    }
}
 
// ムーブセマンティクス（C++11以降）
class LargeBuffer {
    std::vector<uint8_t> data_;
 
public:
    explicit LargeBuffer(size_t size) : data_(size, 0) {}
 
    // ムーブコンストラクタ — データの所有権を移動（コピーなし）
    LargeBuffer(LargeBuffer&& other) noexcept
        : data_(std::move(other.data_)) {}
 
    // ムーブ代入演算子
    LargeBuffer& operator=(LargeBuffer&& other) noexcept {
        data_ = std::move(other.data_);
        return *this;
    }
 
    // コピーを禁止（大きいデータの意図しないコピーを防ぐ）
    LargeBuffer(const LargeBuffer&) = delete;
    LargeBuffer& operator=(const LargeBuffer&) = delete;
 
    size_t size() const { return data_.size(); }
};
 
// std::optional で null を型安全に扱う
std::optional<User> find_user(const std::string& name) {
    if (name == "Alice") {
        return User("Alice", 30);
    }
    return std::nullopt;
}
 
void optional_example() {
    auto user = find_user("Alice");
    if (user.has_value()) {
        std::cout << user->name() << std::endl;
    }
 
    // value_or でデフォルト値
    auto name = find_user("Bob")
        .transform( { return u.name(); })
        .value_or("Unknown");
}
 
// コンセプト（C++20）— テンプレートの型制約
template<typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::same_as<std::ostream&>;
};
 
template<Printable T>
void print(const T& value) {
    std::cout << value << std::endl;
}
 
// Ranges（C++20）— 関数型スタイルのデータ処理
#include <ranges>
#include <algorithm>
 
void ranges_example() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    auto result = numbers
        | std::views::filter( { return n % 2 == 0; })
        | std::views::transform( { return n * n; })
        | std::views::take(3);
 
    for (int n : result) {
        std::cout << n << " ";  // 4 16 36
    }
}

use std::collections::HashMap;
 
// Rust: 所有権システム — コンパイル時にメモリ安全性を保証
// 3つのルール:
// 1. 各値は1つの所有者を持つ
// 2. 所有者がスコープを離れると値は破棄される
// 3. &T（不変借用）は複数可、&mut T（可変借用）は1つだけ
 
struct User {
    name: String,
    age: u32,
    tags: Vec<String>,
}
 
impl User {
    fn new(name: impl Into<String>, age: u32) -> Self {
        User {
            name: name.into(),
            age,
            tags: Vec::new(),
        }
    }
 
    fn add_tag(&mut self, tag: impl Into<String>) {
        self.tags.push(tag.into());
    }
 
    // &self: 不変借用（読み取りのみ）
    fn display(&self) -> String {
        format!("{} (age: {}, tags: {:?})", self.name, self.age, self.tags)
    }
 
    // self: 所有権を消費（呼び出し後は使えない）
    fn into_name(self) -> String {
        self.name  // 所有権が移動
    }
}
 
fn ownership_example() {
    let mut alice = User::new("Alice", 30);
    alice.add_tag("admin");
    alice.add_tag("developer");
 
    // 不変借用（同時に複数可能）
    let display1 = alice.display();
    let display2 = alice.display();
    println!("{}", display1);
    println!("{}", display2);
 
    // 所有権の移動
    let name = alice.into_name();
    println!("Name: {}", name);
    // println!("{}", alice.display());  // コンパイルエラー！ aliceはもう使えない
}
 
// ライフタイム — 参照の有効期間をコンパイラに伝える
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
 
struct Config<'a> {
    name: &'a str,
    values: Vec<&'a str>,
}
 
impl<'a> Config<'a> {
    fn new(name: &'a str) -> Self {
        Config { name, values: Vec::new() }
    }
 
    fn add_value(&mut self, value: &'a str) {
        self.values.push(value);
    }
}
 
// Result/Option によるエラーハンドリング
use std::fs;
use std::io;
 
fn read_config(path: &str) -> Result<HashMap<String, String>, io::Error> {
    let content = fs::read_to_string(path)?;  // ? 演算子でエラー伝播
    let mut config = HashMap::new();
 
    for line in content.lines() {
        if let Some((key, value)) = line.split_once('=') {
            config.insert(key.trim().to_string(), value.trim().to_string());
        }
    }
 
    Ok(config)
}
 
// パターンマッチとenum（代数的データ型）
#[derive(Debug)]
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { base: f64, height: f64 },
}
 
impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
            Shape::Rectangle { width, height } => width * height,
            Shape::Triangle { base, height } => base * height / 2.0,
        }
    }
}
 
// トレイト — インターフェースとジェネリクスの基盤
trait Summary {
    fn summarize(&self) -> String;
 
    // デフォルト実装
    fn summarize_short(&self) -> String {
        format!("{}...", &self.summarize()[..20])
    }
}
 
impl Summary for User {
    fn summarize(&self) -> String {
        format!("{} ({}歳)", self.name, self.age)
    }
}
 
// トレイト境界によるジェネリクス
fn print_summary(item: &impl Summary) {
    println!("{}", item.summarize());
}
 
// where句を使った複雑な制約
fn process_items<T>(items: &[T]) -> Vec<String>
where
    T: Summary + std::fmt::Debug,
{
    items.iter()
        .map(|item| item.summarize())
        .collect()
}
 
// 並行処理 — Send/Syncトレイトでコンパイル時安全性保証
use std::sync::{Arc, Mutex};
use std::thread;
 
fn concurrent_counter() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
 
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
 
    println!("Counter: {}", *counter.lock().unwrap());  // 10
}
 
// チャネルによるメッセージパッシング
use std::sync::mpsc;
 
fn channel_example() {
    let (tx, rx) = mpsc::channel();
 
    // 送信側
    for i in 0..5 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(format!("Message {}", i)).unwrap();
        });
    }
    drop(tx);  // 元の送信者を閉じる
 
    // 受信側
    for received in rx {
        println!("Got: {}", received);
    }
}
 
// async/await（非同期処理）
use tokio;
 
#[tokio::main]
async fn main() {
    let urls = vec![
        "https://example.com",
        "https://example.org",
    ];
 
    let mut handles = vec![];
    for url in urls {
        handles.push(tokio::spawn(async move {
            let resp = reqwest::get(url).await.unwrap();
            (url.to_string(), resp.status().as_u16())
        }));
    }
 
    for handle in handles {
        let (url, status) = handle.await.unwrap();
        println!("{}: {}", url, status);
    }
}

package main
 
import (
    "context"
    "fmt"
    "log"
    "sync"
    "time"
)
 
// Go: GCによるメモリ管理 + goroutine による軽量並行処理
// 設計哲学: シンプルさ、高速コンパイル、並行処理
 
// 構造体（Go にはクラスがない）
type User struct {
    Name string
    Age  int
    Tags []string
}
 
// メソッド（レシーバ付き関数）
func (u *User) AddTag(tag string) {
    u.Tags = append(u.Tags, tag)
}
 
func (u User) Display() string {
    return fmt.Sprintf("%s (age: %d, tags: %v)", u.Name, u.Age, u.Tags)
}
 
// インターフェース — 暗黙的実装（implements 宣言不要）
type Summarizer interface {
    Summarize() string
}
 
func (u User) Summarize() string {
    return fmt.Sprintf("%s (%d歳)", u.Name, u.Age)
}
 
// User は Summarizer を暗黙的に実装
func PrintSummary(s Summarizer) {
    fmt.Println(s.Summarize())
}
 
// エラーハンドリング — 明示的な error 値の返却
type AppError struct {
    Code    int
    Message string
}
 
func (e *AppError) Error() string {
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}
 
func FindUser(name string) (*User, error) {
    if name == "" {
        return nil, &AppError{Code: 400, Message: "name is required"}
    }
    if name == "Alice" {
        return &User{Name: "Alice", Age: 30}, nil
    }
    return nil, &AppError{Code: 404, Message: "user not found"}
}
 
// errors.Is / errors.As によるエラー判定（Go 1.13+）
func example() {
    user, err := FindUser("Bob")
    if err != nil {
        var appErr *AppError
        if errors.As(err, &appErr) {
            log.Printf("App error: code=%d, msg=%s", appErr.Code, appErr.Message)
        } else {
            log.Printf("Unknown error: %v", err)
        }
        return
    }
    fmt.Println(user.Display())
}
 
// Goroutine + Channel — Go の並行処理の核
func goroutineExample() {
    ch := make(chan string, 10)  // バッファ付きチャネル
 
    urls := []string{
        "https://example.com",
        "https://example.org",
        "https://example.net",
    }
 
    for _, url := range urls {
        go func(u string) {
            // HTTPリクエストを並行実行
            result := fmt.Sprintf("Fetched: %s", u)
            ch <- result
        }(url)
    }
 
    for range urls {
        fmt.Println(<-ch)
    }
}
 
// select文 — 複数チャネルの待機
func selectExample() {
    ch1 := make(chan string)
    ch2 := make(chan string)
 
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "from ch1"
    }()
 
    go func() {
        time.Sleep(200 * time.Millisecond)
        ch2 <- "from ch2"
    }()
 
    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println(msg)
        case msg := <-ch2:
            fmt.Println(msg)
        case <-time.After(1 * time.Second):
            fmt.Println("timeout")
        }
    }
}
 
// Context によるキャンセレーション
func contextExample(ctx context.Context) error {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
 
    ch := make(chan string, 1)
    go func() {
        // 長時間処理
        time.Sleep(3 * time.Second)
        ch <- "done"
    }()
 
    select {
    case result := <-ch:
        fmt.Println(result)
        return nil
    case <-ctx.Done():
        return ctx.Err()  // context.DeadlineExceeded or context.Canceled
    }
}
 
// WaitGroup で複数 goroutine の完了を待機
func waitGroupExample() {
    var wg sync.WaitGroup
    results := make([]string, 5)
 
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            results[idx] = fmt.Sprintf("result-%d", idx)
        }(i)
    }
 
    wg.Wait()
    fmt.Println(results)
}
 
// ジェネリクス（Go 1.18+）
func MapT any, U any U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = f(v)
    }
    return result
}
 
func FilterT any bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}
 
// 型制約
type Number interface {
    ~int | ~int64 | ~float64
}
 
func SumT Number T {
    var total T
    for _, n := range numbers {
        total += n
    }
    return total
}
 
// 使用例
func genericsExample() {
    names := []string{"Alice", "Bob", "Carol"}
    upper := Map(names, strings.ToUpper)
    // → ["ALICE", "BOB", "CAROL"]
 
    numbers := []int{1, 2, 3, 4, 5, 6}
    evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
    // → [2, 4, 6]
 
    total := Sum([]int{1, 2, 3, 4, 5})
    // → 15
}

const std = @import("std");
const Allocator = std.mem.Allocator;
 
// Zig: 手動メモリ管理 + comptime（コンパイル時計算）
// 設計哲学: 隠れた制御フローなし、隠れたメモリ割り当てなし
 
// アロケータを明示的に渡す（隠れた割り当てなし）
const User = struct {
    name: []const u8,
    age: u32,
    tags: std.ArrayList([]const u8),
    allocator: Allocator,
 
    pub fn init(allocator: Allocator, name: []const u8, age: u32) User {
        return User{
            .name = name,
            .age = age,
            .tags = std.ArrayList([]const u8).init(allocator),
            .allocator = allocator,
        };
    }
 
    pub fn deinit(self: *User) void {
        self.tags.deinit();
    }
 
    pub fn addTag(self: *User, tag: []const u8) !void {
        try self.tags.append(tag);
    }
 
    pub fn display(self: User) void {
        std.debug.print("User: {s} (age: {})\n", .{ self.name, self.age });
    }
};
 
// エラーハンドリング — error union 型
const FileError = error{
    FileNotFound,
    PermissionDenied,
    OutOfMemory,
};
 
fn readConfig(path: []const u8) FileError![]const u8 {
    const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
        error.FileNotFound => return FileError.FileNotFound,
        error.AccessDenied => return FileError.PermissionDenied,
        else => return FileError.FileNotFound,
    };
    defer file.close();
 
    // ファイル読み込み
    return file.readToEndAlloc(std.heap.page_allocator, 1024 * 1024) catch {
        return FileError.OutOfMemory;
    };
}
 
// comptime — コンパイル時計算（Zigの最大の特徴）
fn fibonacci(comptime n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
 
// コンパイル時に計算されるので実行時コストゼロ
const fib_10 = fibonacci(10);  // コンパイル時に 55 と計算される
 
// comptime による型生成
fn Matrix(comptime T: type, comptime rows: usize, comptime cols: usize) type {
    return struct {
        data: [rows][cols]T,
 
        const Self = @This();
 
        pub fn init() Self {
            return Self{
                .data = [_][cols]T{[_]T{0} ** cols} ** rows,
            };
        }
 
        pub fn get(self: Self, row: usize, col: usize) T {
            return self.data[row][col];
        }
 
        pub fn set(self: *Self, row: usize, col: usize, value: T) void {
            self.data[row][col] = value;
        }
    };
}
 
// 使用例
const Mat3x3 = Matrix(f64, 3, 3);
 
pub fn main() void {
    var mat = Mat3x3.init();
    mat.set(0, 0, 1.0);
    mat.set(1, 1, 1.0);
    mat.set(2, 2, 1.0);
    // 3x3 単位行列
}
 
// defer / errdefer — リソース管理
fn processFile(path: []const u8) !void {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close();  // 関数終了時に必ず実行
 
    const buffer = try std.heap.page_allocator.alloc(u8, 4096);
    errdefer std.heap.page_allocator.free(buffer);  // エラー時のみ実行
 
    // ファイル処理...
}
 
// テスト（言語組み込み）
test "fibonacci" {
    try std.testing.expectEqual(fibonacci(0), 0);
    try std.testing.expectEqual(fibonacci(1), 1);
    try std.testing.expectEqual(fibonacci(10), 55);
}
 
test "user creation" {
    var user = User.init(std.testing.allocator, "Alice", 30);
    defer user.deinit();
 
    try user.addTag("admin");
    try std.testing.expectEqual(user.tags.items.len, 1);
}

// C: 戻り値でエラーを伝える
#include <stdio.h>
#include <errno.h>
 
int read_int_from_file(const char* path, int* result) {
    FILE* f = fopen(path, "r");
    if (!f) {
        return -1;  // エラー（errno にエラーコード）
    }
 
    if (fscanf(f, "%d", result) != 1) {
        fclose(f);
        return -2;  // パースエラー
    }
 
    fclose(f);
    return 0;  // 成功
}
 
// 呼び出し側
void caller(void) {
    int value;
    int ret = read_int_from_file("config.txt", &value);
    if (ret == -1) {
        fprintf(stderr, "ファイルが開けません: %s\n", strerror(errno));
    } else if (ret == -2) {
        fprintf(stderr, "パースエラー\n");
    } else {
        printf("値: %d\n", value);
    }
}

// C++: 例外 + std::expected (C++23)
#include <expected>
#include <fstream>
#include <string>
 
enum class ReadError {
    FileNotFound,
    ParseError,
};
 
// C++23: std::expected
std::expected<int, ReadError> read_int_from_file(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        return std::unexpected(ReadError::FileNotFound);
    }
 
    int value;
    if (!(file >> value)) {
        return std::unexpected(ReadError::ParseError);
    }
 
    return value;
}
 
// 呼び出し側
void caller() {
    auto result = read_int_from_file("config.txt");
    if (result.has_value()) {
        std::cout << "値: " << result.value() << std::endl;
    } else {
        switch (result.error()) {
            case ReadError::FileNotFound:
                std::cerr << "ファイルが見つかりません" << std::endl;
                break;
            case ReadError::ParseError:
                std::cerr << "パースエラー" << std::endl;
                break;
        }
    }
 
    // transform でチェーン
    auto doubled = read_int_from_file("config.txt")
        .transform( { return v * 2; });
}

// Rust: Result + ? 演算子
use std::fs;
use std::num::ParseIntError;
use thiserror::Error;
 
#[derive(Error, Debug)]
enum ReadError {
    #[error("ファイルが開けません: {0}")]
    FileNotFound(#[from] std::io::Error),
    #[error("パースエラー: {0}")]
    ParseError(#[from] ParseIntError),
}
 
fn read_int_from_file(path: &str) -> Result<i32, ReadError> {
    let content = fs::read_to_string(path)?;  // io::Error → ReadError
    let value: i32 = content.trim().parse()?;  // ParseIntError → ReadError
    Ok(value)
}
 
// 呼び出し側
fn caller() {
    match read_int_from_file("config.txt") {
        Ok(value) => println!("値: {}", value),
        Err(ReadError::FileNotFound(e)) => eprintln!("ファイルエラー: {}", e),
        Err(ReadError::ParseError(e)) => eprintln!("パースエラー: {}", e),
    }
 
    // map / and_then でチェーン
    let doubled = read_int_from_file("config.txt")
        .map(|v| v * 2);
}

// Go: error インターフェース
package main
 
import (
    "errors"
    "fmt"
    "os"
    "strconv"
    "strings"
)
 
type ReadError struct {
    Kind    string
    Message string
    Err     error
}
 
func (e *ReadError) Error() string {
    return fmt.Sprintf("%s: %s", e.Kind, e.Message)
}
 
func (e *ReadError) Unwrap() error {
    return e.Err
}
 
func readIntFromFile(path string) (int, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return 0, &ReadError{
            Kind:    "file_not_found",
            Message: fmt.Sprintf("ファイルが開けません: %s", path),
            Err:     err,
        }
    }
 
    value, err := strconv.Atoi(strings.TrimSpace(string(data)))
    if err != nil {
        return 0, &ReadError{
            Kind:    "parse_error",
            Message: "パースエラー",
            Err:     err,
        }
    }
 
    return value, nil
}
 
// 呼び出し側
func caller() {
    value, err := readIntFromFile("config.txt")
    if err != nil {
        var readErr *ReadError
        if errors.As(err, &readErr) {
            fmt.Printf("エラー種別: %s, メッセージ: %s\n", readErr.Kind, readErr.Message)
        } else {
            fmt.Printf("不明なエラー: %v\n", err)
        }
        return
    }
    fmt.Printf("値: %d\n", value)
}

# Rust: Cargo.toml — 依存管理の模範例
[package]
name = "my-cli-tool"
version = "0.1.0"
edition = "2021"
rust-version = "1.75"
 
[dependencies]
clap = { version = "4", features = ["derive"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
anyhow = "1"
tracing = "0.1"
 
[dev-dependencies]
assert_cmd = "2"
predicates = "3"
tempfile = "3"
 
[profile.release]
lto = true        # リンク時最適化
strip = true      # デバッグ情報除去
codegen-units = 1 # 最大最適化

// Go: go.mod — シンプルなモジュール管理
// go.mod
module github.com/user/myapp
 
go 1.22
 
require (
    github.com/gin-gonic/gin v1.9.1
    github.com/jackc/pgx/v5 v5.5.3
    go.uber.org/zap v1.27.0
)
 
// クロスコンパイル（コマンド1つ）
// GOOS=linux GOARCH=amd64 go build -o myapp-linux
// GOOS=darwin GOARCH=arm64 go build -o myapp-mac
// GOOS=windows GOARCH=amd64 go build -o myapp.exe

# 演習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()