// C++: OOP の実用的な例（RAII パターン）
 
#include <iostream>
#include <fstream>
#include <string>
#include <memory>
#include <vector>
 
// RAII: リソースの獲得は初期化時に、解放はデストラクタで
class FileHandle {
private:
    std::fstream file;
    std::string filename;
 
public:
    // コンストラクタでファイルを開く（リソース獲得）
    explicit FileHandle(const std::string& fname)
        : filename(fname) {
        file.open(fname, std::ios::in | std::ios::out);
        if (!file.is_open()) {
            throw std::runtime_error("ファイルを開けません: " + fname);
        }
        std::cout << "ファイルを開きました: " << fname << std::endl;
    }
 
    // デストラクタでファイルを閉じる（リソース解放）
    ~FileHandle() {
        if (file.is_open()) {
            file.close();
            std::cout << "ファイルを閉じました: " << filename << std::endl;
        }
    }
 
    // コピー禁止（リソースの二重解放を防ぐ）
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
 
    // ムーブは許可（所有権の移転）
    FileHandle(FileHandle&& other) noexcept
        : file(std::move(other.file)), filename(std::move(other.filename)) {}
 
    void write(const std::string& data) {
        file << data;
    }
 
    std::string readAll() {
        file.seekg(0);
        return std::string(
            std::istreambuf_iterator<char>(file),
            std::istreambuf_iterator<char>()
        );
    }
};
 
// スマートポインタ: RAII のメモリ管理版
class ResourceManager {
public:
    // unique_ptr: 排他的所有権
    std::unique_ptr<FileHandle> openFile(const std::string& filename) {
        return std::make_unique<FileHandle>(filename);
    }
 
    // shared_ptr: 共有所有権（参照カウント）
    std::shared_ptr<std::vector<int>> createSharedData() {
        return std::make_shared<std::vector<int>>();
    }
};
 
// C++ のテンプレート: コンパイル時のポリモーフィズム
template<typename Shape>
double calculateArea(const Shape& shape) {
    return shape.area(); // コンパイル時にメソッド解決
}
 
class Circle {
    double radius;
public:
    explicit Circle(double r) : radius(r) {}
    double area() const { return 3.14159 * radius * radius; }
};
 
class Rectangle {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const { return width * height; }
};
 
// テンプレートは仮想関数なしでポリモーフィズムを実現
// → ゼロオーバーヘッド（仮想関数テーブルの間接呼び出しなし）

// Java: エンタープライズパターンの進化
 
// === Java 1.0 時代（1995）: 基本的なOOP ===
public class Employee {
    private String name;
    private double salary;
 
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
 
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
 
    @Override
    public String toString() {
        return "Employee{name='" + name + "', salary=" + salary + "}";
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Double.compare(employee.salary, salary) == 0
            && Objects.equals(name, employee.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, salary);
    }
}
// → ボイラープレートの山（getter/setter/equals/hashCode/toString）
 
 
// === Java 5 時代（2004）: ジェネリクス + アノテーション ===
public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    List<T> findAll();
    T save(T entity);
    void deleteById(ID id);
}
 
public class EmployeeRepository implements Repository<Employee, Long> {
    private final Map<Long, Employee> store = new HashMap<>();
 
    @Override
    public Optional<Employee> findById(Long id) {
        return Optional.ofNullable(store.get(id));
    }
 
    @Override
    public List<Employee> findAll() {
        return new ArrayList<>(store.values());
    }
 
    @Override
    public Employee save(Employee employee) {
        store.put(employee.getId(), employee);
        return employee;
    }
 
    @Override
    public void deleteById(Long id) {
        store.remove(id);
    }
}
 
 
// === Java 8 時代（2014）: ラムダ + Stream API ===
public class EmployeeService {
    private final Repository<Employee, Long> repository;
 
    public EmployeeService(Repository<Employee, Long> repository) {
        this.repository = repository;
    }
 
    // Stream API: 関数型プログラミングの要素
    public List<Employee> getHighPaidEmployees(double threshold) {
        return repository.findAll().stream()
            .filter(e -> e.getSalary() > threshold)
            .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
            .collect(Collectors.toList());
    }
 
