// ===== JavaScript =====
 
// 関数宣言を変数に代入（関数式）
const greet = function(name) {
    return `Hello, ${name}!`;
};
 
// アロー関数（ES6+）
const greetArrow = (name) => `Hello, ${name}!`;
 
// 既存の関数を別の変数に代入
const sayHello = greet;
console.log(sayHello("Alice"));  // => "Hello, Alice!"
 
// 条件に応じた関数の選択
const formatter = process.env.NODE_ENV === "production"
    ? (msg) => `[PROD] ${msg}`
    : (msg) => `[DEV] ${msg}`;
 
console.log(formatter("Server started"));
// 開発環境: => "[DEV] Server started"

# ===== Python =====
 
def square(x):
    """xの二乗を返す"""
    return x ** 2
 
# 関数を変数に代入
f = square
print(f(5))      # => 25
print(f.__name__) # => "square"（元の名前を保持）
 
# lambda式による無名関数
double = lambda x: x * 2
print(double(7))  # => 14
 
# 条件に応じた関数の選択
import os
log_fn = print if os.getenv("DEBUG") else lambda *args: None
log_fn("デバッグメッセージ")  # DEBUG環境変数がないと何も表示しない

// ===== Rust =====
 
fn square(x: i32) -> i32 {
    x * x
}
 
fn main() {
    // 関数ポインタとして代入
    let f: fn(i32) -> i32 = square;
    println!("{}", f(5));  // => 25
 
    // クロージャを変数に代入
    let double = |x: i32| -> i32 { x * 2 };
    println!("{}", double(7));  // => 14
 
    // 条件に応じた関数の選択（関数ポインタの場合）
    let debug = true;
    let log_fn: fn(&str) = if debug {
        |msg| println!("[DEBUG] {}", msg)
    } else {
        |_msg| {}  // 何もしない
    };
    log_fn("起動しました");
}

// ===== JavaScript =====
 
// map: 各要素に変換関数を適用
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);
// => [2, 4, 6, 8, 10]
 
// filter: 条件関数を満たす要素のみ抽出
const evens = numbers.filter(x => x % 2 === 0);
// => [2, 4]
 
// reduce: 累積関数で畳み込み
const sum = numbers.reduce((acc, x) => acc + x, 0);
// => 15
 
// カスタム高階関数の作成
function applyTwice(fn, value) {
    return fn(fn(value));
}
 
applyTwice(x => x * 2, 3);   // => 12  (3 → 6 → 12)
applyTwice(x => x + 10, 5);  // => 25  (5 → 15 → 25)
 
// 汎用的な retry 関数
async function retry(fn, maxAttempts = 3, delay = 1000) {
    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            return await fn();
        } catch (err) {
            if (attempt === maxAttempts) throw err;
            console.log(`Attempt ${attempt} failed, retrying...`);
            await new Promise(r => setTimeout(r, delay));
        }
    }
}
 
// 使用例
await retry(() => fetch("https://api.example.com/data"), 3, 2000);

# ===== Python =====
 
# 組み込み高階関数
numbers = [1, 2, 3, 4, 5]
 
# map: 各要素に関数を適用
squared = list(map(lambda x: x ** 2, numbers))
# => [1, 4, 9, 16, 25]
 
# filter: 条件を満たす要素を抽出
evens = list(filter(lambda x: x % 2 == 0, numbers))
# => [2, 4]
 
# sorted: キー関数でソート
words = ["banana", "apple", "cherry", "date"]
sorted_by_length = sorted(words, key=len)
# => ["date", "apple", "banana", "cherry"]
 
# カスタム高階関数
def apply_to_all(fn, items):
    """リスト全要素にfnを適用して新リストを返す"""
    return [fn(item) for item in items]
 
apply_to_all(str.upper, ["hello", "world"])
# => ["HELLO", "WORLD"]
 
# デコレータ: 高階関数の典型的応用
import time
import functools
 
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}秒")
        return result
    return wrapper
 
@timer
def slow_function():
    time.sleep(1)
    return "done"
 
slow_function()  # => "slow_function: 1.00xx秒" と表示後 "done" を返す

// ===== JavaScript =====
 
// 乗数関数ファクトリ
function multiplier(factor) {
    return (x) => x * factor;
}
 
const double = multiplier(2);
const triple = multiplier(3);
const tenTimes = multiplier(10);
 
console.log(double(5));    // => 10
console.log(triple(5));    // => 15
console.log(tenTimes(5));  // => 50
 
// バリデータファクトリ
function createValidator(rules) {
    return (value) => {
        const errors = [];
        for (const rule of rules) {
            const error = rule(value);
            if (error) errors.push(error);
        }
        return { valid: errors.length === 0, errors };
    };
}
 
