# "There should be one-- and preferably only one --obvious way to do it."
# 1つの正しいやり方があるべき
 
# Zen of Python（import this）
# Beautiful is better than ugly.
# Explicit is better than implicit.
# Simple is better than complex.
# Readability counts.
# Errors should never pass silently.
 
# 特徴: インデントで構造化、読みやすさ最優先
def process_data(data: list[dict]) -> list[str]:
    """アクティブなユーザー名を大文字で返す"""
    return [
        item["name"].upper()
        for item in data
        if item.get("active", False)
    ]
 
# コンテキストマネージャによるリソース管理
with open("data.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    records = [row for row in reader if row["status"] == "active"]
 
# デコレータによる横断的関心事の分離
from functools import lru_cache
 
@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
# ジェネレータで大規模データの遅延評価
def read_large_file(path: str):
    """メモリ効率の良い大規模ファイル読み込み"""
    with open(path, "r") as f:
        for line in f:
            yield line.strip()
 
# 型ヒントによるドキュメントとしての型情報（Python 3.12+）
type Point = tuple[float, float]
type Matrix[T] = list[list[T]]
 
def distance(p1: Point, p2: Point) -> float:
    return ((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) ** 0.5

# 1. EAFP (Easier to Ask Forgiveness than Permission)
#    許可を求めるより許しを乞う方が容易
 
# LBYL（他言語的アプローチ）- 推奨しない
if hasattr(obj, "name"):
    print(obj.name)
 
# EAFP（Python的アプローチ）- 推奨
try:
    print(obj.name)
except AttributeError:
    print("name属性がありません")
 
# 2. ダックタイピング
# 「アヒルのように歩き、アヒルのように鳴くなら、それはアヒルだ」
class Duck:
    def quack(self):
        return "ガーガー"
 
class Person:
    def quack(self):
        return "私はアヒルのように鳴けます"
 
def make_quack(thing):
    # Duck型かPerson型かは問わない。quack()メソッドがあればOK
    return thing.quack()
 
# 3. プロトコルによる構造的部分型（Python 3.8+）
from typing import Protocol
 
class Drawable(Protocol):
    def draw(self) -> None: ...
 
class Circle:
    def draw(self) -> None:
        print("○を描画")
 
def render(shape: Drawable) -> None:
    shape.draw()  # CircleはDrawableを明示的に継承していないがOK
 
# 4. データクラスによる簡潔なデータモデリング
from dataclasses import dataclass, field
from datetime import datetime
 
@dataclass(frozen=True)  # frozen=True でイミュータブル
class User:
    name: str
    email: str
    age: int
    created_at: datetime = field(default_factory=datetime.now)
    tags: list[str] = field(default_factory=list)
 
    def is_adult(self) -> bool:
        return self.age >= 18
 
# 5. 構造的パターンマッチ（Python 3.10+）
def handle_command(command: dict) -> str:
    match command:
        case {"action": "create", "name": str(name)}:
            return f"作成: {name}"
        case {"action": "delete", "id": int(id_)}:
            return f"削除: ID={id_}"
        case {"action": "list", "filter": {"status": status}}:
            return f"一覧: status={status}"
        case _:
            return "不明なコマンド"

# "Ruby is designed to make programmers happy."
# プログラマの幸福のために設計
 
# 特徴: 表現力豊か、すべてがオブジェクト
5.times { |i| puts i }
[1, 2, 3].select(&:odd?)  # → [1, 3]
"hello".reverse.upcase     # → "OLLEH"
 
# Convention over Configuration（Rails哲学）
 
# 数値もオブジェクト
3.14.round       # → 3
-42.abs          # → 42
1.upto(5) { |n| print n }  # → 12345
 
# シンボルとハッシュの簡潔さ
user = { name: "Alice", age: 30, active: true }
user[:name]  # → "Alice"
 
# ブロック・Proc・Lambda の豊かな表現力
# ブロック（最も一般的）
[1, 2, 3].map { |n| n * 2 }  # → [2, 4, 6]
 
# Proc（手続きオブジェクト）
doubler = Proc.new { |n| n * 2 }
[1, 2, 3].map(&doubler)  # → [2, 4, 6]
 
# Lambda（引数チェック付き手続き）
validator = ->(n) { n.positive? }
[1, -2, 3, -4].select(&validator)  # → [1, 3]
 
# メソッドミッシング（メタプログラミング）
class DynamicProxy
  def method_missing(name, *args)
    if name.to_s.start_with?("find_by_")
      attribute = name.to_s.sub("find_by_", "")
      puts "#{attribute}で検索: #{args.first}"
    else
      super
    end
  end
 
  def respond_to_missing?(name, include_private = false)
    name.to_s.start_with?("find_by_") || super
  end
end
 
proxy = DynamicProxy.new
proxy.find_by_name("Alice")   # → "nameで検索: Alice"
proxy.find_by_email("a@b.c")  # → "emailで検索: a@b.c"
 
# オープンクラス（既存クラスの拡張）
class Integer
  def factorial
    return 1 if self <= 1
    self * (self - 1).factorial
  end
end
 
5.factorial  # → 120
 
# Enumerableの豊かなメソッド群
users = [
  { name: "Alice", age: 30, dept: "Engineering" },
  { name: "Bob",   age: 25, dept: "Marketing" },
  { name: "Carol", age: 35, dept: "Engineering" },
  { name: "Dave",  age: 28, dept: "Marketing" }
]
 
# グループ化 → 各グループの平均年齢
users
  .group_by { |u| u[:dept] }
  .transform_values { |members| members.sum { |m| m[:age] }.to_f / members.size }
# → {"Engineering"=>32.5, "Marketing"=>26.5}
 
# パターンマッチ（Ruby 3.0+）
case { name: "Alice", age: 30, roles: [:admin, :user] }
in { name: String => name, roles: [*, :admin, *] }
  puts "管理者: #{name}"
in { name: String => name, age: (..17) }
  puts "未成年: #{name}"
else
  puts "一般ユーザー"
end

// Web のユビキタス言語
// ブラウザからサーバーまで1言語で
 
// TypeScript: JavaScript + 型安全性
interface User {
    name: string;
    age: number;
    email?: string;  // オプショナルプロパティ
}
 
const greet = (user: User): string => `Hello, ${user.name}!`;
 
// 特徴: イベント駆動、非同期が自然
const data = await fetch("/api").then(r => r.json());
 
// ユニオン型とリテラル型
type Status = "active" | "inactive" | "pending";
type Result<T> = { ok: true; value: T } | { ok: false; error: string };
 
function processResult<T>(result: Result<T>): T | never {
    if (result.ok) {
        return result.value;  // T型に絞り込み
    }
    throw new Error(result.error);
}
 
// ジェネリクスと条件型
type NonNullable<T> = T extends null | undefined ? never : T;
type Flatten<T> = T extends Array<infer U> ? U : T;
 
// テンプレートリテラル型
type EventName = `on${Capitalize<"click" | "focus" | "blur">}`;
// → "onClick" | "onFocus" | "onBlur"
 
// Mapped Types で型を動的に構築
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type Optional<T> = { [K in keyof T]?: T[K] };
 
// 非同期イテレータ
async function* fetchPages(baseUrl: string): AsyncGenerator<Page[]> {
    let page = 1;
    while (true) {
        const response = await fetch(`${baseUrl}?page=${page}`);
        const data = await response.json();
        if (data.items.length === 0) break;
        yield data.items;
        page++;
    }
}
 
// for await...of で消費
for await (const pages of fetchPages("/api/users")) {
    for (const user of pages) {
        console.log(user.name);
    }
}
 
// Proxy によるメタプログラミング
const validator = new Proxy<Record<string, unknown>>({}, {
    set(target, prop, value) {
        if (typeof prop === "string" && prop.startsWith("age")) {
            if (typeof value !== "number" || value < 0) {
                throw new TypeError(`${String(prop)} must be a positive number`);
            }
        }
        target[prop as string] = value;
        return true;
    }
});
 
// Decorator（TypeScript 5.0+, Stage 3）
function log(target: any, context: ClassMethodDecoratorContext) {
    return function(this: any, ...args: any[]) {
        console.log(`Calling ${String(context.name)} with`, args);
        const result = target.call(this, ...args);
        console.log(`Result:`, result);
        return result;
    };
}
 
class Calculator {
    @log
    add(a: number, b: number): number {
        return a + b;
    }
}

<?php
// PHP 8.3+: モダンPHP
// Webサーバーサイドの実用的な言語
 
// 列挙型（PHP 8.1+）
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
    case Pending = 'pending';
 
    public function label(): string {
        return match($this) {
            Status::Active => '有効',
            Status::Inactive => '無効',
            Status::Pending => '保留中',
        };
    }
}
 
// Readonly プロパティとコンストラクタプロモーション
class User {
    public function __construct(
        public readonly string $name,
        public readonly int $age,
        public readonly string $email,
        public readonly Status $status = Status::Active,
    ) {}
 
    public function isAdult(): bool {
        return $this->age >= 18;
    }
}
 
// 名前付き引数
$user = new User(
    name: 'Alice',
    age: 30,
    email: 'alice@example.com',
);
 
// ファーストクラスCallable構文（PHP 8.1+）
$users = [
    new User('Alice', 30, 'a@example.com'),
    new User('Bob', 17, 'b@example.com'),
    new User('Carol', 25, 'c@example.com'),
];
 
$adults = array_filter($users, fn(User $u) => $u->isAdult());
$names = array_map(fn(User $u) => $u->name, $adults);
 
// Fiber（PHP 8.1+）— 軽量な並行処理
$fiber = new Fiber(function (): void {
    $value = Fiber::suspend('fiber started');
    echo "受け取った値: $value\n";
});
 
$result = $fiber->start();  // → 'fiber started'
$fiber->resume('hello');     // → "受け取った値: hello"
 
// match式（PHP 8.0+）— switchの型安全版
function getStatusCode(string $method): int {
    return match($method) {
        'GET'    => 200,
        'POST'   => 201,
        'DELETE'  => 204,
        default  => throw new InvalidArgumentException("不明なメソッド: $method"),
    };
}
 
// Union型・Intersection型（PHP 8.0+/8.1+）
function processInput(string|int $input): string {
    return match(true) {
        is_string($input) => strtoupper($input),
        is_int($input)    => str_pad((string)$input, 5, '0', STR_PAD_LEFT),
    };
}
 
// Attribute（PHP 8.0+）— アノテーション
#[Route('/api/users', methods: ['GET'])]
#[Middleware('auth')]
function listUsers(): JsonResponse {
    // ...
}
 
// ジェネレータでメモリ効率の良い処理
function readCsv(string $path): Generator {
    $handle = fopen($path, 'r');
    $headers = fgetcsv($handle);
    while (($row = fgetcsv($handle)) !== false) {
        yield array_combine($headers, $row);
    }
    fclose($handle);
}
 
foreach (readCsv('large_file.csv') as $row) {
    // 1行ずつ処理（メモリに全件載せない）
    processRow($row);
}

#!/usr/bin/perl
use strict;
use warnings;
use v5.38;
 
# "There's More Than One Way To Do It" (TMTOWTDI)
# やり方は1つではない
 
# 正規表現のネイティブサポート（Perlの最大の強み）
my $email_pattern = qr/
    ^
    [a-zA-Z0-9._%+-]+    # ローカル部
    @                      # @記号
    [a-zA-Z0-9.-]+        # ドメイン
    \.                    # ドット
    [a-zA-Z]{2,}          # TLD
    $
/x;  # /x フラグで空白・コメントを許可
 
my $text = "Contact us at info\@example.com or support\@test.org";
my @emails = ($text =~ /[\w.+-]+@[\w.-]+\.\w{2,}/g);
say "Found: @emails";
 
# ワンライナーの力（コマンドラインでの文字列処理）
# perl -ne 'print if /ERROR/' access.log
# perl -pe 's/foo/bar/g' input.txt > output.txt
# perl -ane 'print "$F[0]\n"' data.tsv
 
# 正規表現によるテキスト変換
sub parse_log_line {
    my ($line) = @_;
    if ($line =~ /^(\d{4}-\d{2}-\d{2})\s+(\w+)\s+\[(\w+)\]\s+(.*)$/) {
        return {
            date    => $1,
            level   => $2,
            module  => $3,
            message => $4,
        };
    }
    return undef;
}
 
# ハッシュ（連想配列）の操作
my %config = (
    host    => 'localhost',
    port    => 8080,
    debug   => 1,
    workers => 4,
);
 
# ハッシュスライス
my @connection_info = @config{qw(host port)};
 
# リファレンスとデリファレンス
my $nested = {
    users => [
        { name => 'Alice', age => 30 },
        { name => 'Bob',   age => 25 },
    ],
    metadata => { total => 2, page => 1 },
};
 
say $nested->{users}[0]{name};  # → "Alice"
 
# Moose/Moo によるモダンなOOP
package User {
    use Moo;
    use Types::Standard qw(Str Int);
 
    has name  => (is => 'ro', isa => Str, required => 1);
    has age   => (is => 'ro', isa => Int, required => 1);
    has email => (is => 'rw', isa => Str);
 
    sub greet {
        my ($self) = @_;
        return "Hello, " . $self->name . "!";
    }
}

# Python: pip / uv / poetry
# --- requirements.txt ---
fastapi>=0.100.0
pydantic>=2.0.0
sqlalchemy>=2.0.0
 
# --- pyproject.toml (モダンなアプローチ) ---
# [project]
# name = "myapp"
# version = "0.1.0"
# dependencies = [
#     "fastapi>=0.100.0",
#     "pydantic>=2.0.0",
# ]
 
# uv（超高速パッケージマネージャ、Rust製）
# uv pip install fastapi
# uv venv
# uv sync

# Ruby: Bundler + Gemfile
# --- Gemfile ---
source 'https://rubygems.org'
 
gem 'rails', '~> 7.1'
gem 'pg', '~> 1.5'
gem 'puma', '~> 6.0'
 
group :development, :test do
  gem 'rspec-rails', '~> 6.0'
  gem 'rubocop', '~> 1.60'
end
 
# bundle install
# bundle exec rails server

// JavaScript: package.json (npm / pnpm / yarn)
{
  "name": "myapp",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "next": "^14.0.0",
    "react": "^18.2.0"
  },
  "devDependencies": {
    "typescript": "^5.3.0",
    "@types/react": "^18.2.0"
  },
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "lint": "eslint . --ext .ts,.tsx"
  }
}