    public Map<String, Double> getAverageSalaryByDepartment() {
        return repository.findAll().stream()
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.averagingDouble(Employee::getSalary)
            ));
    }
 
    public Optional<Employee> findHighestPaid() {
        return repository.findAll().stream()
            .max(Comparator.comparingDouble(Employee::getSalary));
    }
}
 
 
// === Java 17+ 時代（2021-）: Record + Sealed + Pattern Matching ===
 
// Record: ボイラープレート削減（不変データクラス）
public record EmployeeRecord(
    long id,
    String name,
    String department,
    double salary
) {
    // コンパクトコンストラクタでバリデーション
    public EmployeeRecord {
        if (salary < 0) throw new IllegalArgumentException("給与は正の数");
        if (name == null || name.isBlank()) throw new IllegalArgumentException("名前は必須");
    }
}
 
// Sealed class: 代数的データ型
public sealed interface PaymentMethod
    permits CreditCard, BankTransfer, DigitalWallet {
}
 
public record CreditCard(String number, String expiry) implements PaymentMethod {}
public record BankTransfer(String accountNumber, String bankCode) implements PaymentMethod {}
public record DigitalWallet(String walletId, String provider) implements PaymentMethod {}
 
// Pattern Matching: switch式で型安全な分岐
public String processPayment(PaymentMethod method, double amount) {
    return switch (method) {
        case CreditCard cc -> "クレジットカード %s で %.0f円決済".formatted(
            cc.number().substring(cc.number().length() - 4), amount);
        case BankTransfer bt -> "銀行振込 %s へ %.0f円送金".formatted(
            bt.bankCode(), amount);
        case DigitalWallet dw -> "%s ウォレット %s で %.0f円決済".formatted(
            dw.provider(), dw.walletId(), amount);
    };
}

# Ruby: 純粋OOP + メタプログラミング
 
# 全てがオブジェクト
42.class          # => Integer
42.even?          # => true
"hello".reverse   # => "olleh"
nil.class         # => NilClass
true.class        # => TrueClass
 
# Mixin（多重継承の代替）
module Serializable
  def to_json
    require 'json'
    hash = {}
    instance_variables.each do |var|
      hash[var.to_s.delete('@')] = instance_variable_get(var)
    end
    JSON.generate(hash)
  end
end
 
module Auditable
  def self.included(base)
    base.instance_variable_set(:@audit_log, [])
  end
 
  def log_change(message)
    self.class.instance_variable_get(:@audit_log) << {
      timestamp: Time.now,
      object_id: object_id,
      message: message
    }
  end
end
 
class User
  include Serializable
  include Auditable
 
  attr_reader :name, :email
 
  def initialize(name, email)
    @name = name
    @email = email
    log_change("User created: #{name}")
  end
 
  def update_email(new_email)
    old = @email
    @email = new_email
    log_change("Email changed: #{old} -> #{new_email}")
  end
end
 
# Open class: 既存クラスの拡張
class String
  def palindrome?
    self == self.reverse
  end
end
 
"racecar".palindrome?  # => true
"hello".palindrome?    # => false
 
# メタプログラミング: 動的なメソッド定義
class ActiveRecordLike
  def self.has_attribute(name, type: :string, default: nil)
    # getter
    define_method(name) do
      instance_variable_get("@#{name}") || default
    end
 
    # setter
    define_method("#{name}=") do |value|
      instance_variable_set("@#{name}", value)
    end
 
    # クエリメソッド
    define_method("#{name}?") do
      !send(name).nil? && send(name) != "" && send(name) != false
    end
  end
end
 
class Product < ActiveRecordLike
  has_attribute :name, type: :string
  has_attribute :price, type: :float, default: 0
  has_attribute :in_stock, type: :boolean, default: true
end
 
p = Product.new
p.name = "Ruby本"
p.price = 3000
p.name?      # => true
p.in_stock?  # => true

# Python: モダンなOOPの実践
 