// ルール定義
const required = (v) => v ? null : "必須項目です";
const minLength = (n) => (v) => v && v.length >= n
    ? null : `${n}文字以上必要です`;
const pattern = (re, msg) => (v) => re.test(v) ? null : msg;
 
// バリデータ生成
const validateEmail = createValidator([
    required,
    minLength(5),
    pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, "有効なメールアドレスを入力してください"),
]);
 
console.log(validateEmail(""));
// => { valid: false, errors: ["必須項目です", "5文字以上必要です", ...] }
 
console.log(validateEmail("user@example.com"));
// => { valid: true, errors: [] }

# ===== Python =====
 
# ロガーファクトリ
def create_logger(prefix, level="INFO"):
    """指定プレフィックスとレベルのログ関数を生成する"""
    def logger(message):
        from datetime import datetime
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] [{level}] [{prefix}] {message}")
    return logger
 
app_log = create_logger("APP")
db_log = create_logger("DB", level="DEBUG")
 
app_log("サーバー起動")
# => [2026-03-06 10:30:00] [INFO] [APP] サーバー起動
 
db_log("クエリ実行: SELECT * FROM users")
# => [2026-03-06 10:30:00] [DEBUG] [DB] クエリ実行: SELECT * FROM users

# ===== Python =====
 
# ディスパッチテーブルによるコマンドパターン
class Calculator:
    def __init__(self):
        self.operations = {
            "+": lambda a, b: a + b,
            "-": lambda a, b: a - b,
            "*": lambda a, b: a * b,
            "/": lambda a, b: a / b if b != 0 else float("inf"),
            "**": lambda a, b: a ** b,
            "%": lambda a, b: a % b,
        }
        self.history = []
 
    def calculate(self, a, op, b):
        if op not in self.operations:
            raise ValueError(f"未対応の演算子: {op}")
        result = self.operationsop
        self.history.append(f"{a} {op} {b} = {result}")
        return result
 
    def add_operation(self, symbol, fn):
        """演算子を動的に追加"""
        self.operations[symbol] = fn
 
calc = Calculator()
print(calc.calculate(10, "+", 5))   # => 15
print(calc.calculate(2, "**", 10))  # => 1024
 
# 演算子の動的追加
calc.add_operation("avg", lambda a, b: (a + b) / 2)
print(calc.calculate(10, "avg", 20))  # => 15.0

// ===== JavaScript =====
 
// HTTP メソッドのディスパッチテーブル
const handlers = {
    GET:    (req) => ({ status: 200, body: fetchResource(req.path) }),
    POST:   (req) => ({ status: 201, body: createResource(req.body) }),
    PUT:    (req) => ({ status: 200, body: updateResource(req.path, req.body) }),
    DELETE: (req) => ({ status: 204, body: null }),
};
 
function handleRequest(req) {
    const handler = handlers[req.method];
    if (!handler) {
        return { status: 405, body: "Method Not Allowed" };
    }
    return handler(req);
}
 
// パイプライン: 関数の配列を順に適用
const pipeline = [
    (data) => ({ ...data, timestamp: Date.now() }),
    (data) => ({ ...data, id: crypto.randomUUID() }),
    (data) => ({ ...data, status: "processed" }),
];
 
function processThroughPipeline(data, steps) {
    return steps.reduce((acc, step) => step(acc), data);
}
 
const result = processThroughPipeline(
    { name: "Alice" },
    pipeline
);
// => { name: "Alice", timestamp: 1709..., id: "abc-...", status: "processed" }

// ===== JavaScript: map / filter / reduce の自作実装 =====
 
// map の実装
function myMap(arr, fn) {
    const result = [];
    for (let i = 0; i < arr.length; i++) {
        result.push(fn(arr[i], i, arr));
    }
    return result;
}
 
// filter の実装
function myFilter(arr, predicate) {
    const result = [];
    for (let i = 0; i < arr.length; i++) {
        if (predicate(arr[i], i, arr)) {
            result.push(arr[i]);
        }
    }
    return result;
}
 
// reduce の実装
function myReduce(arr, fn, initial) {
    let acc = initial;
    let startIndex = 0;
    if (acc === undefined) {
        acc = arr[0];
        startIndex = 1;
    }
    for (let i = startIndex; i < arr.length; i++) {
        acc = fn(acc, arr[i], i, arr);
    }
    return acc;
}
 
// 動作確認
const nums = [1, 2, 3, 4, 5];
console.log(myMap(nums, x => x * 2));           // => [2, 4, 6, 8, 10]
console.log(myFilter(nums, x => x > 3));        // => [4, 5]
console.log(myReduce(nums, (a, b) => a + b, 0)); // => 15
 
// reduce で map と filter を再実装
function mapWithReduce(arr, fn) {
    return arr.reduce((acc, x, i) => {
        acc.push(fn(x, i, arr));
        return acc;
    }, []);
}
 
