@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/elixir/12-error-handling-and-with.md

@@ -1,154 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと with 構文"
-description: "この章では、Elixir で例外に頼りすぎず、値としてエラーを扱う方法を学びます。"
-tags: [article, getting-start-tdd, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 12 章: エラーハンドリングと with 構文
-
-## 12.1 はじめに
-
-この章では、Elixir で例外に頼りすぎず、値としてエラーを扱う方法を学びます。`{:ok, value}` / `{:error, reason}` の Result パターン、`with` 構文による連鎖処理、`try/rescue` との使い分けを整理します。
-
-## 12.2 タグ付きタプルによる Result パターン
-
-関数の成功と失敗を同じ型で返すと、呼び出し側が分岐を明示できます。
-
-```elixir
-defmodule FizzBuzz.Safe do
-  def safe_generate(number) when is_integer(number) and number > 0 do
-    {:ok, generate(number)}
-  end
-
-  def safe_generate(number) when is_integer(number) do
-    {:error, :non_positive}
-  end
-
-  def safe_generate(_), do: {:error, :not_integer}
-
-  defp generate(number) when rem(number, 15) == 0, do: "FizzBuzz"
-  defp generate(number) when rem(number, 3) == 0, do: "Fizz"
-  defp generate(number) when rem(number, 5) == 0, do: "Buzz"
-  defp generate(number), do: Integer.to_string(number)
-end
-```
-
-## 12.3 safe_generate/1 で安全な生成を行う
-
-`safe_generate/1` は例外を投げず、入力エラーを `{:error, reason}` で返します。これにより、関数合成時の失敗経路を追いやすくなります。
-
-```elixir
-defmodule FizzBuzz.SafeFacade do
-  alias FizzBuzz.Safe
-
-  def safe_generate_message(input) do
-    case Safe.safe_generate(input) do
-      {:ok, value} -> "result: #{value}"
-      {:error, reason} -> "error: #{reason}"
-    end
-  end
-end
-```
-
-## 12.4 with 構文でモナド的にエラーを連鎖する
-
-`with` は「途中で `{:error, reason}` が出たら即終了」の流れを簡潔に書けます。`safe_generate_list/1` では、各要素の検証と変換を連鎖します。
-
-```elixir
-defmodule FizzBuzz.SafeList do
-  alias FizzBuzz.Safe
-
-  def safe_generate_list(inputs) when is_list(inputs) do
-    inputs
-    |> Enum.reduce_while({:ok, []}, fn input, {:ok, acc} ->
-      with {:ok, value} <- Safe.safe_generate(input) do
-        {:cont, {:ok, acc ++ [value]}}
-      else
-        {:error, reason} -> {:halt, {:error, {:invalid_item, input, reason}}}
-      end
-    end)
-  end
-
-  def safe_generate_list(_), do: {:error, :not_list}
-end
-```
-
-## 12.5 try/rescue vs with の使い分け
-
-`with` は、想定内エラーをタグ付きタプルで扱うときに使います。`try/rescue` は、外部ライブラリや危険な処理で例外が発生しうるときに限定します。
-
-```elixir
-defmodule FizzBuzz.ExceptionBoundary do
-  alias FizzBuzz.Safe
-
-  def parse_and_generate(text) do
-    with {number, ""} <- Integer.parse(text),
-         {:ok, value} <- Safe.safe_generate(number) do
-      {:ok, value}
-    else
-      :error -> {:error, :parse_error}
-      {:error, reason} -> {:error, reason}
-    end
-  end
-
-  def parse_with_rescue(text) do
-    try do
-      number = String.to_integer(text)
-      Safe.safe_generate(number)
-    rescue
-      ArgumentError -> {:error, :parse_error}
-    end
-  end
-end
-```
-
-## 12.6 関数型エラーハンドリングの設計指針
-
-- ドメイン上で起こりうる失敗は、例外ではなく `{:error, reason}` で表現します。
-- `reason` は機械的に扱える atom や構造化データにします。
-- `with` は 2 段以上の処理連鎖で使い、`case` のネストを減らします。
-- 例外は境界層で捕捉し、内部では Result パターンへ正規化します。
-
-## 12.7 ExUnit でエラーハンドリングを検証する
-
-```elixir
-defmodule FizzBuzz.ErrorHandlingTest do
-  use ExUnit.Case, async: true
-
-  alias FizzBuzz.{ExceptionBoundary, Safe, SafeList}
-
-  test "safe_generate/1 は成功時に {:ok, value} を返す" do
-    assert Safe.safe_generate(15) == {:ok, "FizzBuzz"}
-  end
-
-  test "safe_generate/1 は入力エラーを {:error, reason} で返す" do
-    assert Safe.safe_generate(0) == {:error, :non_positive}
-    assert Safe.safe_generate("3") == {:error, :not_integer}
-  end
-
-  test "safe_generate_list/1 は全要素が正しければ一覧を返す" do
-    assert SafeList.safe_generate_list([1, 3, 5]) == {:ok, ["1", "Fizz", "Buzz"]}
-  end
-
-  test "safe_generate_list/1 は最初の不正要素で停止する" do
-    assert SafeList.safe_generate_list([1, -1, 3]) == {:error, {:invalid_item, -1, :non_positive}}
-  end
-
-  test "with を使った parse_and_generate/1 は parse エラーを返せる" do
-    assert ExceptionBoundary.parse_and_generate("abc") == {:error, :parse_error}
-    assert ExceptionBoundary.parse_and_generate("15") == {:ok, "FizzBuzz"}
-  end
-
-  test "try/rescue ベースの実装も同じ契約に揃えられる" do
-    assert ExceptionBoundary.parse_with_rescue("abc") == {:error, :parse_error}
-    assert ExceptionBoundary.parse_with_rescue("5") == {:ok, "Buzz"}
-  end
-end
-```
-
-## 12.8 まとめ
-
-この章では、`safe_generate/1` と `safe_generate_list/1` を通じて Result パターンと `with` 構文を使ったエラーハンドリングを確認しました。想定内エラーは値で返し、想定外例外は境界で `try/rescue` する設計にすると、関数型らしい見通しのよいコードになります。

package/lib/assets/docs/article/getting-start-tdd/elixir/index.md

@@ -1,35 +0,0 @@
-# テスト駆動開発から始める Elixir 入門
-
-## 概要
-
-FizzBuzz 問題を題材に、Elixir でテスト駆動開発を体験する。
-
-## 対象読者
-
-- プログラミング基礎を持ち、TDD や Elixir に興味がある開発者
-
-## 目次
-
-### 第 1 部: TDD の基本サイクル
-
-1. [01: TODO リストと最初のテスト](./01-todo-list-and-first-test.md)
-2. [02: 仮実装と三角測量](./02-fake-it-and-triangulation.md)
-3. [03: 明白な実装とリファクタリング](./03-obvious-implementation-and-refactoring.md)
-
-### 第 2 部: 開発環境と自動化
-
-1. [04: バージョン管理と Conventional Commits](./04-version-control-and-conventional-commits.md)
-2. [05: パッケージ管理と静的解析](./05-package-management-and-static-analysis.md)
-3. [06: タスクランナーと CI/CD](./06-task-runner-and-ci-cd.md)
-
-### 第 3 部: オブジェクト指向設計
-
-1. [07: 構造体とプロトコルによるポリモーフィズム](./07-structs-and-protocols.md)
-2. [08: パターンマッチとガード節](./08-pattern-matching-and-guards.md)
-3. [09: モジュール設計とビヘイビア](./09-module-design-and-behaviours.md)
-
-### 第 4 部: 関数型プログラミング
-
-1. [10: 高階関数とパイプライン演算子](./10-higher-order-functions-and-pipeline.md)
-2. [11: Stream と遅延評価](./11-stream-and-lazy-evaluation.md)
-3. [12: エラーハンドリングと with 構文](./12-error-handling-and-with.md)

package/lib/assets/docs/article/getting-start-tdd/fsharp/chapter01.md

@@ -1,211 +0,0 @@
----
-type: Article
-title: "第 1 章: TODO リストと最初のテスト"
-description: "プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して TODO リスト を作るところから始めます。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 1 章: TODO リストと最初のテスト
-
-## 1.1 はじめに
-
-プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して **TODO リスト** を作るところから始めます。
-
-> TODO リスト
->
-> 何をテストすべきだろうか——着手する前に、必要になりそうなテストをリストに書き出しておこう。
->
-> — テスト駆動開発
-
-## 1.2 仕様の確認
-
-今回取り組む FizzBuzz 問題の仕様は以下の通りです。
-
-```
-1 から 100 までの数をプリントするプログラムを書け。
-ただし 3 の倍数のときは数の代わりに「Fizz」と、5 の倍数のときは「Buzz」とプリントし、
-3 と 5 両方の倍数の場合には「FizzBuzz」とプリントすること。
-```
-
-この仕様をそのままプログラムに落とし込むには少しサイズが大きいですね。最初の作業は仕様を **TODO リスト** に分解する作業から着手しましょう。
-
-## 1.3 TODO リストの作成
-
-仕様を分解して TODO リストを作成します。
-
-**TODO リスト**:
-
-- [ ] 数を文字列にして返す
-  - [ ] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-まず「1 を渡したら文字列 "1" を返す」という、最も小さなタスクから取り掛かります。
-
-## 1.4 テスティングフレームワークの導入
-
-### テストファースト
-
-最初にプログラムする対象を決めたので、早速プロダクトコードを実装……ではなく **テストファースト** で作業を進めましょう。
-
-> テストファースト
->
-> いつテストを書くべきだろうか——それはテスト対象のコードを書く前だ。
->
-> — テスト駆動開発
-
-今回 F# のテスティングフレームワークには **xUnit** を利用します。xUnit は .NET エコシステムで広く使われているテスティングフレームワークです。
-
-### 開発環境のセットアップ
-
-dotnet CLI で F# プロジェクトを作成します。
-
-```bash
-# Nix 環境に入る
-$ nix develop .#dotnet
-
-# ライブラリプロジェクトの作成
-$ dotnet new classlib -lang F# -n FizzBuzzFSharp
-$ cd FizzBuzzFSharp
-
-# テストプロジェクトの作成
-$ cd ..
-$ dotnet new xunit -lang F# -n FizzBuzzFSharpTest
-$ cd FizzBuzzFSharpTest
-$ dotnet add reference ../FizzBuzzFSharp/FizzBuzzFSharp.fsproj
-```
-
-F# のテストは xUnit の `[<Fact>]` アトリビュートを付けた関数として記述します。関数名にはダブルバッククォートで囲むことで日本語を使用できます。
-
-### 環境確認テスト
-
-環境が正しく設定されていることを確認するため、学習用テストを書きます。
-
-```fsharp
-// Tests.fs
-module Tests
-
-open Xunit
-
-[<Fact>]
-let ``整数を文字列へ変換できる`` () =
-    Assert.Equal("42", string 42)
-```
-
-テストを実行します。
-
-```bash
-$ dotnet test
-  合計: 1、成功: 1、失敗: 0、スキップ: 0
-```
-
-テストが通りました。F# の `string` 関数が整数を文字列に変換できることを確認しました。`let` バインディングで関数を定義し、`Assert.Equal` で期待値と実際の値を比較します。
-
-## 1.5 仮実装
-
-テスト環境の準備ができたので、TODO リストの最初の作業に取り掛かりましょう。
-
-**TODO リスト**:
-
-- [ ] 数を文字列にして返す
-  - **1 を渡したら文字列 "1" を返す**
-
-まずはアサーションを最初に書きましょう。
-
-> アサートファースト
->
-> いつアサーションを書くべきだろうか——最初に書こう。
->
-> — テスト駆動開発
-
-### Red: 最初のテスト
-
-FizzBuzz のテストを書きます。
-
-```fsharp
-// Tests.fs
-module Tests
-
-open Xunit
-open FizzBuzzFSharp.FizzBuzz
-
-[<Fact>]
-let ``数を文字列にして返す_1を渡したら文字列1を返す`` () =
-    Assert.Equal("1", generate 1)
-```
-
-テストを実行します。
-
-```bash
-$ dotnet test
-error FS0039: 値またはコンストラクター 'generate' が定義されていません。
-```
-
-`generate` 関数がまだ定義されていないため、コンパイルエラーになります。これは期待通りの **Red** フェーズです。
-
-### Green: 仮実装
-
-テストを通すために **仮実装** から始めます。
-
-> 仮実装を経て本実装へ
->
-> 失敗するテストを書いてから、最初に行う実装はどのようなものだろうか——ベタ書きの値を返そう。
->
-> — テスト駆動開発
-
-`generate` 関数を定義して、文字列リテラルを返します。
-
-```fsharp
-// Library.fs
-namespace FizzBuzzFSharp
-
-module FizzBuzz =
-
-    let generate (number: int) : string =
-        "1"
-```
-
-テストを実行します。
-
-```bash
-$ dotnet test
-  合計: 1、成功: 1、失敗: 0、スキップ: 0
-```
-
-テストが通りました。F# では `let` バインディングで関数を定義します。`module` キーワードでモジュールを定義し、その中に関数をまとめます。型注釈 `(number: int) : string` は省略可能ですが、最初は明示することで意図を明確にします。
-
-**TODO リスト**:
-
-- [ ] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-ここまでの作業をバージョン管理システムにコミットしておきましょう。
-
-```bash
-$ git add .
-$ git commit -m 'test: 数を文字列にして返す'
-```
-
-## 1.6 まとめ
-
-この章では以下のことを学びました。
-
-- **TODO リスト** で仕様をプログラミング対象に分解する方法
-- **テストファースト** で最初にテストを書く考え方
-- F# プロジェクトのセットアップ（dotnet CLI、xUnit）
-- **仮実装** でベタ書きの値を返してテストを通す手法
-- F# の `let` バインディングによる関数定義
-- F# の `module` によるコードの構造化
-- ダブルバッククォートによるテスト関数名への日本語使用
-
-次章では、2 つ目のテストケースを追加して **三角測量** を行い、プログラムを一般化していきます。

package/lib/assets/docs/article/getting-start-tdd/fsharp/chapter02.md

@@ -1,255 +0,0 @@
----
-type: Article
-title: "第 2 章: 仮実装と三角測量"
-description: "前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 2 章: 仮実装と三角測量
-
-## 2.1 はじめに
-
-前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。この章では、**三角測量** によってプログラムを一般化し、さらに FizzBuzz のコアロジックを実装していきます。
-
-**TODO リスト**:
-
-- [ ] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-  - [ ] 2 を渡したら文字列 "2" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.2 三角測量
-
-1 を渡したら文字列 "1" を返すようにできました。では、2 を渡したらどうなるでしょうか？
-
-### Red: 2 つ目のテストを書く
-
-```fsharp
-[<Fact>]
-let ``数を文字列にして返す_2を渡したら文字列2を返す`` () =
-    Assert.Equal("2", generate 2)
-```
-
-テストを実行します。
-
-```bash
-$ dotnet test
-  Assert.Equal() Failure
-  Expected: "2"
-  Actual:   "1"
-```
-
-テストが失敗しました。文字列 "1" しか返さないプログラムなのですから当然です。
-
-### Green: 一般化する
-
-数値を文字列に変換して返すように修正します。F# では `string` 関数で整数を文字列に変換できます。
-
-```fsharp
-let generate (number: int) : string =
-    string number
-```
-
-テストを実行します。
-
-```bash
-$ dotnet test
-  合計: 2、成功: 2、失敗: 0、スキップ: 0
-```
-
-テストが通りました。2 つ目のテストによって `generate` 関数の一般化を実現できました。このようなアプローチを **三角測量** と言います。
-
-> 三角測量
->
-> テストから最も慎重に一般化を引き出すやり方はどのようなものだろうか——2 つ以上の例があるときだけ、一般化を行うようにしよう。
->
-> — テスト駆動開発
-
-Rust では `number.to_string()` と書くところを、F# では `string number` という組み込み関数を使います。F# の `string` 関数は Rust の `Display` トレイトに相当する機能で、多くの型を文字列に変換できます。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-  - [x] 2 を渡したら文字列 "2" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.3 3 の倍数 — Fizz
-
-次は「3 の倍数のときは数の代わりに Fizz と返す」に取り掛かります。
-
-### Red: 3 の倍数のテスト
-
-```fsharp
-[<Fact>]
-let ``三の倍数のときはFizzを返す`` () =
-    Assert.Equal("Fizz", generate 3)
-```
-
-```bash
-$ dotnet test
-  Assert.Equal() Failure
-  Expected: "Fizz"
-  Actual:   "3"
-```
-
-### Green: 明白な実装
-
-3 の倍数のときは "Fizz" を返すように実装します。F# では `%` 演算子で剰余を求め、`= 0` でゼロかどうかを判定します。
-
-```fsharp
-let generate (number: int) : string =
-    if number % 3 = 0 then "Fizz"
-    else string number
-```
-
-```bash
-$ dotnet test
-  合計: 3、成功: 3、失敗: 0、スキップ: 0
-```
-
-F# の `if/else` は式であり、常に値を返します。Rust の `if` 式や Kotlin の `when` 式と同様に、結果を変数にバインドしたりそのまま返したりできます。
-
-三角測量として 6 のテストも追加して確認します。
-
-```fsharp
-[<Fact>]
-let ``三の倍数のときはFizzを返す_6`` () =
-    Assert.Equal("Fizz", generate 6)
-```
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.4 5 の倍数 — Buzz
-
-### Red: 5 の倍数のテスト
-
-```fsharp
-[<Fact>]
-let ``五の倍数のときはBuzzを返す`` () =
-    Assert.Equal("Buzz", generate 5)
-```
-
-```bash
-$ dotnet test
-  Assert.Equal() Failure
-  Expected: "Buzz"
-  Actual:   "5"
-```
-
-### Green: Buzz の実装
-
-F# の `elif` キーワードで条件を追加します。
-
-```fsharp
-let generate (number: int) : string =
-    if number % 3 = 0 then "Fizz"
-    elif number % 5 = 0 then "Buzz"
-    else string number
-```
-
-```bash
-$ dotnet test
-  合計: 5、成功: 5、失敗: 0、スキップ: 0
-```
-
-F# では `else if` の代わりに `elif` を使います。Python の `elif` と同様の書き方です。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.5 15 の倍数 — FizzBuzz
-
-### Red: 15 の倍数のテスト
-
-```fsharp
-[<Fact>]
-let ``三と五の倍数のときはFizzBuzzを返す`` () =
-    Assert.Equal("FizzBuzz", generate 15)
-```
-
-```bash
-$ dotnet test
-  Assert.Equal() Failure
-  Expected: "FizzBuzz"
-  Actual:   "Fizz"
-```
-
-15 は 3 の倍数でもあるため、"Fizz" が返されてしまいました。3 と 5 の両方の倍数の判定を先に行う必要があります。
-
-### Green: FizzBuzz の実装
-
-```fsharp
-let generate (number: int) : string =
-    if number % 3 = 0 && number % 5 = 0 then "FizzBuzz"
-    elif number % 3 = 0 then "Fizz"
-    elif number % 5 = 0 then "Buzz"
-    else string number
-```
-
-```bash
-$ dotnet test
-  合計: 6、成功: 6、失敗: 0、スキップ: 0
-```
-
-F# の `&&` は論理 AND 演算子です。Rust や Java と同じ記号を使いますが、F# では等値比較に `=`（Rust は `==`）を使う点に注意してください。
-
-### パイプライン演算子の紹介
-
-ここで F# の特徴的な機能である **パイプライン演算子** `|>` を紹介します。パイプライン演算子は値を関数に渡すための構文で、Unix のパイプ `|` と同様にデータの流れを左から右に読めるようにします。
-
-```fsharp
-// 通常の関数呼び出し
-string 42
-
-// パイプライン演算子を使った呼び出し
-42 |> string
-```
-
-この段階ではまだ活用しませんが、次章以降で FizzBuzz のリファクタリングに活用します。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.6 まとめ
-
-この章では以下のことを学びました。
-
-- **三角測量** で 2 つ以上の例を使ってプログラムを一般化する手法
-- F# の `string` 関数による整数から文字列への変換
-- F# の `%` 演算子による剰余判定
-- F# の `if/elif/else` 式による条件分岐
-- F# の `&&` 演算子と `=` 演算子
-- **パイプライン演算子** `|>` の基本概念
-- Red-Green-Refactor サイクルを繰り返してコアロジックを段階的に構築する方法
-
-次章では、残りの TODO（リスト生成とプリント）を実装し、リファクタリングで「動作するきれいなコード」を目指します。