from __future__ import annotations
from dataclasses import dataclass, field
from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable
from functools import total_ordering
from datetime import datetime
 
 
# データクラス: ボイラープレートの自動生成
@dataclass(frozen=True)  # frozen=True で不変に
@total_ordering
class Money:
    """金額値オブジェクト"""
    amount: int
    currency: str = "JPY"
 
    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("金額は0以上である必要があります")
 
    def __add__(self, other: Money) -> Money:
        if self.currency != other.currency:
            raise ValueError(f"通貨が異なります: {self.currency} vs {other.currency}")
        return Money(self.amount + other.amount, self.currency)
 
    def __sub__(self, other: Money) -> Money:
        if self.currency != other.currency:
            raise ValueError(f"通貨が異なります: {self.currency} vs {other.currency}")
        return Money(self.amount - other.amount, self.currency)
 
    def __mul__(self, factor: int | float) -> Money:
        return Money(int(self.amount * factor), self.currency)
 
    def __lt__(self, other: Money) -> bool:
        if self.currency != other.currency:
            raise ValueError("通貨が異なります")
        return self.amount < other.amount
 
    def __str__(self) -> str:
        if self.currency == "JPY":
            return f"¥{self.amount:,}"
        return f"{self.amount / 100:.2f} {self.currency}"
 
 
# プロトコル: 構造的型付け（ダックタイピングの型安全版）
@runtime_checkable
class Discountable(Protocol):
    """割引適用可能なもの"""
    def apply_discount(self, rate: float) -> Money: ...
    @property
    def price(self) -> Money: ...
 
 
# 抽象基底クラス
class Product(ABC):
    """商品の抽象基底クラス"""
 
    def __init__(self, name: str, base_price: Money):
        self._name = name
        self._base_price = base_price
 
    @property
    def name(self) -> str:
        return self._name
 
    @property
    def price(self) -> Money:
        return self._base_price
 
    @abstractmethod
    def description(self) -> str:
        """商品の説明を返す"""
        pass
 
    def apply_discount(self, rate: float) -> Money:
        """割引後の価格を計算"""
        if not 0 <= rate <= 1:
            raise ValueError("割引率は0〜1の範囲")
        return self._base_price * (1 - rate)
 
 
# 具象クラス
@dataclass
class Book(Product):
    """書籍"""
    _name: str = field(init=False)
    _base_price: Money = field(init=False)
    author: str = ""
    isbn: str = ""
    pages: int = 0
 
    def __init__(self, name: str, price: Money, author: str, isbn: str = "", pages: int = 0):
        super().__init__(name, price)
        self.author = author
        self.isbn = isbn
        self.pages = pages
 
    def description(self) -> str:
        return f"『{self.name}』{self.author}著 ({self.pages}ページ)"
 
 
@dataclass
class Electronics(Product):
    """電子機器"""
    _name: str = field(init=False)
    _base_price: Money = field(init=False)
    brand: str = ""
    warranty_months: int = 12
 
    def __init__(self, name: str, price: Money, brand: str, warranty_months: int = 12):
        super().__init__(name, price)
        self.brand = brand
        self.warranty_months = warranty_months
 
    def description(self) -> str:
        return f"{self.brand} {self.name} (保証: {self.warranty_months}ヶ月)"
 
 
# デコレータパターン
class DiscountedProduct:
    """割引適用済み商品（デコレータ）"""
 
    def __init__(self, product: Product, discount_rate: float, reason: str = ""):
        self._product = product
        self._discount_rate = discount_rate
        self._reason = reason
 
    @property
    def name(self) -> str:
        return f"{self._product.name} [{self._reason}]" if self._reason else self._product.name
 
    @property
    def price(self) -> Money:
        return self._product.apply_discount(self._discount_rate)
 
    @property
    def original_price(self) -> Money:
        return self._product.price
 
    def description(self) -> str:
        return f"{self._product.description()} - {self._discount_rate*100:.0f}%OFF"
 
 
