// TypeScript: 型は関数の「契約」を表現する
 
// この型シグネチャは以下の契約を表す:
// - 呼び出し側: number型の引数を2つ渡す義務がある
// - 関数側: number型の値を返す義務がある
function divide(numerator: number, denominator: number): number {
    if (denominator === 0) {
        throw new Error("Division by zero");
    }
    return numerator / denominator;
}
 
// 契約に従った呼び出し --- コンパイル成功
const result = divide(10, 3);  // number型が返る
 
// 契約違反 --- コンパイルエラー
// const bad = divide("10", 3);
// Error: Argument of type 'string' is not assignable to parameter of type 'number'

// Java: 名目的型付け --- 型の名前（宣言）で互換性を判定
 
interface Printable {
    String format();
}
 
// Printable を明示的に implements しなければ、
// format() メソッドがあっても Printable として扱えない
class Invoice implements Printable {
    private double amount;
    private String customer;
 
    public Invoice(double amount, String customer) {
        this.amount = amount;
        this.customer = customer;
    }
 
    @Override
    public String format() {
        return String.format("Invoice: %s - $%.2f", customer, amount);
    }
}
 
class Report {
    // format() メソッドがあるが、Printable を implements していない
    public String format() {
        return "Monthly Report";
    }
}
 
public class Main {
    static void print(Printable p) {
        System.out.println(p.format());
    }
 
    public static void main(String[] args) {
        print(new Invoice(100.0, "Alice"));  // OK: Invoice は Printable
        // print(new Report());               // コンパイルエラー!
        // Report は format() を持つが、Printable を implements していない
    }
}

// Rust: 型システムと所有権システムが連携してメモリ安全性を保証
 
use std::fmt;
 
// トレイトによる型の振る舞い定義
trait Summary {
    fn summarize(&self) -> String;
 
    // デフォルト実装も可能
    fn preview(&self) -> String {
        format!("{}...", &self.summarize()[..20.min(self.summarize().len())])
    }
}
 
struct Article {
    title: String,
    author: String,
    content: String,
}
 
impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{} by {}", self.title, self.author)
    }
}
 
// ジェネリクスとトレイト境界
fn notify<T: Summary + fmt::Display>(item: &T) {
    println!("Breaking news: {}", item.summarize());
}
 
// Result型によるエラー処理 --- エラーの可能性が型で表現される
fn parse_config(path: &str) -> Result<Config, ConfigError> {
    let content = std::fs::read_to_string(path)
        .map_err(|e| ConfigError::IoError(e))?;  // ? 演算子でエラー伝播
 
    let config: Config = toml::from_str(&content)
        .map_err(|e| ConfigError::ParseError(e))?;
 
    Ok(config)
}
 
// 呼び出し側は Result を処理する義務がある
fn main() {
    match parse_config("config.toml") {
        Ok(config) => println!("Config loaded: {:?}", config),
        Err(e) => eprintln!("Failed to load config: {}", e),
    }
    // Result を無視すると #[must_use] 警告が出る
}

// Go: 構造的型付け --- 型の構造（メソッドセット）で互換性を判定
 
package main
 
import "fmt"
 
// インターフェースの定義
type Writer interface {
    Write(data []byte) (int, error)
}
 
// FileWriter は Writer インターフェースを「暗黙的に」実装
// implements キーワードは不要
type FileWriter struct {
    Path string
}
 
func (fw FileWriter) Write(data []byte) (int, error) {
    fmt.Printf("Writing %d bytes to %s\n", len(data), fw.Path)
    return len(data), nil
}
 
// ConsoleWriter も Writer インターフェースを暗黙的に実装
type ConsoleWriter struct{}
 
func (cw ConsoleWriter) Write(data []byte) (int, error) {
    fmt.Print(string(data))
    return len(data), nil
}
 
// Writer インターフェースを満たす任意の型を受け取れる
func process(w Writer, message string) {
    w.Write([]byte(message))
}
 