// PHP: composer.json
{
    "require": {
        "php": "^8.2",
        "laravel/framework": "^11.0",
        "laravel/sanctum": "^4.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0",
        "phpstan/phpstan": "^1.10"
    },
    "autoload": {
        "psr-4": {
            "App\\": "app/"
        }
    }
}

# Python: pytest（最もポピュラー）
import pytest
from myapp.calculator import Calculator
 
class TestCalculator:
    @pytest.fixture
    def calc(self):
        return Calculator()
 
    def test_add(self, calc):
        assert calc.add(2, 3) == 5
 
    def test_divide_by_zero(self, calc):
        with pytest.raises(ZeroDivisionError):
            calc.divide(1, 0)
 
    @pytest.mark.parametrize("a, b, expected", [
        (1, 1, 2),
        (0, 0, 0),
        (-1, 1, 0),
        (100, 200, 300),
    ])
    def test_add_parametrized(self, calc, a, b, expected):
        assert calc.add(a, b) == expected

# Ruby: RSpec（BDD スタイル）
RSpec.describe Calculator do
  subject(:calc) { described_class.new }
 
  describe '#add' do
    it '2つの数を足す' do
      expect(calc.add(2, 3)).to eq(5)
    end
 
    context '負の数の場合' do
      it '正しく計算する' do
        expect(calc.add(-1, 1)).to eq(0)
      end
    end
  end
 
  describe '#divide' do
    it 'ゼロ除算でエラー' do
      expect { calc.divide(1, 0) }.to raise_error(ZeroDivisionError)
    end
  end