# コンテキストマネージャ: Pythonらしいリソース管理
class DatabaseConnection:
    """データベース接続（コンテキストマネージャ）"""
 
    def __init__(self, connection_string: str):
        self._connection_string = connection_string
        self._connected = False
 
    def __enter__(self):
        print(f"DB接続開始: {self._connection_string}")
        self._connected = True
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self._connected:
            print("DB接続終了")
            self._connected = False
        return False  # 例外を再送出
 
    def query(self, sql: str) -> list[dict]:
        if not self._connected:
            raise RuntimeError("接続されていません")
        print(f"SQL実行: {sql}")
        return []
 
 
# 使用例
with DatabaseConnection("postgresql://localhost/mydb") as db:
    results = db.query("SELECT * FROM users")
# → __exit__ が自動的に呼ばれる（例外発生時も）

// TypeScript: 継承からコンポジションへの進化
 
// === 1990s スタイル: 深い継承階層 ===
// 問題だらけのアプローチ
 
/*
abstract class Animal {
  abstract speak(): string;
}
 
class Mammal extends Animal {
  breathe(): string { return "肺で呼吸"; }
  abstract speak(): string;
}
 
class Pet extends Mammal {
  constructor(public owner: string) { super(); }
  abstract speak(): string;
}
 
class Dog extends Pet {
  speak(): string { return "ワン！"; }
}
 
class Cat extends Pet {
  speak(): string { return "ニャー！"; }
}
 
// 問題: ペンギンは鳥だが飛べない → 継承階層が破綻
// 問題: 新しい振る舞いの追加が困難
// 問題: テストのための差し替えが困難
*/
 
 
// === 2020s スタイル: コンポジション + インターフェース ===
 
// 振る舞いをインターフェースで定義
interface CanSpeak {
  speak(): string;
}
 
interface CanMove {
  move(): string;
}
 
interface CanSwim {
  swim(): string;
}
 
interface CanFly {
  fly(): string;
}
 
// コンポジションで組み合わせ
class DogComposed implements CanSpeak, CanMove, CanSwim {
  constructor(
    public readonly name: string,
    public readonly owner: string,
  ) {}
 
  speak(): string { return `${this.name}: ワン！`; }
  move(): string { return `${this.name}が走る`; }
  swim(): string { return `${this.name}が泳ぐ`; }
}
 
class PenguinComposed implements CanSpeak, CanMove, CanSwim {
  constructor(public readonly name: string) {}
 
  speak(): string { return `${this.name}: ペンペン！`; }
  move(): string { return `${this.name}がよちよち歩く`; }
  swim(): string { return `${this.name}が高速で泳ぐ`; }
  // fly() は実装しない → コンパイル時に飛べないことが保証される
}
 
class EagleComposed implements CanSpeak, CanMove, CanFly {
  constructor(public readonly name: string) {}
 
  speak(): string { return `${this.name}: ピーッ！`; }
  move(): string { return `${this.name}が飛び回る`; }
  fly(): string { return `${this.name}が大空を飛ぶ`; }
  // swim() は実装しない → 泳げないことが型で表現される
}
 
// 必要なインターフェースだけを要求
function makeSwimRace(swimmers: CanSwim[]): void {
  for (const s of swimmers) {
    console.log(s.swim());
  }
}
 
// Dog と Penguin は泳げるが、Eagle は泳げない
// → コンパイル時にエラーで検出
makeSwimRace([
  new DogComposed("ポチ", "田中"),
  new PenguinComposed("ペンタ"),
  // new EagleComposed("タカ"),  // コンパイルエラー: CanSwim を実装していない
]);

// TypeScript: 構造的型付けの実践例
 
// インターフェースを明示的に実装しなくても型互換
interface Printable {
  toString(): string;
}
 
interface HasLength {
  length: number;
}
 
// クラスでも使える
class Document implements Printable {
  constructor(private content: string) {}
  toString(): string { return this.content; }
}
 
// プレーンオブジェクトでも OK（構造が一致すれば）
const logEntry = {
  toString(): string { return "2024-01-01 INFO: Application started"; }
};
 
// 配列は HasLength を満たす
const items = [1, 2, 3]; // { length: number } を持つ
 
function print(item: Printable): void {
  console.log(item.toString());
}
 
function getLength(item: HasLength): number {
  return item.length;
}
 