function filterWithReduce(arr, pred) {
    return arr.reduce((acc, x, i) => {
        if (pred(x, i, arr)) acc.push(x);
        return acc;
    }, []);
}

// ===== JavaScript: 同期コールバックの多様な用例 =====
 
// イベントリスナー（ブラウザ環境）
document.addEventListener("click", (event) => {
    console.log(`クリック位置: (${event.clientX}, ${event.clientY})`);
});
 
// Array メソッドチェーン
const users = [
    { name: "Alice", age: 30, role: "admin" },
    { name: "Bob", age: 25, role: "user" },
    { name: "Charlie", age: 35, role: "admin" },
    { name: "Diana", age: 28, role: "user" },
];
 
// 管理者の名前を年齢順に取得
const adminNames = users
    .filter(u => u.role === "admin")
    .sort((a, b) => a.age - b.age)
    .map(u => u.name);
// => ["Alice", "Charlie"]
 
// forEach: 副作用のためのコールバック
users.forEach(u => {
    console.log(`${u.name} (${u.age}歳) - ${u.role}`);
});
 
// find / findIndex: 条件に合う最初の要素
const firstAdmin = users.find(u => u.role === "admin");
// => { name: "Alice", age: 30, role: "admin" }
 
// every / some: 全要素/一部要素が条件を満たすか
const allAdults = users.every(u => u.age >= 18);  // => true
const hasAdmin = users.some(u => u.role === "admin"); // => true

// ===== JavaScript: 非同期コールバックの進化 =====
 
// 1. 古典的コールバックスタイル（Node.js）
const fs = require("fs");
 
fs.readFile("/path/to/file.txt", "utf8", (err, data) => {
    if (err) {
        console.error("読み取りエラー:", err);
        return;
    }
    console.log("ファイル内容:", data);
});
 
// 2. Promise（ES6+）
function readFileAsync(path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, "utf8", (err, data) => {
            if (err) reject(err);
            else resolve(data);
        });
    });
}
 
readFileAsync("/path/to/file.txt")
    .then(data => console.log(data))
    .catch(err => console.error(err));
 
// 3. async/await（ES2017+）
async function processFile() {
    try {
        const data = await readFileAsync("/path/to/file.txt");
        const processed = data.toUpperCase();
        console.log(processed);
    } catch (err) {
        console.error("処理エラー:", err);
    }
}

// ===== TypeScript: OOP的ストラテジー vs 関数的ストラテジー =====
 
// --- OOP的アプローチ（Javaスタイル）---
interface SortStrategy<T> {
    compare(a: T, b: T): number;
}
 
class NameSortStrategy implements SortStrategy<User> {
    compare(a: User, b: User): number {
        return a.name.localeCompare(b.name);
    }
}
 
class AgeSortStrategy implements SortStrategy<User> {
    compare(a: User, b: User): number {
        return a.age - b.age;
    }
}
 
class UserSorter {
    private strategy: SortStrategy<User>;
 
    constructor(strategy: SortStrategy<User>) {
        this.strategy = strategy;
    }
 
    setStrategy(strategy: SortStrategy<User>) {
        this.strategy = strategy;
    }
 
    sort(users: User[]): User[] {
        return [...users].sort((a, b) => this.strategy.compare(a, b));
    }
}
 
// --- 関数的アプローチ（第一級関数を活用）---
type Comparator<T> = (a: T, b: T) => number;
 
const byName: Comparator<User> = (a, b) => a.name.localeCompare(b.name);
const byAge: Comparator<User> = (a, b) => a.age - b.age;
const byNameDesc: Comparator<User> = (a, b) => b.name.localeCompare(a.name);
const byAgeDesc: Comparator<User> = (a, b) => b.age - a.age;
 
// 合成: 複数のソート条件を組み合わせ
function composeComparators<T>(...comparators: Comparator<T>[]): Comparator<T> {
    return (a, b) => {
        for (const cmp of comparators) {
            const result = cmp(a, b);
            if (result !== 0) return result;
        }
        return 0;
    };
}
 
// ロール優先 → 年齢順でソート
const byRoleThenAge = composeComparators(
    (a, b) => a.role.localeCompare(b.role),
    byAge
);
 
const sorted = [...users].sort(byRoleThenAge);

// ===== TypeScript: 関数合成の実装 =====
 
// compose: 右から左へ適用（数学的記法）
function compose<A, B, C>(
    f: (b: B) => C,
    g: (a: A) => B
): (a: A) => C {
    return (a: A) => f(g(a));
}
 
// pipe: 左から右へ適用（プログラミング的記法）
function pipe<T>(...fns: Array<(arg: T) => T>): (arg: T) => T {
    return (arg: T) => fns.reduce((acc, fn) => fn(acc), arg);
}
 