end
 
# Minitest（標準ライブラリ、軽量）
class TestCalculator < Minitest::Test
  def setup
    @calc = Calculator.new
  end
 
  def test_add
    assert_equal 5, @calc.add(2, 3)
  end
end

// TypeScript: Vitest / Jest
import { describe, it, expect } from 'vitest';
import { Calculator } from './calculator';
 
describe('Calculator', () => {
    const calc = new Calculator();
 
    it('should add two numbers', () => {
        expect(calc.add(2, 3)).toBe(5);
    });
 
    it('should throw on division by zero', () => {
        expect(() => calc.divide(1, 0)).toThrow('Division by zero');
    });
 
    it.each([
        [1, 1, 2],
        [0, 0, 0],
        [-1, 1, 0],
    ])('add(%i, %i) = %i', (a, b, expected) => {
        expect(calc.add(a, b)).toBe(expected);
    });
});

<?php
// PHP: PHPUnit
use PHPUnit\Framework\TestCase;
 
class CalculatorTest extends TestCase
{
    private Calculator $calc;
 
    protected function setUp(): void
    {
        $this->calc = new Calculator();
    }
 
    public function testAdd(): void
    {
        $this->assertSame(5, $this->calc->add(2, 3));
    }
 
    public function testDivideByZero(): void
    {
        $this->expectException(\DivisionByZeroError::class);
        $this->calc->divide(1, 0);
    }
 