print(new Document("Hello"));   // OK
print(logEntry);                 // OK: 構造が一致
getLength(items);               // OK: length プロパティがある
getLength("hello");             // OK: string も length を持つ

// Kotlin: モダンOOPの例
// データクラス（ボイラープレート削減）
data class User(
    val name: String,
    val email: String,
    val age: Int
)
 
// sealed class（代数的データ型 — FPからの影響）
sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Failure(val error: Throwable) : Result<Nothing>()
}
 
// 拡張関数（オブジェクトを変更せずに機能追加）
fun String.isValidEmail(): Boolean =
    this.matches(Regex("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$"))
 
// 高階関数（FPの要素）
fun <T> List<T>.filterAndMap(
    predicate: (T) -> Boolean,
    transform: (T) -> String
): List<String> = this.filter(predicate).map(transform)

// Swift: プロトコル指向プログラミング
protocol Drawable {
    func draw()
}
 
protocol Resizable {
    func resize(by factor: Double)
}
 
// プロトコル拡張（デフォルト実装）
extension Drawable {
    func draw() {
        print("Default drawing")
    }
}
 
// 値型（struct）+ プロトコル準拠
struct Circle: Drawable, Resizable {
    var radius: Double
 
    func draw() {
        print("Drawing circle with radius \(radius)")
    }
 
    func resize(by factor: Double) -> Circle {
        Circle(radius: radius * factor)
    }
}

// Kotlin: モダンOOPの包括的な例
 
// === Null安全 ===
fun processUser(name: String?) {
    // コンパイラが null チェックを強制
    val length = name?.length ?: 0
    val upper = name?.uppercase() ?: "UNKNOWN"
 
    // スマートキャスト
    if (name != null) {
        // この分岐内では name は String（非null）
        println(name.length)
    }
}
 
// === Sealed class + When 式（網羅的パターンマッチ） ===
sealed interface Shape {
    data class Circle(val radius: Double) : Shape
    data class Rectangle(val width: Double, val height: Double) : Shape
    data class Triangle(val base: Double, val height: Double) : Shape
}
 
fun area(shape: Shape): Double = when (shape) {
    is Shape.Circle -> Math.PI * shape.radius * shape.radius
    is Shape.Rectangle -> shape.width * shape.height
    is Shape.Triangle -> shape.base * shape.height / 2
    // when 式は網羅的: 新しい Shape を追加するとコンパイルエラー
}
 
// === 委譲パターン（by キーワード） ===
interface Logger {
    fun log(message: String)
}
 
class ConsoleLogger : Logger {
    override fun log(message: String) = println("[LOG] $message")
}
 
class UserService(logger: Logger) : Logger by logger {
    // Logger の実装を ConsoleLogger に委譲
    // log() メソッドを明示的に実装する必要なし
 
    fun createUser(name: String) {
        log("Creating user: $name")  // 委譲されたメソッド
        // ... ユーザー作成ロジック
    }
}
 
// === コルーチン（非同期プログラミング） ===
import kotlinx.coroutines.*
 
class OrderProcessor {
    suspend fun processOrder(orderId: String): Result<Order> {
        return try {
            val order = fetchOrder(orderId)      // 非同期DB取得
            val validated = validateOrder(order)  // バリデーション
            val charged = chargePayment(validated) // 非同期決済
            Result.success(charged)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
 
    private suspend fun fetchOrder(id: String): Order = withContext(Dispatchers.IO) {
        // DB からの取得（非同期）
        delay(100) // シミュレーション
        Order(id, "pending")
    }
 
    private fun validateOrder(order: Order): Order {
        // ビジネスルールのバリデーション
        require(order.status == "pending") { "注文は pending 状態である必要があります" }
        return order
    }
 
    private suspend fun chargePayment(order: Order): Order = withContext(Dispatchers.IO) {
        // 決済処理（非同期）
        delay(200) // シミュレーション
        order.copy(status = "confirmed")
    }
}

// Rust: トレイトベースのOOP
 
use std::fmt;
 
// トレイト: インターフェース + デフォルト実装 + 関連型
trait Animal: fmt::Display {
    fn name(&self) -> &str;
    fn sound(&self) -> &str;
 
    // デフォルト実装
    fn introduce(&self) -> String {
        format!("{}は「{}」と鳴きます", self.name(), self.sound())
    }
}
 
// 構造体 + トレイト実装
struct Dog {
    name: String,
    breed: String,
}
 
impl Animal for Dog {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> &str { "ワン" }
}
 
impl fmt::Display for Dog {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "犬「{}」({})", self.name, self.breed)
    }
}
 