// 使用例
const double = (x: number) => x * 2;
const addOne = (x: number) => x + 1;
const square = (x: number) => x * x;
 
const doubleAndAddOne = compose(addOne, double);
console.log(doubleAndAddOne(5));  // => 11
 
const transform = pipe(double, addOne, square);
console.log(transform(3));  // => 3 → 6 → 7 → 49

# ===== Python: 関数合成 =====
 
from functools import reduce
 
def compose(*fns):
    """右から左への関数合成"""
    def composed(x):
        result = x
        for fn in reversed(fns):
            result = fn(result)
        return result
    return composed
 
def pipe(*fns):
    """左から右への関数合成"""
    def piped(x):
        result = x
        for fn in fns:
            result = fn(result)
        return result
    return piped
 
# 使用例
double = lambda x: x * 2
add_one = lambda x: x + 1
square = lambda x: x ** 2
 
transform = pipe(double, add_one, square)
print(transform(3))  # => 49  (3 → 6 → 7 → 49)
 
# 文字列処理パイプライン
normalize = pipe(
    str.strip,
    str.lower,
    lambda s: s.replace("  ", " "),
)
print(normalize("  Hello   World  "))  # => "hello world"

# ===== Python: functools.partial =====
 
from functools import partial
 
def power(base, exponent):
    """baseのexponent乗を計算"""
    return base ** exponent
 
# 部分適用で新しい関数を生成
square = partial(power, exponent=2)
cube = partial(power, exponent=3)
 
print(square(5))  # => 25
print(cube(3))    # => 27
 
# HTTPクライアントの部分適用
import urllib.request
 
def fetch(method, url, headers=None, body=None):
    """汎用HTTPリクエスト関数"""
    req = urllib.request.Request(url, method=method, headers=headers or {})
    if body:
        req.data = body.encode()
    return urllib.request.urlopen(req)
 
# メソッド固定の関数を生成
get = partial(fetch, "GET")
post = partial(fetch, "POST")
put = partial(fetch, "PUT")
 
# 使用: get("https://api.example.com/users")

// ===== JavaScript: カリー化 =====
 
// 手動カリー化
function add(a) {
    return function(b) {
        return a + b;
    };
}
 
const add5 = add(5);
console.log(add5(3));  // => 8
 
// 汎用カリー化関数
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        }
        return function(...moreArgs) {
            return curried.apply(this, args.concat(moreArgs));
        };
    };
}
 
// 使用例
const curriedAdd = curry((a, b, c) => a + b + c);
console.log(curriedAdd(1)(2)(3));    // => 6
console.log(curriedAdd(1, 2)(3));    // => 6
console.log(curriedAdd(1)(2, 3));    // => 6
console.log(curriedAdd(1, 2, 3));    // => 6
 
// 実用例: ログ関数のカリー化
const log = curry((level, module, message) => {
    console.log(`[${level}] [${module}] ${message}`);
});
 
const errorLog = log("ERROR");
const appError = errorLog("APP");
const dbError = errorLog("DB");
 
appError("接続タイムアウト");
// => [ERROR] [APP] 接続タイムアウト
 
dbError("クエリ失敗");
// => [ERROR] [DB] クエリ失敗

// ===== Rust: 3種類のクロージャトレイト =====
 
fn main() {
    // --- Fn: 環境を不変参照でキャプチャ ---
    let name = String::from("Alice");
    let greet = || println!("Hello, {}!", name);  // name を &name でキャプチャ
    greet();  // 何度でも呼べる
    greet();  // 再利用可能
    println!("{}", name);  // name はまだ使える
 
    // --- FnMut: 環境を可変参照でキャプチャ ---
    let mut count = 0;
    let mut increment = || {
        count += 1;  // count を &mut count でキャプチャ
        println!("count = {}", count);
    };
    increment();  // count = 1
    increment();  // count = 2
 
    // --- FnOnce: 環境を所有権移動でキャプチャ ---
    let data = vec![1, 2, 3];
    let consume = move || {
        println!("data: {:?}", data);  // data の所有権を移動
        drop(data);  // data を消費
    };
    consume();  // 1回しか呼べない
    // consume();  // コンパイルエラー: 既に消費済み
 
    // --- 高階関数での使い分け ---
    fn apply_fn<F: Fn()>(f: F) {
        f(); f();  // 複数回呼べる
    }
 
    fn apply_fn_mut<F: FnMut()>(mut f: F) {
        f(); f();  // 状態を変更しつつ複数回呼べる
    }
 
    fn apply_fn_once<F: FnOnce()>(f: F) {
        f();  // 1回だけ呼べる
    }
}

// ===== JavaScript: ミドルウェアパターン =====
 
// シンプルなミドルウェアシステム
class Pipeline {
    constructor() {
        this.middlewares = [];
    }
 