    /**
     * @dataProvider additionProvider
     */
    public function testAddParametrized(int $a, int $b, int $expected): void
    {
        $this->assertSame($expected, $this->calc->add($a, $b));
    }
 
    public static function additionProvider(): array
    {
        return [
            [1, 1, 2],
            [0, 0, 0],
            [-1, 1, 0],
        ];
    }
}

# Python のパフォーマンス改善策
# 1. PyPy（JITコンパイラ実装） — CPython比で5-10倍高速
# 2. Cython（C拡張の自動生成）
# 3. NumPy/Polars（C/Rust実装のデータ処理）
# 4. asyncio（I/O並行処理）
# 5. multiprocessing（GIL回避のマルチプロセス）
# 6. Python 3.13+: Free-threaded Python（GIL除去実験）
 
# asyncio による並行 I/O
import asyncio
import aiohttp
 
async def fetch_all(urls: list[str]) -> list[str]:
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_one(session, url) for url in urls]
        return await asyncio.gather(*tasks)
 
async def fetch_one(session: aiohttp.ClientSession, url: str) -> str:
    async with session.get(url) as response:
        return await response.text()
 
# multiprocessing による CPU 並列処理
from multiprocessing import Pool
 
def heavy_computation(n: int) -> int:
    return sum(i * i for i in range(n))
 