struct Cat {
    name: String,
    indoor: bool,
}
 
impl Animal for Cat {
    fn name(&self) -> &str { &self.name }
    fn sound(&self) -> &str { "ニャー" }
}
 
impl fmt::Display for Cat {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let location = if self.indoor { "室内飼い" } else { "外飼い" };
        write!(f, "猫「{}」({})", self.name, location)
    }
}
 
// トレイトオブジェクト: 実行時ポリモーフィズム
fn introduce_all(animals: &[&dyn Animal]) {
    for animal in animals {
        println!("{}", animal.introduce());
    }
}
 
// ジェネリクス + トレイト境界: コンパイル時ポリモーフィズム
fn loudest_sound<T: Animal>(animals: &[T]) -> &str {
    // コンパイル時に型が確定 → 仮想関数テーブルなし → ゼロコスト
    animals.first().map(|a| a.sound()).unwrap_or("")
}
 
// 列挙型: 代数的データ型（Rust の強み）
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,
        }
    }
 
    fn perimeter(&self) -> f64 {
        match self {
            Shape::Circle { radius } => 2.0 * std::f64::consts::PI * radius,
            Shape::Rectangle { width, height } => 2.0 * (width + height),
            Shape::Triangle { base, height } => {
                let hyp = (base * base + height * height).sqrt();
                base + height + hyp
            }
        }
    }
}
 
// 所有権システム: コンパイル時のメモリ安全性保証
struct FileProcessor {
    path: String,
    content: Option<String>,
}
 
impl FileProcessor {
    fn new(path: &str) -> Self {
        FileProcessor {
            path: path.to_string(),
            content: None,
        }
    }
 
    // &self: 読み取り専用借用
    fn path(&self) -> &str {
        &self.path
    }
 
    // &mut self: 可変借用
    fn load(&mut self) -> Result<(), std::io::Error> {
        self.content = Some(std::fs::read_to_string(&self.path)?);
        Ok(())
    }
 
    // self: 所有権を消費（呼び出し後は使えない）
    fn into_content(self) -> Option<String> {
        self.content
    }
}

// Go: 構造体 + インターフェース（暗黙的実装）
package main
 
import (
    "fmt"
    "math"
    "sort"
)
 
// インターフェース: 暗黙的に実装される
type Shape interface {
    Area() float64
    Perimeter() float64
    String() string
}
 
// 構造体（クラスの代わり）
type Circle struct {
    Radius float64
}
 
// メソッド（レシーバ付き関数）
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
 
func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}
 
func (c Circle) String() string {
    return fmt.Sprintf("Circle(r=%.2f)", c.Radius)
}
 
type Rectangle struct {
    Width, Height float64
}
 
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
 
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}
 
func (r Rectangle) String() string {
    return fmt.Sprintf("Rect(%.2fx%.2f)", r.Width, r.Height)
}
 
// 埋め込み（Embedding）: 継承の代替
type NamedShape struct {
    Shape // Shape インターフェースを埋め込み
    Name  string
}
 
func (ns NamedShape) Describe() string {
    return fmt.Sprintf("%s: area=%.2f", ns.Name, ns.Area())
}
 
// インターフェースの合成
type ReadWriter interface {
    Reader
    Writer
}
 
type Reader interface {
    Read(p []byte) (n int, err error)
}
 
type Writer interface {
    Write(p []byte) (n int, err error)
}
 
// 関数型: 小さなインターフェースを多用
type SortByArea []Shape
 