func main() {
    file := FileWriter{Path: "/tmp/output.txt"}
    console := ConsoleWriter{}
 
    process(file, "Hello, File!")       // OK
    process(console, "Hello, Console!") // OK
    // どちらも Write メソッドを持つため Writer として扱える
}

// TypeScript: 構造的部分型 --- プロパティの構造で互換性を判定
 
interface Point2D {
    x: number;
    y: number;
}
 
interface Point3D {
    x: number;
    y: number;
    z: number;
}
 
function distanceFromOrigin(point: Point2D): number {
    return Math.sqrt(point.x ** 2 + point.y ** 2);
}
 
const p3d: Point3D = { x: 3, y: 4, z: 5 };
 
// Point3D は Point2D の全プロパティを含むため、互換性がある
// （構造的部分型: Point3D <: Point2D）
const dist = distanceFromOrigin(p3d);  // OK: 5
 
// 型エイリアスとインターフェースの使い分け
type Result<T> =
    | { success: true; data: T }
    | { success: false; error: string };
 
function fetchUser(id: number): Result<{ name: string; email: string }> {
    if (id <= 0) {
        return { success: false, error: "Invalid ID" };
    }
    return {
        success: true,
        data: { name: "Alice", email: "alice@example.com" }
    };
}
 
// 判別共用体（Discriminated Union）による安全なパターンマッチ
const result = fetchUser(1);
if (result.success) {
    // TypeScript はここで result.data が存在することを推論
    console.log(result.data.name);
} else {
    // ここでは result.error が存在することを推論
    console.log(result.error);
}

# Python: 強い動的型付け + ダックタイピング
 
# 同一変数に異なる型の値を代入可能
x = 42         # int
x = "hello"    # str（再代入OK、型チェックなし）
x = [1, 2, 3]  # list
 
# ダックタイピングの例
class Duck:
    def quack(self):
        return "Quack!"
 
    def swim(self):
        return "Swimming..."
 
class Person:
    def quack(self):
        return "I'm quacking like a duck!"
 
    def swim(self):
        return "I'm swimming like a duck!"
 
class RubberDuck:
    def quack(self):
        return "Squeak!"
    # swim() メソッドがない
 
def perform_duck_actions(duck):
    """duck 引数が quack() と swim() を持てば動作する"""
    print(duck.quack())
    print(duck.swim())
 
perform_duck_actions(Duck())    # OK
perform_duck_actions(Person())  # OK（ダックタイピング）
# perform_duck_actions(RubberDuck())  # AttributeError: swim() がない
# ↑ この問題は実行時にしか検出できない
 
 
# 動的型付けの威力: デコレータ
import functools
import time
 