with Pool(processes=4) as pool:
    results = pool.map(heavy_computation, [10**6, 10**6, 10**6, 10**6])

# Ruby のパフォーマンス改善策
# 1. YJIT (Yet Another JIT) — Ruby 3.1+ に統合、3.3で成熟
# 2. Ractor（並列処理、GVL回避）
# 3. Fiber Scheduler（非同期I/O）
 
# Ractor による並列処理（Ruby 3.0+）
ractors = 4.times.map do |i|
  Ractor.new(i) do |id|
    # 各Ractorは独立したGVLを持つ
    result = (1..1_000_000).sum
    [id, result]
  end
end
 
results = ractors.map(&:take)
puts results.inspect
 
# Fiber Scheduler による非同期I/O
require 'async'
 
Async do
  urls = ['https://example.com', 'https://example.org']
  tasks = urls.map do |url|
    Async do
      # 非ブロッキングHTTPリクエスト
      response = Net::HTTP.get(URI(url))
      response.length
    end
  end
  results = tasks.map(&:wait)
end

// Node.js のパフォーマンス特性
// V8エンジンのJITコンパイルにより、スクリプト言語で最高レベルの性能
 
// Worker Threads（CPU集約的処理の並列化）
import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
 
if (isMainThread) {
    const worker = new Worker(new URL(import.meta.url), {
        workerData: { start: 0, end: 1_000_000 }
    });
    worker.on('message', (result) => {
        console.log(`Result: ${result}`);
    });
} else {
    const { start, end } = workerData;
    let sum = 0;
    for (let i = start; i < end; i++) {
        sum += i * i;
    }
    parentPort.postMessage(sum);
}
 