    use(middleware) {
        this.middlewares.push(middleware);
        return this;  // メソッドチェーン
    }
 
    async execute(context) {
        let index = 0;
        const next = async () => {
            if (index < this.middlewares.length) {
                const middleware = this.middlewares[index++];
                await middleware(context, next);
            }
        };
        await next();
        return context;
    }
}
 
// ミドルウェアの定義（各ミドルウェアは関数）
const logger = async (ctx, next) => {
    const start = Date.now();
    console.log(`→ ${ctx.method} ${ctx.path}`);
    await next();
    console.log(`← ${ctx.method} ${ctx.path} (${Date.now() - start}ms)`);
};
 
const auth = async (ctx, next) => {
    if (!ctx.headers.authorization) {
        ctx.status = 401;
        ctx.body = "Unauthorized";
        return;  // next() を呼ばない → 以降のミドルウェアをスキップ
    }
    ctx.user = verifyToken(ctx.headers.authorization);
    await next();
};
 
const handler = async (ctx, next) => {
    ctx.status = 200;
    ctx.body = { message: "Hello", user: ctx.user };
    await next();
};
 
// パイプラインの組み立て
const app = new Pipeline();
app.use(logger).use(auth).use(handler);
 
// 実行
await app.execute({
    method: "GET",
    path: "/api/users",
    headers: { authorization: "Bearer token123" },
});

// ===== TypeScript: 型安全なイベントエミッタ =====
 
type EventMap = {
    "user:login":  { userId: string; timestamp: number };
    "user:logout": { userId: string; reason: string };
    "error":       { code: number; message: string };
};
 
class TypedEventEmitter<T extends Record<string, unknown>> {
    private listeners = new Map<keyof T, Set<(data: any) => void>>();
 
    on<K extends keyof T>(event: K, handler: (data: T[K]) => void): () => void {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, new Set());
        }
        this.listeners.get(event)!.add(handler);
 
        // 解除関数を返す（これも第一級関数の活用）
        return () => {
            this.listeners.get(event)?.delete(handler);
        };
    }
 
    emit<K extends keyof T>(event: K, data: T[K]): void {
        this.listeners.get(event)?.forEach(handler => handler(data));
    }
}
 
// 使用例
const emitter = new TypedEventEmitter<EventMap>();
 
const unsubscribe = emitter.on("user:login", (data) => {
    console.log(`ユーザー ${data.userId} がログイン (${data.timestamp})`);
});
 
emitter.emit("user:login", {
    userId: "user-123",
    timestamp: Date.now(),
});
 
// 不要になったら解除
unsubscribe();

// ===== JavaScript: 汎用メモ化関数 =====
 
function memoize(fn, options = {}) {
    const cache = new Map();
    const { maxSize = 1000, keyFn = JSON.stringify } = options;
 
    function memoized(...args) {
        const key = keyFn(args);
 
        if (cache.has(key)) {
            return cache.get(key);
        }
 
        const result = fn.apply(this, args);
 
        // キャッシュサイズ制限
        if (cache.size >= maxSize) {
            const firstKey = cache.keys().next().value;
            cache.delete(firstKey);
        }
 
        cache.set(key, result);
        return result;
    }
 
    // キャッシュ操作メソッドを付加
    memoized.cache = cache;
    memoized.clear = () => cache.clear();
 
    return memoized;
}
 
// 使用例: フィボナッチ数列
const fib = memoize((n) => {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
});
 
console.log(fib(50));  // => 12586269025（高速に計算される）
 
// 使用例: API レスポンスキャッシュ
const fetchUser = memoize(
    async (id) => {
        const res = await fetch(`/api/users/${id}`);
        return res.json();
    },
    { maxSize: 100 }
);

# ===== Python: lru_cache デコレータ =====
 
from functools import lru_cache
 
