@k2works/claude-code-booster 6.2.0 → 6.3.1

package/lib/assets/docs/article/functional-desgin-ppp/elixir/15-gossiping-bus-drivers.md

@@ -1,300 +0,0 @@
----
-type: Article
-title: "第15章: ゴシップ好きなバスの運転手"
-description: "「ゴシップ好きなバスの運転手」は、バス運転手が停留所で噂を共有するシミュレーション問題です。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第15章: ゴシップ好きなバスの運転手
-
-## はじめに
-
-「ゴシップ好きなバスの運転手」は、バス運転手が停留所で噂を共有するシミュレーション問題です。無限ストリーム（`Stream.cycle`）を使って循環ルートを表現し、集合演算（`MapSet`）で噂の伝播をモデル化します。
-
-## 1. 問題の概要
-
-- 複数のバス運転手がそれぞれのルートを循環する
-- 同じ停留所に居合わせたドライバー同士は噂を共有する
-- 全員が全ての噂を知るまでの時間を求める
-- 8時間（480分）以内に共有されない場合は `:never` を返す
-
-## 2. ドライバーの作成と操作
-
-### Driver 構造体
-
-```elixir
-defmodule Driver do
-  defstruct [:name, :route, :rumors]
-
-  def new(name, route, rumors) when is_list(route) do
-    %__MODULE__{
-      name: name,
-      route: Stream.cycle(route),  # 無限ストリームで循環ルート
-      rumors: MapSet.new(rumors)
-    }
-  end
-
-  def current_stop(%__MODULE__{route: route}) do
-    Enum.at(route, 0)
-  end
-
-  def move(%__MODULE__{route: route} = driver) do
-    %{driver | route: Stream.drop(route, 1)}
-  end
-
-  def set_rumors(%__MODULE__{} = driver, rumors) do
-    %{driver | rumors: rumors}
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# ドライバーを作成
-driver = Driver.new("Alice", [1, 2, 3], [:rumor_a])
-
-# 現在の停留所
-Driver.current_stop(driver)  #=> 1
-
-# 次の停留所に移動
-moved = Driver.move(driver)
-Driver.current_stop(moved)   #=> 2
-
-# ルートは循環する
-driver
-|> Driver.move()
-|> Driver.move()
-|> Driver.move()
-|> Driver.current_stop()     #=> 1（最初に戻る）
-```
-
-## 3. ワールド（世界）の操作
-
-### 停留所の集計
-
-```elixir
-defmodule World do
-  def get_stops(drivers) do
-    Enum.reduce(drivers, %{}, fn driver, stops ->
-      stop = Driver.current_stop(driver)
-      Map.update(stops, stop, [driver], &[driver | &1])
-    end)
-  end
-end
-```
-
-### 噂の伝播
-
-```elixir
-defmodule World do
-  def merge_rumors(drivers) when is_list(drivers) do
-    # 全ドライバーの噂を統合
-    all_rumors = Enum.reduce(drivers, MapSet.new(), fn driver, acc ->
-      MapSet.union(acc, driver.rumors)
-    end)
-
-    # 各ドライバーに統合された噂を設定
-    Enum.map(drivers, &Driver.set_rumors(&1, all_rumors))
-  end
-
-  def spread_rumors(drivers) do
-    stops = get_stops(drivers)
-
-    stops
-    |> Map.values()
-    |> Enum.flat_map(&merge_rumors/1)
-  end
-end
-```
-
-### 1ステップのシミュレーション
-
-```elixir
-def drive(drivers) do
-  drivers
-  |> move_drivers()      # 全員を移動
-  |> spread_rumors()     # 噂を伝播
-end
-
-def move_drivers(drivers) do
-  Enum.map(drivers, &Driver.move/1)
-end
-```
-
-## 4. シミュレーション実行
-
-### 収束判定
-
-```elixir
-def all_rumors_shared?(drivers) do
-  rumors_list = Enum.map(drivers, & &1.rumors)
-
-  case rumors_list do
-    [] -> true
-    [first | rest] -> Enum.all?(rest, &(&1 == first))
-  end
-end
-```
-
-### メインシミュレーション
-
-```elixir
-defmodule Simulation do
-  @max_steps 480  # 8時間
-
-  def run_until_spread(drivers) do
-    run_until_spread(World.drive(drivers), 1)
-  end
-
-  defp run_until_spread(_drivers, step) when step > @max_steps, do: :never
-  defp run_until_spread(drivers, step) do
-    if World.all_rumors_shared?(drivers) do
-      step
-    else
-      run_until_spread(World.drive(drivers), step + 1)
-    end
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# ドライバーを作成
-drivers = [
-  Driver.new("D1", [3, 1, 2, 3], [:r1]),
-  Driver.new("D2", [3, 2, 3, 1], [:r2]),
-  Driver.new("D3", [4, 2, 3, 4, 5], [:r3])
-]
-
-# シミュレーション実行
-steps = Simulation.run_until_spread(drivers)
-#=> 例: 5（5ステップで全噂が共有された）
-```
-
-## 5. 問題ソルバー
-
-```elixir
-defmodule Solver do
-  def solve(routes) when is_list(routes) do
-    drivers =
-      routes
-      |> Enum.with_index(1)
-      |> Enum.map(fn {route, idx} ->
-        rumor = String.to_atom("rumor_#{idx}")
-        Driver.new("Driver_#{idx}", route, [rumor])
-      end)
-
-    Simulation.run_until_spread(drivers)
-  end
-
-  def parse_and_solve(input) when is_binary(input) do
-    routes =
-      input
-      |> String.trim()
-      |> String.split("\n")
-      |> Enum.map(fn line ->
-        line
-        |> String.split()
-        |> Enum.map(&String.to_integer/1)
-      end)
-
-    solve(routes)
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# ルートリストから解く
-routes = [[3, 1, 2, 3], [3, 2, 3, 1], [4, 2, 3, 4, 5]]
-Solver.solve(routes)
-
-# テキスト入力から解く
-input = """
-3 1 2 3
-3 2 3 1
-4 2 3 4 5
-"""
-Solver.parse_and_solve(input)
-```
-
-## 6. 設計のポイント
-
-### 無限ストリームの活用
-
-`Stream.cycle/1` を使用することで、循環ルートを自然に表現できます。
-
-```elixir
-route = Stream.cycle([1, 2, 3])
-Enum.take(route, 7)  #=> [1, 2, 3, 1, 2, 3, 1]
-```
-
-### 不変データ構造
-
-ドライバーの状態は不変で、移動や噂の更新は常に新しい構造体を返します。
-
-```elixir
-# 元のドライバーは変更されない
-driver = Driver.new("Alice", [1, 2], [:a])
-moved = Driver.move(driver)
-
-Driver.current_stop(driver)  #=> 1（元のまま）
-Driver.current_stop(moved)   #=> 2（新しい状態）
-```
-
-### 集合演算による噂の統合
-
-`MapSet.union/2` を使用して、噂の統合を簡潔に表現できます。
-
-```elixir
-rumors1 = MapSet.new([:a, :b])
-rumors2 = MapSet.new([:b, :c])
-MapSet.union(rumors1, rumors2)  #=> MapSet.new([:a, :b, :c])
-```
-
-### 遅延評価
-
-`Stream` を使用することで、無限シーケンスでもメモリ効率良く処理できます。
-
-## 7. サンプル問題
-
-### 出会わないケース
-
-```elixir
-drivers = [
-  Driver.new("D1", [1], [:r1]),  # 停留所1に固定
-  Driver.new("D2", [2], [:r2])   # 停留所2に固定
-]
-
-Simulation.run_until_spread(drivers)  #=> :never
-```
-
-### すぐに出会うケース
-
-```elixir
-drivers = [
-  Driver.new("D1", [1, 2], [:r1]),
-  Driver.new("D2", [1, 3], [:r2]),
-  Driver.new("D3", [1, 4], [:r3])
-]
-
-# 全員が最初から停留所1にいるので、1ステップ目で噂が共有される
-Simulation.run_until_spread(drivers)  #=> 1
-```
-
-## まとめ
-
-この問題は以下の関数型プログラミングの概念を活用しています：
-
-1. **無限ストリーム**: `Stream.cycle` で循環ルートを表現
-2. **不変データ構造**: 状態変更は常に新しいデータを返す
-3. **集合演算**: `MapSet` で噂の統合を簡潔に実装
-4. **再帰とパターンマッチ**: シミュレーションの終了条件を明確に表現
-5. **高階関数**: `Enum.map`, `Enum.reduce`, `Enum.filter` でデータ変換
-
-Elixir の強力なストリーム処理と不変データ構造により、シミュレーション問題を宣言的に記述できます。