def timer(func):
    """任意の関数の実行時間を計測するデコレータ"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__}: {elapsed:.4f}s")
        return result
    return wrapper
 
@timer
def slow_function(n):
    return sum(range(n))
 
@timer
def slow_string(s, repeat):
    return s * repeat
 
# 型を問わず、あらゆる関数に適用可能
slow_function(1_000_000)
slow_string("hello", 100)

# Ruby: 全てがオブジェクト + 強い動的型付け
 
# オープンクラス: 既存クラスにメソッドを追加可能
class Integer
  def factorial
    return 1 if self <= 1
    self * (self - 1).factorial
  end
 
  def prime?
    return false if self < 2
    (2..Math.sqrt(self).to_i).none? { |i| self % i == 0 }
  end
end
 
puts 5.factorial   # => 120
puts 7.prime?      # => true
 
# method_missing によるメタプログラミング
class DynamicConfig
  def initialize(data = {})
    @data = data
  end
 
  def method_missing(name, *args)
    key = name.to_s
    if key.end_with?('=')
      @data[key.chomp('=')] = args.first
    elsif @data.key?(key)
      @data[key]
    else
      super
    end
  end
 
  def respond_to_missing?(name, include_private = false)
    @data.key?(name.to_s.chomp('=')) || super
  end
end
 
config = DynamicConfig.new
config.database = "postgresql"  # method_missing で動的にセッター呼び出し
config.port = 5432
puts config.database            # => "postgresql"
puts config.port                # => 5432

// JavaScript: プロトタイプベース + 弱い動的型付け
 
// プロトタイプチェーン
const animal = {
    type: "Animal",
    describe() {
        return `I am a ${this.type}`;
    }
};
 
const dog = Object.create(animal);
dog.type = "Dog";
dog.bark = function() { return "Woof!"; };
 
console.log(dog.describe()); // "I am a Dog" (プロトタイプのメソッドを継承)
console.log(dog.bark());     // "Woof!"
 
// 動的プロパティの追加と削除
const user = { name: "Alice" };
user.age = 30;           // プロパティの動的追加
user.greet = function() { return `Hi, I'm ${this.name}`; };
delete user.age;          // プロパティの動的削除
 
// typeof の落とし穴
console.log(typeof null);       // "object" (歴史的バグ)
console.log(typeof undefined);  // "undefined"
console.log(typeof NaN);        // "number" (NaN は number 型)
console.log(typeof []);         // "object" (配列もオブジェクト)

# Python: 強い型付け --- 暗黙的型変換をほぼ許さない
 
# 文字列 + 整数 → TypeError
try:
    result = "Age: " + 25
except TypeError as e:
    print(f"Error: {e}")
    # Error: can only concatenate str (not "int") to str
 
# 明示的な変換が必要
result = "Age: " + str(25)     # OK: "Age: 25"
result = f"Age: {25}"          # OK: f-string は内部で str() を呼ぶ
 
# 整数 + 浮動小数点 → 例外的に暗黙変換される（数値の拡大変換）
x = 1 + 2.5    # int + float → float (3.5)
# これは Python でも許容される暗黙変換（情報損失がないため）
 
# bool と int の関係（歴史的経緯）
print(True + 1)   # → 2（bool は int のサブクラス）
print(False + 1)  # → 1
# これは暗黙変換ではなく、継承関係による

// Rust: 最も厳格な型付けの一つ
 
fn main() {
    let x: i32 = 42;
    let y: i64 = 100;
 
    // let z = x + y;  // コンパイルエラー!
    // error: cannot add `i64` to `i32`
    // 整数型同士でもサイズが異なれば暗黙変換しない
 
    let z = x as i64 + y;  // 明示的キャスト必須
    let z = i64::from(x) + y;  // from トレイトによる安全な変換
 
    // 浮動小数点への変換も明示的
    let a: f64 = x as f64;  // 明示的キャスト必須
    // let b: f64 = x;      // コンパイルエラー!
}

// JavaScript: 弱い型付け --- 広範な暗黙的型変換
 
// 加算演算子 + のオーバーロード
console.log("5" + 3);       // "53"  (数値→文字列に変換して連結)
console.log("5" - 3);       // 2     (文字列→数値に変換して減算)
console.log("5" * "3");     // 15    (両方を数値に変換して乗算)
console.log("5" + + "3");   // "53"  (単項+で数値化後、文字列連結)
 
// 比較演算子の暗黙変換
console.log(0 == "");        // true  (両方を数値に変換: 0 == 0)
console.log(0 == "0");       // true  (文字列→数値: 0 == 0)
console.log("" == "0");      // false (両方文字列: "" !== "0")
console.log(false == "0");   // true  (false→0, "0"→0: 0 == 0)
console.log(null == undefined);  // true  (特別ルール)
console.log(NaN == NaN);    // false (NaN は何とも等しくない)
 
// ===（厳密等価演算子）で暗黙変換を防ぐ
console.log(0 === "");       // false (型が違うので false)
console.log(0 === "0");      // false
console.log(false === "0");  // false
 
// 論理演算子の暗黙変換
console.log([] + {});        // "[object Object]"
console.log({} + []);        // 0 (ブラウザ依存)
console.log([] + []);        // ""
console.log(!![]);           // true (空配列は truthy)
console.log(!!0);            // false (0 は falsy)

// C: 弱い型付け + 静的型付け
 
#include <stdio.h>
 
int main() {
    // 暗黙の型変換（整数の拡大変換）
    int x = 42;
    long y = x;          // int → long (暗黙拡大)
    double z = x;        // int → double (暗黙拡大)
 
    // 暗黙の型変換（データ損失の可能性あり）
    double pi = 3.14159;
    int truncated = pi;   // double → int: 3（切り捨て、警告のみ）
 
    // 暗黙のポインタ変換
    int *ip = &x;
    void *vp = ip;       // int* → void*（暗黙変換）
    char *cp = (char*)vp; // void* → char*（明示キャスト必要）
 
    // 整数とポインタの混同（危険）
    // int *bad = 0x12345678;  // 一部コンパイラで警告なしに通る
 
    // char と int の暗黙変換
    char c = 65;          // int → char: 'A'
    int ascii = 'A';      // char → int: 65
    printf("%c %d\n", c, ascii);  // A 65
 
    return 0;
}

# Python: 段階的型付けの実践
 
# === Phase 1: 型注釈なし（従来の動的型付け）===
def calculate_total(items, tax_rate):
    subtotal = sum(item['price'] * item['quantity'] for item in items)
    return subtotal * (1 + tax_rate)
 
 
# === Phase 2: 基本的な型注釈を追加 ===
from typing import TypedDict
 
class Item(TypedDict):
    name: str
    price: float
    quantity: int
 
def calculate_total(items: list[Item], tax_rate: float) -> float:
    subtotal = sum(item['price'] * item['quantity'] for item in items)
    return subtotal * (1 + tax_rate)
 
 
# === Phase 3: より厳密な型定義 ===
from typing import TypedDict, NewType
from decimal import Decimal
 
Price = NewType('Price', Decimal)   # 価格専用の型
TaxRate = NewType('TaxRate', Decimal)  # 税率専用の型
 
class StrictItem(TypedDict):
    name: str
    price: Price
    quantity: int
 
def calculate_total_strict(
    items: list[StrictItem],
    tax_rate: TaxRate
) -> Decimal:
    subtotal = sum(
        item['price'] * item['quantity']
        for item in items
    )
    return subtotal * (1 + tax_rate)
 
# NewType により Price と TaxRate を混同するとmypyがエラーを報告
# price = Price(Decimal("100.00"))
# rate = TaxRate(Decimal("0.10"))
# bad = price + rate  # mypy error: Price と TaxRate は直接加算不可
 
 
# === 高度な型ヒント機能 ===
from typing import (
    Generic, TypeVar, Protocol, overload,
    Literal, Union, Optional
)
 
# ジェネリクス
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')
 
class Cache(Generic[K, V]):
    """型安全なキャッシュ"""
    def __init__(self, max_size: int = 100) -> None:
        self._data: dict[K, V] = {}
        self._max_size = max_size
 
    def get(self, key: K) -> Optional[V]:
        return self._data.get(key)
 
    def set(self, key: K, value: V) -> None:
        if len(self._data) >= self._max_size:
            oldest = next(iter(self._data))
            del self._data[oldest]
        self._data[key] = value
 
# 使用時に型パラメータが推論される
cache: Cache[str, int] = Cache(max_size=50)
cache.set("count", 42)    # OK
# cache.set("count", "42")  # mypy error: str は int に代入不可
 
# Protocol（構造的部分型）
class Renderable(Protocol):
    def render(self) -> str: ...
 
class HtmlElement:
    def render(self) -> str:
        return "<div>Hello</div>"
 
class MarkdownText:
    def render(self) -> str:
        return "**Hello**"
 
def display(item: Renderable) -> None:
    print(item.render())
 
# HtmlElement も MarkdownText も render() を持つため Renderable として扱える
# Protocol は「ダックタイピングを型で表現する」仕組み
display(HtmlElement())    # OK
display(MarkdownText())   # OK

// TypeScript: JavaScript からの段階的移行戦略
 
// === Step 1: .js → .ts にリネーム + allowJs ===
// tsconfig.json:
// {
//   "compilerOptions": {
//     "allowJs": true,
//     "checkJs": false,
//     "strict": false,
//     "outDir": "./dist"
//   }
// }
 
// === Step 2: any を使って型エラーを一時的に回避 ===
// 移行初期: 型が不明な箇所に any を使う
function processLegacyData(data: any): any {
    return data.items.map((item: any) => item.value);
}
 
// === Step 3: any を unknown に置き換え ===
// unknown は any より安全（型ガードが必須）
function processData(data: unknown): string[] {
    if (
        typeof data === "object" &&
        data !== null &&
        "items" in data &&
        Array.isArray((data as { items: unknown[] }).items)
    ) {
        const items = (data as { items: Array<{ value: string }> }).items;
        return items.map(item => item.value);
    }
    throw new Error("Invalid data format");
}
 
// === Step 4: 適切な型定義を作成 ===
interface DataItem {
    id: number;
    value: string;
    metadata?: Record<string, unknown>;
}
 
interface DataPayload {
    items: DataItem[];
    total: number;
    page: number;
}
 
function processTypedData(data: DataPayload): string[] {
    return data.items.map(item => item.value);
}
 
// === Step 5: strict モードを有効化 ===
// tsconfig.json:
// {
//   "compilerOptions": {
//     "strict": true,
//     "noImplicitAny": true,
//     "strictNullChecks": true,
//     "strictFunctionTypes": true,
//     "strictBindCallApply": true,
//     "noImplicitReturns": true,
//     "noFallthroughCasesInSwitch": true,
//     "exactOptionalPropertyTypes": true
//   }
// }
 
// strict モード下での安全なコード例
function findUser(
    users: readonly User[],
    id: number
): User | undefined {
    return users.find(user => user.id === id);
}
 
// strictNullChecks 下では undefined の可能性を処理しないとエラー
const user = findUser(users, 42);
// console.log(user.name);  // Error: Object is possibly 'undefined'
 
// 正しい処理
if (user !== undefined) {
    console.log(user.name);  // OK: ここでは user は User 型
}
 
// Optional chaining + Nullish coalescing
const name = user?.name ?? "Unknown";

// Rust: 安全なコードは健全、unsafe ブロックで健全性の「穴」を作れる
 
// 安全なコード --- 型システムが健全性を保証
fn safe_example() {
    let v: Vec<i32> = vec![1, 2, 3];
    // v[10];  // パニック（境界チェックあり）だが型エラーではない
 
    let x: Option<i32> = Some(42);
    // x + 1;  // コンパイルエラー: Option<i32> に + は定義されていない
    let y = x.unwrap() + 1;  // OK: unwrap で i32 を取り出してから加算
}
 
// unsafe ブロック --- 開発者が安全性を保証する責任を負う
fn unsafe_example() {
    let x: i32 = 42;
    let ptr = &x as *const i32;
 
    unsafe {
        // 生ポインタのデリファレンス --- 開発者の責任
        let value = *ptr;
        println!("Value: {}", value);
 
        // unsafe の典型的な用途:
        // 1. 生ポインタのデリファレンス
        // 2. unsafe 関数の呼び出し（FFI等）
        // 3. ミュータブルな静的変数へのアクセス
        // 4. unsafe トレイトの実装
    }
}

// TypeScript: 意図的に不健全な箇所がある
 
// 1. any 型 --- 型チェックを完全に無効化
let data: any = "hello";
data.nonExistentMethod();  // コンパイルOK、実行時エラー
 
// 2. 型アサーション --- 開発者が型を強制
interface User {
    name: string;
    email: string;
}
const raw: unknown = {};
const user = raw as User;      // コンパイルOK
console.log(user.name);        // undefined（実行時）
 
// 3. non-null assertion --- null/undefined でないと断言
function getLength(s: string | undefined): number {
    return s!.length;  // s が undefined なら実行時エラー
}
 
// 4. 共変配列 --- TypeScript の設計上の妥協
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs;  // OK（共変）
animals.push(new Cat());         // コンパイルOK!
// dogs[1] は Cat だが Dog[] の要素として扱われる（不健全）

// Java: 名目的型付けの典型例
 
class Meter {
    private final double value;
    Meter(double value) { this.value = value; }
    double getValue() { return value; }
}
 
class Kilogram {
    private final double value;
    Kilogram(double value) { this.value = value; }
    double getValue() { return value; }
}
 
// Meter と Kilogram は同じ構造だが、互換性なし
void processDistance(Meter m) {
    System.out.println("Distance: " + m.getValue() + "m");
}
 
// processDistance(new Kilogram(5.0));  // コンパイルエラー!
// Kilogram は Meter ではない（名前が異なる）
// → 単位の混同を型レベルで防止できる
// （NASAの火星探査機が単位混同で墜落した事例を防げる設計）

// TypeScript: 構造的型付けの典型例
 
interface HasName {
    name: string;
}
 
interface HasAge {
    age: number;
}
 
interface Person {
    name: string;
    age: number;
    email: string;
}
 
function greetByName(entity: HasName): string {
    return `Hello, ${entity.name}!`;
}
 
const person: Person = { name: "Alice", age: 30, email: "a@b.com" };
const company = { name: "Acme Corp", founded: 1990 };
 
// どちらも name プロパティを持つため HasName として扱える
greetByName(person);   // OK
greetByName(company);  // OK（構造的に互換）
 
// Go も構造的型付けを採用
// Go では「暗黙的にインターフェースを満たす」

// --- アンチパターン: any の乱用 ---
 
// BAD: API レスポンスを any で受ける
async function fetchUsers(): Promise<any> {
    const response = await fetch("/api/users");
    return response.json();  // any が返る
}
 
async function displayUsers() {
    const users = await fetchUsers();
    // any なので何でもアクセスできてしまう
    console.log(users.nonExistent.deeply.nested);  // コンパイルOK!
    // → 実行時に TypeError: Cannot read properties of undefined
}
 
// BAD: イベントハンドラで any
function handleEvent(event: any) {
    event.target.value.toUpperCase();  // コンパイルOK、実行時に壊れる可能性
}
 
// BAD: 型が面倒だから any
function processData(data: any): any {
    return data.map((item: any) => ({
        ...item,
        processed: true,
    }));
}
 
// --- 改善パターン ---
 
// GOOD: 適切な型定義
interface User {
    id: number;
    name: string;
    email: string;
    role: "admin" | "user" | "guest";
}
 
interface ApiResponse<T> {
    data: T;
    meta: { total: number; page: number };
}
 
async function fetchUsers(): Promise<ApiResponse<User[]>> {
    const response = await fetch("/api/users");
    const json: unknown = await response.json();
    return validateApiResponse(json);  // バリデーション付き
}
 
// GOOD: unknown + 型ガード
function isUser(value: unknown): value is User {
    return (
        typeof value === "object" &&
        value !== null &&
        "id" in value &&
        "name" in value &&
        "email" in value &&
        typeof (value as User).id === "number" &&
        typeof (value as User).name === "string"
    );
}
 
// GOOD: イベントハンドラの適切な型付け
function handleInputChange(event: React.ChangeEvent<HTMLInputElement>) {
    const value = event.target.value;  // string 型が保証される
    console.log(value.toUpperCase());
}
 
// GOOD: ジェネリクスで柔軟かつ型安全に
function processData<T>(data: T[]): (T & { processed: boolean })[] {
    return data.map(item => ({ ...item, processed: true }));
}

// --- アンチパターン: 暗黙的型変換への依存 ---
 
// BAD: == による暗黙変換を利用した比較
function isEmptyValue(value) {
    return value == null;  // null と undefined の両方に一致
    // 意図は理解できるが、== の挙動は他の場面で罠になる
}
 
// BAD: 真偽値としての暗黙評価に依存
function getDisplayName(user) {
    return user.nickname || user.name || "Anonymous";
    // 問題: nickname が "" (空文字列) の場合、falsy なのでスキップされる
    // ユーザーが意図的に空文字を設定した場合の挙動が不正
}
 
// BAD: + 演算子の暗黙変換に依存
function calculateTotal(items) {
    let total = 0;
    for (const item of items) {
        total += item.price;  // item.price が文字列 "100" だと文字列結合になる
    }
    return total;
    // items = [{price: 10}, {price: "20"}]
    // → total = "1020" (文字列!) ではなく期待値は 30
}
 
// BAD: 配列のソートにおける暗黙変換
const numbers = [10, 1, 21, 2];
numbers.sort();           // [1, 10, 2, 21] (文字列として比較!)
// デフォルトの sort() は要素を文字列に変換して辞書順でソートする
 
// --- 改善パターン ---
 
// GOOD: 厳密等価演算子 === を使う
function isNullOrUndefined(value) {
    return value === null || value === undefined;
}
 
// GOOD: Nullish coalescing ?? を使う（ES2020+）
function getDisplayName(user) {
    return user.nickname ?? user.name ?? "Anonymous";
    // ?? は null と undefined のみをスキップ（"" や 0 はスキップしない）
}
 
// GOOD: 明示的な型変換
function calculateTotal(items) {
    let total = 0;
    for (const item of items) {
        const price = Number(item.price);
        if (Number.isNaN(price)) {
            throw new Error(`Invalid price: ${item.price}`);
        }
        total += price;
    }
    return total;
}
 
// GOOD: 比較関数を明示的に渡す
numbers.sort((a, b) => a - b);  // [1, 2, 10, 21] (数値として比較)

// --- アンチパターン: 型アサーション (as) の過信 ---
 
// BAD: 外部データを型アサーションで無検証に変換
interface Config {
    host: string;
    port: number;
    ssl: boolean;
}
 
// 外部から来るデータを検証せずにアサーション
const config = JSON.parse(rawJson) as Config;
// rawJson が不正でも Config として扱われてしまう
 
// BAD: as unknown as T で型システムを完全にバイパス
const num = "hello" as unknown as number;
// コンパイルOK。num.toFixed(2) → 実行時エラー
 
// --- 改善パターン ---
 
// GOOD: Zod などのバリデーションライブラリを使用
import { z } from "zod";
 
const ConfigSchema = z.object({
    host: z.string().min(1),
    port: z.number().int().min(1).max(65535),
    ssl: z.boolean(),
});
 
type Config = z.infer<typeof ConfigSchema>;
 
function loadConfig(rawJson: string): Config {
    const parsed = JSON.parse(rawJson);
    return ConfigSchema.parse(parsed);
    // バリデーションに失敗すると ZodError が投げられる
}

# Python (動的型付け) で実行する:
 
# テスト1: 型不一致の算術演算
def test_arithmetic():
    result = "100" + 50
    return result
 
# テスト2: 存在しないメソッド呼び出し
def test_method():
    x = 42
    return x.upper()
 
# テスト3: 引数の型不一致
def test_argument():
    items = [1, 2, 3]
    return items.append("not a number")  # 成功する（listは型制約なし）
 
# それぞれを実行し、エラーメッセージを記録すること
# 追加課題: mypy で同じコードを解析し、結果を比較すること

// TypeScript (静的型付け) で実行する:
 
// テスト1: 型不一致の算術演算
function testArithmetic(): number {
    const result: number = "100" + 50;  // コンパイルエラー
    return result;
}
 
// テスト2: 存在しないメソッド呼び出し
function testMethod(): string {
    const x: number = 42;
    return x.upper();  // コンパイルエラー
}
 
// テスト3: 引数の型不一致
function testArgument(): void {
    const items: number[] = [1, 2, 3];
    items.push("not a number");  // コンパイルエラー
}
 
// tsc でコンパイルし、エラーメッセージを記録すること

// Rust (静的 + 強い型付け) で実行する:
 
// テスト1: 型不一致の算術演算
fn test_arithmetic() -> i32 {
    let result: i32 = "100" + 50;  // コンパイルエラー
    result
}
 
// テスト2: 存在しないメソッド呼び出し
fn test_method() -> String {
    let x: i32 = 42;
    x.upper()  // コンパイルエラー
}
 
// テスト3: 引数の型不一致
fn test_argument() {
    let mut items: Vec<i32> = vec![1, 2, 3];
    items.push("not a number");  // コンパイルエラー
}
 
// cargo build でコンパイルし、エラーメッセージを記録すること

# 型注釈なしの元コード（これに型ヒントを追加する）
 
from datetime import datetime, timedelta
 
class TaskStatus:
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    CANCELLED = "cancelled"
 
class Task:
    def __init__(self, title, description, due_date=None):
        self.title = title
        self.description = description
        self.due_date = due_date
        self.status = TaskStatus.PENDING
        self.created_at = datetime.now()
        self.tags = []
 
    def is_overdue(self):
        if self.due_date is None:
            return False
        return datetime.now() > self.due_date
 
    def add_tag(self, tag):
        if tag not in self.tags:
            self.tags.append(tag)
 
    def remove_tag(self, tag):
        if tag in self.tags:
            self.tags.remove(tag)
            return True
        return False
 
class TaskManager:
    def __init__(self):
        self.tasks = []
        self.next_id = 1
 
    def add_task(self, title, description, due_date=None):
        task = Task(title, description, due_date)
        self.tasks.append(task)
        self.next_id += 1
        return task
 
    def get_overdue_tasks(self):
        return [t for t in self.tasks if t.is_overdue()]
 
    def get_tasks_by_tag(self, tag):
        return [t for t in self.tasks if tag in t.tags]
 
    def get_tasks_by_status(self, status):
        return [t for t in self.tasks if t.status == status]
 
    def summary(self):
        total = len(self.tasks)
        by_status = {}
        for task in self.tasks:
            by_status[task.status] = by_status.get(task.status, 0) + 1
        return {"total": total, "by_status": by_status}

// 要件:
// 1. API エンドポイントの定義を型で表現する
// 2. エンドポイントに応じたリクエスト/レスポンスの型を自動推論する
// 3. 存在しないエンドポイントへのアクセスをコンパイル時に防止する
 
// ヒント: 以下のような型定義から始める
 
// API スキーマの型定義
interface ApiSchema {
    "/users": {
        GET: { response: User[]; query: { page?: number; limit?: number } };
        POST: { response: User; body: { name: string; email: string } };
    };
    "/users/:id": {
        GET: { response: User; params: { id: string } };
        PUT: { response: User; params: { id: string }; body: Partial<User> };
        DELETE: { response: void; params: { id: string } };
    };
    "/posts": {
        GET: { response: Post[]; query: { authorId?: string } };
        POST: { response: Post; body: { title: string; content: string } };
    };
}
 
// 型安全な API クライアント（実装せよ）
// const api = createApiClient<ApiSchema>(baseUrl);
//
// 以下が型安全に動作すること:
// const users = await api.get("/users", { query: { page: 1 } });
//   → users の型は User[]
//
// const user = await api.post("/users", { body: { name: "Alice", email: "a@b.com" } });
//   → user の型は User
//
// 以下がコンパイルエラーになること:
// await api.get("/nonexistent");  // 存在しないエンドポイント
// await api.post("/users", { body: { name: 123 } });  // 型不一致
// await api.delete("/users");  // DELETE は /users/:id のみ