@lru_cache(maxsize=128)
def fibonacci(n):
    """メモ化されたフィボナッチ数列"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
print(fibonacci(100))
# => 354224848179261915075（高速に計算される）
 
# キャッシュ統計
print(fibonacci.cache_info())
# => CacheInfo(hits=98, misses=101, maxsize=128, currsize=101)
 
# キャッシュクリア
fibonacci.cache_clear()

// ===== アンチパターン: 過剰な抽象化 =====
 
// BAD: 不要な関数ラッピング
const add = (a) => (b) => a + b;
const multiply = (a) => (b) => a * b;
const compose = (f) => (g) => (x) => f(g(x));
const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
 
// 単純な計算なのに読解コストが高い
const result = pipe(
    add(1),
    multiply(2),
    compose(add(3))(multiply(4)),
)(5);
// 何をしているのか一見して分からない...
 
// GOOD: 適切な抽象度
function calculatePrice(basePrice, taxRate, discount) {
    const afterDiscount = basePrice * (1 - discount);
    const withTax = afterDiscount * (1 + taxRate);
    return Math.round(withTax);
}
 
calculatePrice(1000, 0.1, 0.2);  // => 880
// 意図が明確で読みやすい

// ===== アンチパターン: this の喪失 =====
 
class UserService {
    constructor() {
        this.users = ["Alice", "Bob"];
    }
 
    getUsers() {
        return this.users;
    }
}
 
const service = new UserService();
 
// BAD: メソッドを変数に代入すると this が失われる
const getUsers = service.getUsers;
// getUsers();  // TypeError: Cannot read property 'users' of undefined
 
// BAD: コールバックとして渡しても this が失われる
// setTimeout(service.getUsers, 1000);  // 同様のエラー
 
// --- 解決策 ---
 
// 解決策1: bind で this を束縛
const getUsersBound = service.getUsers.bind(service);
getUsersBound();  // => ["Alice", "Bob"]
 
// 解決策2: アロー関数でラップ
setTimeout(() => service.getUsers(), 1000);
 
// 解決策3: クラスフィールドでアロー関数を使う（推奨）
class UserServiceFixed {
    users = ["Alice", "Bob"];
 
    // アロー関数のクラスフィールド → this が固定される
    getUsers = () => {
        return this.users;
    };
}
 
const fixed = new UserServiceFixed();
const fn = fixed.getUsers;
fn();  // => ["Alice", "Bob"]（正常動作）

// ===== アンチパターン: ループ変数の罠 =====
 
// BAD: var を使ったループでのクロージャ
const functions = [];
for (var i = 0; i < 5; i++) {
    functions.push(() => i);
}
console.log(functions.map(f => f()));
// => [5, 5, 5, 5, 5]  全て5になる！（var はブロックスコープを持たない）
 
// GOOD: let を使う（ブロックスコープ）
const functions2 = [];
for (let i = 0; i < 5; i++) {
    functions2.push(() => i);
}
console.log(functions2.map(f => f()));
// => [0, 1, 2, 3, 4]  期待通り
 
// GOOD: IIFE（即時実行関数式）で値をキャプチャ
const functions3 = [];
for (var i = 0; i < 5; i++) {
    functions3.push(((captured) => () => captured)(i));
}
 
// BEST: 関数型アプローチ
const functions4 = Array.from({ length: 5 }, (_, i) => () => i);
console.log(functions4.map(f => f()));
// => [0, 1, 2, 3, 4]

// ===== Go: ループ変数の罠（Go 1.21 以前） =====
 
package main
 
import "fmt"
 
func main() {
    // BAD（Go 1.21 以前）: ループ変数はイテレーション間で共有される
    fns := make([]func(), 5)
    for i := 0; i < 5; i++ {
        fns[i] = func() { fmt.Println(i) }
    }
    for _, f := range fns {
        f()  // Go 1.21以前: 全て5。Go 1.22+: 0,1,2,3,4
    }
 
    // GOOD: ローカル変数にコピー（Go 1.21 以前の対策）
    fns2 := make([]func(), 5)
    for i := 0; i < 5; i++ {
        i := i  // シャドーイングで値をキャプチャ
        fns2[i] = func() { fmt.Println(i) }
    }
}

// ===== アンチパターン: 不要なクロージャの生成 =====
 
// BAD: レンダリングのたびに新しい関数オブジェクトが生成される
function TodoList({ todos, onDelete }) {
    return todos.map(todo => (
        // 毎回新しいアロー関数が生成され、子コンポーネントの
        // メモ化が無効化される
        <TodoItem
            key={todo.id}
            todo={todo}
            onDelete={() => onDelete(todo.id)}  // 毎回新しい関数
        />
    ));
}
 
// GOOD: useCallback やメソッド参照を使用
function TodoListOptimized({ todos, onDelete }) {
    const handleDelete = useCallback((id) => {
        onDelete(id);
    }, [onDelete]);
 
    return todos.map(todo => (
        <TodoItem
            key={todo.id}
            todo={todo}
            onDelete={handleDelete}
            todoId={todo.id}
        />
    ));
}

// 解答例
 
function applyOperation(a, b, operation) {
    return operation(a, b);
}
 
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;
const multiply = (a, b) => a * b;
const divide = (a, b) => {
    if (b === 0) throw new Error("0で除算はできません");
    return a / b;
};
 
console.log(applyOperation(10, 5, add));       // => 15
console.log(applyOperation(10, 5, subtract));  // => 5
console.log(applyOperation(10, 5, multiply));  // => 50
console.log(applyOperation(10, 5, divide));    // => 2

# 解答例
 
numbers = [1, -2, 3, -4, 5, -6, 7, -8, 9, -10]
 
positives = list(filter(lambda x: x > 0, numbers))
# => [1, 3, 5, 7, 9]
 
evens = list(filter(lambda x: x % 2 == 0, numbers))
# => [-2, -4, -6, -8, -10]
 
abs_gte_5 = list(filter(lambda x: abs(x) >= 5, numbers))
# => [5, -6, 7, -8, 9, -10]

// 解答例
 
const transforms = {
    upper:   (s) => s.toUpperCase(),
    lower:   (s) => s.toLowerCase(),
    reverse: (s) => s.split("").reverse().join(""),
    length:  (s) => `${s.length}文字`,
};
 
function applyTransform(command, text) {
    const fn = transforms[command];
    if (!fn) {
        return `エラー: 未知のコマンド "${command}"`;
    }
    return fn(text);
}
 
console.log(applyTransform("upper", "hello"));     // => "HELLO"
console.log(applyTransform("reverse", "hello"));   // => "olleh"
console.log(applyTransform("length", "hello"));    // => "5文字"
console.log(applyTransform("unknown", "hello"));   // => "エラー: 未知のコマンド..."

// 解答例
 
// pipe の実装（型安全版は複雑になるため、ここではシンプル版）
function pipe<T>(...fns: Array<(arg: T) => T>): (arg: T) => T {
    return (arg: T) => fns.reduce((acc, fn) => fn(acc), arg);
}
 
// 各ステップを関数として定義
const toLowerAll = (words: string[]) => words.map(w => w.toLowerCase());
const filterShort = (words: string[]) => words.filter(w => w.length > 3);
const unique = (words: string[]) => [...new Set(words)];
const sortAlpha = (words: string[]) => [...words].sort();
const joinComma = (words: string[]) => words.join(", ");
 
// パイプラインの構築（型の都合上、段階的に適用）
function processWords(input: string[]): string {
    const step1 = toLowerAll(input);
    const step2 = filterShort(step1);
    const step3 = unique(step2);
    const step4 = sortAlpha(step3);
    return joinComma(step4);
}
 
// テスト
const input = ["Hello", "WORLD", "the", "HELLO", "JavaScript", "is", "Great", "hello"];
console.log(processWords(input));
// => "great, hello, javascript, world"

// 解答例
 
async function retry(fn, options = {}) {
    const {
        maxAttempts = 3,
        baseDelay = 1000,
        backoffFactor = 2,
        onRetry = (attempt, err) => {
            console.log(`リトライ ${attempt}回目: ${err.message}`);
        },
    } = options;
 
    let lastError;
 
    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            return await fn(attempt);
        } catch (err) {
            lastError = err;
            if (attempt < maxAttempts) {
                const delay = baseDelay * Math.pow(backoffFactor, attempt - 1);
                onRetry(attempt, err);
                await new Promise(r => setTimeout(r, delay));
            }
        }
    }
 
    throw new Error(
        `${maxAttempts}回リトライしましたが失敗しました: ${lastError.message}`
    );
}
 
// テスト: 3回目で成功するシミュレーション
let callCount = 0;
const result = await retry(
    async (attempt) => {
        callCount++;
        if (callCount < 3) {
            throw new Error(`接続エラー（試行${callCount}）`);
        }
        return { data: "成功！" };
    },
    { maxAttempts: 5, baseDelay: 100 }
);
console.log(result);  // => { data: "成功！" }

# 解答例
 
import functools
 
def validate_args(func):
    """全引数が None でないことを検証するデコレータ"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        for i, arg in enumerate(args):
            if arg is None:
                raise ValueError(
                    f"{func.__name__}: 引数{i}が None です"
                )
        for key, val in kwargs.items():
            if val is None:
                raise ValueError(
                    f"{func.__name__}: キーワード引数'{key}'が None です"
                )
        return func(*args, **kwargs)
    return wrapper
 
 