package/lib/assets/docs/article/functional-desgin-ppp/elixir/16-payroll-system.md

@@ -1,429 +0,0 @@
----
-type: Article
-title: "第16章: 給与計算システム"
-description: "給与計算システムは、従業員の給与計算と支払い処理を統合的に管理するシステムです。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第16章: 給与計算システム
-
-## はじめに
-
-給与計算システムは、従業員の給与計算と支払い処理を統合的に管理するシステムです。パターンマッチングによる多態性を活用して、異なる給与タイプに対応した計算ロジックを実装します。
-
-## 1. 従業員モデル
-
-### Employee 構造体
-
-```elixir
-defmodule Employee do
-  @type pay_type :: :salaried | :hourly | :commissioned
-  @type schedule :: :monthly | :weekly | :biweekly
-  @type payment_method :: :hold | :direct_deposit | :mail
-
-  defstruct [
-    :id,
-    :name,
-    :address,
-    :pay_class,
-    :schedule,
-    :payment_method
-  ]
-end
-```
-
-### 従業員の作成
-
-```elixir
-# 月給制従業員
-def make_salaried(id, name, salary) do
-  %Employee{
-    id: id,
-    name: name,
-    pay_class: {:salaried, salary},
-    schedule: :monthly,
-    payment_method: :hold
-  }
-end
-
-# 時給制従業員
-def make_hourly(id, name, hourly_rate) do
-  %Employee{
-    id: id,
-    name: name,
-    pay_class: {:hourly, hourly_rate},
-    schedule: :weekly,
-    payment_method: :hold
-  }
-end
-
-# 歩合制従業員
-def make_commissioned(id, name, base_pay, commission_rate) do
-  %Employee{
-    id: id,
-    name: name,
-    pay_class: {:commissioned, base_pay, commission_rate},
-    schedule: :biweekly,
-    payment_method: :hold
-  }
-end
-```
-
-### 使用例
-
-```elixir
-# 月給50万円の従業員
-salaried = Employee.make_salaried("E001", "田中太郎", 500_000)
-
-# 時給1500円の従業員
-hourly = Employee.make_hourly("E002", "佐藤花子", 1500)
-
-# 基本給20万円 + 売上の10%の従業員
-commissioned = Employee.make_commissioned("E003", "鈴木一郎", 200_000, 0.1)
-```
-
-## 2. 給与計算
-
-### パターンマッチングによる計算
-
-```elixir
-defmodule Classification do
-  # 月給制：そのまま月給を返す
-  def calc_pay(%Employee{pay_class: {:salaried, salary}}, _context) do
-    salary
-  end
-
-  # 時給制：タイムカードから計算（残業は1.5倍）
-  def calc_pay(%Employee{pay_class: {:hourly, hourly_rate}} = employee, context) do
-    time_cards = get_in(context, [:time_cards, Employee.get_id(employee)]) || []
-    hours = Enum.map(time_cards, fn {_date, hours} -> hours end)
-    total_hours = Enum.sum(hours)
-
-    regular_hours = min(total_hours, 40)
-    overtime_hours = max(0, total_hours - 40)
-
-    regular_hours * hourly_rate + overtime_hours * hourly_rate * 1.5
-  end
-
-  # 歩合制：基本給 + 売上 × コミッション率
-  def calc_pay(%Employee{pay_class: {:commissioned, base_pay, commission_rate}} = employee, context) do
-    sales_receipts = get_in(context, [:sales_receipts, Employee.get_id(employee)]) || []
-    total_sales = Enum.sum(Enum.map(sales_receipts, fn {_date, amount} -> amount end))
-
-    base_pay + total_sales * commission_rate
-  end
-end
-```
-
-### コンテキストの管理
-
-```elixir
-defmodule Classification do
-  def make_context do
-    %{
-      time_cards: %{},
-      sales_receipts: %{}
-    }
-  end
-
-  def add_time_card(context, employee_id, date, hours) do
-    update_in(context, [:time_cards, employee_id], fn
-      nil -> [{date, hours}]
-      cards -> [{date, hours} | cards]
-    end)
-  end
-
-  def add_sales_receipt(context, employee_id, date, amount) do
-    update_in(context, [:sales_receipts, employee_id], fn
-      nil -> [{date, amount}]
-      receipts -> [{date, amount} | receipts]
-    end)
-  end
-end
-```
-
-### 使用例
-
-```elixir
-# 時給制従業員の給与計算
-hourly = Employee.make_hourly("E002", "佐藤", 1500)
-ctx =
-  Classification.make_context()
-  |> Classification.add_time_card("E002", "2024-01-15", 8)
-  |> Classification.add_time_card("E002", "2024-01-16", 8)
-
-Classification.calc_pay(hourly, ctx)  #=> 24000.0
-
-# 残業を含む場合
-ctx_overtime =
-  Classification.make_context()
-  |> Classification.add_time_card("E002", "2024-01-15", 45)
-
-Classification.calc_pay(hourly, ctx_overtime)
-#=> 40 * 1500 + 5 * 1500 * 1.5 = 67500.0
-```
-
-## 3. 支払いスケジュール
-
-```elixir
-defmodule Schedule do
-  # 月給制：月末が支払日
-  def is_pay_day?(%Employee{schedule: :monthly}, date) do
-    is_last_day_of_month?(date)
-  end
-
-  # 時給制：毎週金曜日
-  def is_pay_day?(%Employee{schedule: :weekly}, date) do
-    Map.get(date, :day_of_week) == :friday
-  end
-
-  # 歩合制：隔週金曜日
-  def is_pay_day?(%Employee{schedule: :biweekly}, date) do
-    Map.get(date, :day_of_week) == :friday and
-      Map.get(date, :is_pay_week, false) == true
-  end
-
-  # 日付ファクトリ
-  def end_of_month(year, month), do: # ...
-  def friday(year, month, day), do: # ...
-  def pay_friday(year, month, day), do: # ...
-end
-```
-
-## 4. 支払い処理
-
-```elixir
-defmodule Payment do
-  def process(%Employee{payment_method: :hold} = employee, amount) do
-    %{
-      type: :hold,
-      employee_id: Employee.get_id(employee),
-      amount: amount,
-      message: "支払いを保留"
-    }
-  end
-
-  def process(%Employee{payment_method: :direct_deposit} = employee, amount) do
-    %{
-      type: :direct_deposit,
-      employee_id: Employee.get_id(employee),
-      amount: amount,
-      message: "口座に振り込み"
-    }
-  end
-
-  def process(%Employee{payment_method: :mail} = employee, amount) do
-    %{
-      type: :mail,
-      employee_id: Employee.get_id(employee),
-      amount: amount,
-      message: "小切手を郵送"
-    }
-  end
-end
-```
-
-## 5. 給与計算システム
-
-### Payroll モジュール
-
-```elixir
-defmodule Payroll do
-  def calculate_pay(employee, context) do
-    Classification.calc_pay(employee, context)
-  end
-
-  def calculate_payroll(employees, context) do
-    Enum.map(employees, fn emp ->
-      %{employee: emp, pay: calculate_pay(emp, context)}
-    end)
-  end
-
-  def run_payroll(employees, context, date) do
-    employees
-    |> Enum.filter(&Schedule.is_pay_day?(&1, date))
-    |> Enum.map(fn emp ->
-      pay = calculate_pay(emp, context)
-      Payment.process(emp, pay)
-    end)
-  end
-
-  def payroll_report(employees, context) do
-    payroll = calculate_payroll(employees, context)
-    total = Enum.sum(Enum.map(payroll, & &1.pay))
-
-    %{
-      employees: Enum.map(payroll, fn %{employee: emp, pay: pay} ->
-        %{
-          id: Employee.get_id(emp),
-          name: Employee.get_name(emp),
-          type: Employee.get_pay_type(emp),
-          pay: pay
-        }
-      end),
-      total: total,
-      count: length(employees)
-    }
-  end
-end
-```
-
-## 6. 従業員リポジトリ
-
-```elixir
-defmodule EmployeeRepository do
-  def start_link do
-    Agent.start_link(fn -> %{} end)
-  end
-
-  def add(pid, %Employee{} = employee) do
-    Agent.update(pid, &Map.put(&1, employee.id, employee))
-    {:ok, employee}
-  end
-
-  def get(pid, id) do
-    case Agent.get(pid, &Map.get(&1, id)) do
-      nil -> {:error, :not_found}
-      employee -> {:ok, employee}
-    end
-  end
-
-  def get_all(pid) do
-    Agent.get(pid, &Map.values(&1))
-  end
-
-  def update(pid, id, update_fn) do
-    Agent.get_and_update(pid, fn state ->
-      case Map.get(state, id) do
-        nil ->
-          {{:error, :not_found}, state}
-        employee ->
-          updated = update_fn.(employee)
-          {{:ok, updated}, Map.put(state, id, updated)}
-      end
-    end)
-  end
-
-  def delete(pid, id) do
-    Agent.get_and_update(pid, fn state ->
-      case Map.pop(state, id) do
-        {nil, state} -> {{:error, :not_found}, state}
-        {employee, state} -> {{:ok, employee}, state}
-      end
-    end)
-  end
-end
-```
-
-## 7. サービス層
-
-```elixir
-defmodule PayrollService do
-  defstruct [:repo, :context]
-
-  def new do
-    {:ok, repo} = EmployeeRepository.start_link()
-    %__MODULE__{
-      repo: repo,
-      context: Classification.make_context()
-    }
-  end
-
-  def add_salaried_employee(service, id, name, salary) do
-    employee = Employee.make_salaried(id, name, salary)
-    EmployeeRepository.add(service.repo, employee)
-  end
-
-  def add_time_card(%__MODULE__{context: ctx} = service, employee_id, date, hours) do
-    new_ctx = Classification.add_time_card(ctx, employee_id, date, hours)
-    %{service | context: new_ctx}
-  end
-
-  def run_payroll(service, date) do
-    employees = EmployeeRepository.get_all(service.repo)
-    Payroll.run_payroll(employees, service.context, date)
-  end
-
-  def payroll_report(service) do
-    employees = EmployeeRepository.get_all(service.repo)
-    Payroll.payroll_report(employees, service.context)
-  end
-end
-```
-
-## 8. 完全なワークフロー例
-
-```elixir
-# サービスを作成
-service = PayrollService.new()
-
-# 従業員を追加
-PayrollService.add_salaried_employee(service, "E001", "田中太郎", 500_000)
-PayrollService.add_hourly_employee(service, "E002", "佐藤花子", 1500)
-PayrollService.add_commissioned_employee(service, "E003", "鈴木一郎", 200_000, 0.1)
-
-# 支払い方法を変更
-PayrollService.change_payment_method(service, "E001", :direct_deposit)
-
-# タイムカードを追加
-service = PayrollService.add_time_card(service, "E002", "2024-01-15", 8)
-service = PayrollService.add_time_card(service, "E002", "2024-01-16", 8)
-
-# 売上レシートを追加
-service = PayrollService.add_sales_receipt(service, "E003", "2024-01-15", 100_000)
-
-# レポートを生成
-report = PayrollService.payroll_report(service)
-#=> %{count: 3, total: 722_000.0, employees: [...]}
-
-# 給与を支払い（月末）
-end_of_month = Schedule.end_of_month(2024, 1)
-payments = PayrollService.run_payroll(service, end_of_month)
-#=> 月給制従業員への支払いが処理される
-
-# クリーンアップ
-PayrollService.stop(service)
-```
-
-## 設計のポイント
-
-### パターンマッチングによる多態性
-
-Clojure のマルチメソッドに相当する機能を、Elixir ではパターンマッチングで実現しています。
-
-```elixir
-# 給与タイプごとに異なる計算ロジック
-def calc_pay(%Employee{pay_class: {:salaried, salary}}, _), do: salary
-def calc_pay(%Employee{pay_class: {:hourly, rate}}, ctx), do: # ...
-def calc_pay(%Employee{pay_class: {:commissioned, base, rate}}, ctx), do: # ...
-```
-
-### タプルによる分類データの表現
-
-```elixir
-pay_class: {:salaried, 500_000}
-pay_class: {:hourly, 1500}
-pay_class: {:commissioned, 200_000, 0.1}
-```
-
-### Agent による状態管理
-
-リポジトリは `Agent` を使用して状態を管理します。これにより、関数型の純粋性を保ちながら、必要な箇所でのみ状態を持つことができます。
-
-### コンテキストによる補助データの管理
-
-タイムカードや売上レシートは、コンテキスト（マップ）として管理し、必要に応じて給与計算に渡します。
-
-## まとめ
-
-給与計算システムは以下の関数型プログラミングの概念を活用しています：
-
-1. **パターンマッチング**: 給与タイプごとの計算ロジックを明確に分離
-2. **不変データ構造**: 従業員データの安全な管理
-3. **高階関数**: リスト処理の簡潔な実装
-4. **Agent**: 必要最小限の状態管理
-5. **パイプライン**: データ変換の連鎖的な処理
-
-Elixir のパターンマッチングと関数型の特性により、複雑なビジネスロジックを明確かつ保守しやすい形で実装できます。