// Stream APIによるメモリ効率の良い処理
import { createReadStream } from 'fs';
import { createInterface } from 'readline';
 
const rl = createInterface({
    input: createReadStream('large_file.txt'),
    crlfDelay: Infinity,
});
 
let lineCount = 0;
for await (const line of rl) {
    if (line.includes('ERROR')) {
        lineCount++;
    }
}
console.log(`Error lines: ${lineCount}`);

# Python: 型ヒント（実行時には無視される）
from typing import TypeVar, Generic, Protocol
 
T = TypeVar('T')
 
class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []
 
    def push(self, item: T) -> None:
        self._items.append(item)
 
    def pop(self) -> T:
        if not self._items:
            raise IndexError("Stack is empty")
        return self._items.pop()
 
    def peek(self) -> T:
        if not self._items:
            raise IndexError("Stack is empty")
        return self._items[-1]
 
# mypy / Pyright で静的チェック
stack: Stack[int] = Stack()
stack.push(42)
stack.push("hello")  # mypy: error: Argument 1 has incompatible type "str"
 
# TypedDict（辞書の型指定）
from typing import TypedDict, NotRequired
 
class UserDict(TypedDict):
    name: str
    age: int
    email: NotRequired[str]
 
def process_user(user: UserDict) -> str:
    return f"{user['name']} ({user['age']})"

// TypeScript: 高度な型システム
 
// Discriminated Unions（判別ユニオン）
type Shape =
    | { kind: "circle"; radius: number }
    | { kind: "rectangle"; width: number; height: number }
    | { kind: "triangle"; base: number; height: number };
 
function area(shape: Shape): number {
    switch (shape.kind) {
        case "circle":
            return Math.PI * shape.radius ** 2;
        case "rectangle":
            return shape.width * shape.height;
        case "triangle":
            return (shape.base * shape.height) / 2;
    }
    // TypeScript: exhaustiveness check（網羅性チェック）
}
 
// Template Literal Types
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type APIPath = `/api/${string}`;
type APIRoute = `${HTTPMethod} ${APIPath}`;
 
// Conditional Types + Infer
type ReturnTypeOf<T> = T extends (...args: any[]) => infer R ? R : never;
type ArrayElement<T> = T extends (infer E)[] ? E : never;
 
// Branded Types（ブランド型でプリミティブを区別）
type UserId = number & { readonly __brand: "UserId" };
type OrderId = number & { readonly __brand: "OrderId" };
 
function createUserId(id: number): UserId {
    return id as UserId;
}
 
function getUser(id: UserId): void { /* ... */ }
// getUser(createOrderId(1)); // コンパイルエラー！

<?php
// PHP: 型宣言の強化（PHP 8.0+）
declare(strict_types=1);
 
// Union型 + Intersection型
function processInput(string|int $input): string|int {
    return match(true) {
        is_string($input) => strtoupper($input),
        is_int($input) => $input * 2,
    };
}
 
// PHPStan / Psalm による高度な静的解析
/**
 * @template T
 * @param array<T> $items
 * @param callable(T): bool $predicate
 * @return array<T>
 */