def log_calls(func):
    """関数呼び出しをログ出力するデコレータ"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"呼び出し: {func.__name__}({signature})")
        result = func(*args, **kwargs)
        print(f"戻り値: {func.__name__} → {result!r}")
        return result
    return wrapper
 
 
@log_calls
@validate_args
def divide(a, b):
    """a / b を計算する"""
    if b == 0:
        raise ZeroDivisionError("0で除算はできません")
    return a / b
 
 
# テスト
divide(10, 3)
# 呼び出し: divide(10, 3)
# 戻り値: divide → 3.3333333333333335
 
# divide(10, None)
# ValueError: divide: 引数1が None です

// 解答例
 
class Optional<T> {
    private constructor(private readonly value: T | null | undefined) {}
 
    static of<T>(value: T | null | undefined): Optional<T> {
        return new Optional(value);
    }
 
    static empty<T>(): Optional<T> {
        return new Optional<T>(null);
    }
 
    isPresent(): boolean {
        return this.value !== null && this.value !== undefined;
    }
 
    map<U>(fn: (value: T) => U): Optional<U> {
        if (!this.isPresent()) return Optional.empty<U>();
        return Optional.of(fn(this.value!));
    }
 
    flatMap<U>(fn: (value: T) => Optional<U>): Optional<U> {
        if (!this.isPresent()) return Optional.empty<U>();
        return fn(this.value!);
    }
 
    getOrElse(defaultValue: T): T {
        return this.isPresent() ? this.value! : defaultValue;
    }
 
    filter(predicate: (value: T) => boolean): Optional<T> {
        if (!this.isPresent()) return this;
        return predicate(this.value!) ? this : Optional.empty();
    }
}
 
// ユーザーデータの型定義
interface User {
    name: string;
    address?: {
        street?: string;
        city?: string;
        zip?: string;
    };
}
 
// 安全な郵便番号取得パイプライン
function getFormattedZip(user: User | null): string {
    return Optional.of(user)
        .flatMap(u => Optional.of(u.address))
        .flatMap(a => Optional.of(a.zip))
        .filter(zip => /^\d{3}-?\d{4}$/.test(zip))
        .map(zip => zip.includes("-") ? zip : `${zip.slice(0,3)}-${zip.slice(3)}`)
        .getOrElse("郵便番号なし");
}
 
// テスト
const user1: User = { name: "太郎", address: { zip: "1000001" } };
const user2: User = { name: "花子" };
const user3: User | null = null;
 
console.log(getFormattedZip(user1));  // => "100-0001"
console.log(getFormattedZip(user2));  // => "郵便番号なし"
console.log(getFormattedZip(user3));  // => "郵便番号なし"

// 解答例
 
type EventHandler<T = unknown> = (data: T) => void;
 
interface ListenerEntry<T = unknown> {
    handler: EventHandler<T>;
    priority: number;
    once: boolean;
}
 
class EventBus<TEvents extends Record<string, unknown>> {
    private listeners = new Map<string, ListenerEntry[]>();
    private wildcardListeners: ListenerEntry<{ event: string; data: unknown }>[] = [];
 
    on<K extends keyof TEvents & string>(
        event: K,
        handler: EventHandler<TEvents[K]>,
        priority = 0,
    ): () => void {
        return this.addListener(event, handler, priority, false);
    }
 
    once<K extends keyof TEvents & string>(
        event: K,
        handler: EventHandler<TEvents[K]>,
        priority = 0,
    ): () => void {
        return this.addListener(event, handler, priority, true);
    }
 
    onAny(
        handler: EventHandler<{ event: string; data: unknown }>,
        priority = 0,
    ): () => void {
        const entry: ListenerEntry<{ event: string; data: unknown }> = {
            handler,
            priority,
            once: false,
        };
        this.wildcardListeners.push(entry);
        this.wildcardListeners.sort((a, b) => b.priority - a.priority);
        return () => {
            const idx = this.wildcardListeners.indexOf(entry);
            if (idx >= 0) this.wildcardListeners.splice(idx, 1);
        };
    }
 
    emit<K extends keyof TEvents & string>(event: K, data: TEvents[K]): void {
        // 通常リスナー
        const entries = this.listeners.get(event) || [];
        const remaining: ListenerEntry[] = [];
        for (const entry of entries) {
            entry.handler(data);
            if (!entry.once) remaining.push(entry);
        }
        this.listeners.set(event, remaining);
 
        // ワイルドカードリスナー
        for (const entry of this.wildcardListeners) {
            entry.handler({ event, data });
        }
    }
 
    private addListener(
        event: string,
        handler: EventHandler<any>,
        priority: number,
        once: boolean,
    ): () => void {
        const entry: ListenerEntry = { handler, priority, once };
        if (!this.listeners.has(event)) {
            this.listeners.set(event, []);
        }
        const entries = this.listeners.get(event)!;
        entries.push(entry);
        entries.sort((a, b) => b.priority - a.priority);
 
        return () => {
            const idx = entries.indexOf(entry);
            if (idx >= 0) entries.splice(idx, 1);
        };
    }
}
 
// 使用例
interface AppEvents {
    "user:login":  { userId: string; time: number };
    "user:logout": { userId: string };
    "error":       { code: number; message: string };
}
 
const bus = new EventBus<AppEvents>();
 
// 通常リスナー
const unsub = bus.on("user:login", (data) => {
    console.log(`ログイン: ${data.userId}`);
});
 
// 1回限りのリスナー
bus.once("error", (data) => {
    console.error(`エラー ${data.code}: ${data.message}`);
});
 
// ワイルドカードリスナー（全イベント監視）
bus.onAny(({ event, data }) => {
    console.log(`[監査ログ] ${event}:`, data);
});
 
bus.emit("user:login", { userId: "user-1", time: Date.now() });
unsub();  // リスナー解除