func (s SortByArea) Len() int           { return len(s) }
func (s SortByArea) Less(i, j int) bool { return s[i].Area() < s[j].Area() }
func (s SortByArea) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 
func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 3, Height: 4},
        Circle{Radius: 2},
        Rectangle{Width: 10, Height: 1},
    }
 
    sort.Sort(SortByArea(shapes))
 
    for _, s := range shapes {
        fmt.Printf("%s -> Area: %.2f\n", s, s.Area())
    }
}

// TypeScript: Result型によるエラー処理（FP的アプローチ）
 
type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };
 
function ok<T>(value: T): Result<T, never> {
  return { ok: true, value };
}
 
function err<E>(error: E): Result<never, E> {
  return { ok: false, error };
}
 
// 副作用を明示的に型で表現
class UserService {
  constructor(
    private readonly db: Database,
    private readonly mailer: Mailer,
  ) {}
 
  // 戻り値の型が「成功 or 失敗」を明示
  async createUser(
    name: string,
    email: string,
  ): Promise<Result<User, CreateUserError>> {
    // バリデーション（純粋関数）
    const validationResult = this.validateInput(name, email);
    if (!validationResult.ok) return validationResult;
 
    // DB操作（副作用）
    const existingUser = await this.db.findUserByEmail(email);
    if (existingUser) {
      return err({ type: "DUPLICATE_EMAIL", email });
    }
 
    const user = await this.db.createUser({ name, email });
 
    // メール送信（副作用）
    const mailResult = await this.mailer.sendWelcome(user);
    if (!mailResult.ok) {
      // メール失敗はログに記録するが、ユーザー作成は成功
      console.warn("Welcome email failed:", mailResult.error);
    }
 
    return ok(user);
  }
 
  private validateInput(
    name: string,
    email: string,
  ): Result<void, CreateUserError> {
    if (!name.trim()) return err({ type: "INVALID_NAME", name });
    if (!email.includes("@")) return err({ type: "INVALID_EMAIL", email });
    return ok(undefined);
  }
}
 
type CreateUserError =
  | { type: "INVALID_NAME"; name: string }
  | { type: "INVALID_EMAIL"; email: string }
  | { type: "DUPLICATE_EMAIL"; email: string }
  | { type: "DATABASE_ERROR"; cause: Error };

// TypeScript: React Hooks スタイル（クラスなしのOOP的設計）
 
// 状態管理のカプセル化（クラスを使わず）
function useCounter(initialValue: number = 0) {
  let count = initialValue;
 
  return {
    get value() { return count; },
    increment() { count++; },
    decrement() { count--; },
    reset() { count = initialValue; },
  };
}
 
// ビジネスロジックのカプセル化
function useShoppingCart() {
  const items: Map<string, { name: string; price: number; qty: number }> = new Map();
 
  return {
    addItem(id: string, name: string, price: number) {
      const existing = items.get(id);
      if (existing) {
        existing.qty++;
      } else {
        items.set(id, { name, price, qty: 1 });
      }
    },
 
    removeItem(id: string) {
      items.delete(id);
    },
 
    get total() {
      let sum = 0;
      for (const item of items.values()) {
        sum += item.price * item.qty;
      }
      return sum;
    },
 
    get itemCount() {
      let count = 0;
      for (const item of items.values()) {
        count += item.qty;
      }
      return count;
    },
 
    get isEmpty() {
      return items.size === 0;
    },
  };
}
 
// コンポジション: 複数の機能を組み合わせ
function useCheckout() {
  const cart = useShoppingCart();
  const step = useCounter(1);
 
  return {
    cart,
    step,
 
    get canProceed() {
      if (step.value === 1) return !cart.isEmpty;
      if (step.value === 2) return true; // 配送先入力済み
      return false;
    },
 
    nextStep() {
      if (this.canProceed && step.value < 3) {
        step.increment();
      }
    },
 
    previousStep() {
      if (step.value > 1) {
        step.decrement();
      }
    },
  };
}
 
// → クラスを使わずに、OOP の利点（カプセル化、コンポジション）を実現
// → 関数がオブジェクト（クロージャ）を返すパターン
// → テスト容易（モック不要、純粋関数的）

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