function filter_items(array $items, callable $predicate): array {
    return array_values(array_filter($items, $predicate));
}
 
// DNF型（Disjunctive Normal Form, PHP 8.2+）
function process((Countable&Iterator)|null $input): int {
    if ($input === null) {
        return 0;
    }
    return count($input);
}

# Python: asyncio + aiohttp の実践例
import asyncio
import aiohttp
from dataclasses import dataclass
 
@dataclass
class FetchResult:
    url: str
    status: int
    body_length: int
 
async def fetch_url(session: aiohttp.ClientSession, url: str) -> FetchResult:
    async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
        body = await resp.text()
        return FetchResult(url=url, status=resp.status, body_length=len(body))
 
async def fetch_all(urls: list[str], concurrency: int = 10) -> list[FetchResult]:
    """セマフォで同時接続数を制限しつつ並行フェッチ"""
    semaphore = asyncio.Semaphore(concurrency)
 
    async def bounded_fetch(session: aiohttp.ClientSession, url: str) -> FetchResult:
        async with semaphore:
            return await fetch_url(session, url)
 
    async with aiohttp.ClientSession() as session:
        tasks = [bounded_fetch(session, url) for url in urls]
        return await asyncio.gather(*tasks, return_exceptions=True)
 
# 実行
urls = [f"https://httpbin.org/get?id={i}" for i in range(100)]
results = asyncio.run(fetch_all(urls, concurrency=20))

// TypeScript/Node.js: Promise.allSettled + 並行制御
interface FetchResult {
    url: string;
    status: number;
    bodyLength: number;
}
 
async function fetchWithConcurrency(
    urls: string[],
    concurrency: number = 10
): Promise<FetchResult[]> {
    const results: FetchResult[] = [];
 
    // chunks に分割して並行実行
    for (let i = 0; i < urls.length; i += concurrency) {
        const chunk = urls.slice(i, i + concurrency);
        const settled = await Promise.allSettled(
            chunk.map(async (url): Promise<FetchResult> => {
                const resp = await fetch(url);
                const body = await resp.text();
                return { url, status: resp.status, bodyLength: body.length };
            })
        );
 
        for (const result of settled) {
            if (result.status === "fulfilled") {
                results.push(result.value);
            } else {
                console.error(`Failed: ${result.reason}`);
            }
        }
    }
 
    return results;
}

# Python
def process_users(users: list[dict]) -> list[str]:
    return [
        user["name"].upper()
        for user in users
        if user.get("active", False)
    ]

// TypeScript（同じロジック）
interface User {
    name: string;
    active?: boolean;
}
 
function processUsers(users: User[]): string[] {
    return users
        .filter(user => user.active ?? false)
        .map(user => user.name.toUpperCase());
}

# Ruby
class UserService
  def initialize(repo)
    @repo = repo
  end
 
  def active_users
    @repo.all
         .select { |u| u.active? }
         .sort_by { |u| u.name }
         .map { |u| u.name.upcase }
  end
end

# Python（同じロジック）
class UserService:
    def __init__(self, repo):
        self._repo = repo
 
    def active_users(self) -> list[str]:
        users = self._repo.all()
        return sorted(
            [u.name.upper() for u in users if u.is_active()],
        )

<?php
// PHP
class UserService {
    public function __construct(
        private readonly UserRepository $repo,
    ) {}
 
    public function getActiveUsers(): array {
        $users = $this->repo->findAll();
        $active = array_filter($users, fn(User $u) => $u->isActive());
        $names = array_map(fn(User $u) => strtoupper($u->name), $active);
        sort($names);
        return $names;
    }
}

# Python（同じロジック）
class UserService:
    def __init__(self, repo: UserRepository) -> None:
        self._repo = repo
 
    def get_active_users(self) -> list[str]:
        users = self._repo.find_all()
        return sorted(
            u.name.upper() for u in users if u.is_active()
        )