@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/haskell/02-fake-it-and-triangulation.md

@@ -1,346 +0,0 @@
----
-type: Article
-title: "第 2 章: 仮実装と三角測量"
-description: "前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。"
-tags: [article, getting-start-tdd, haskell]
-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 つ目のテストを書く
-
-```haskell
-    it "2 を渡すと '2' を返す" $
-      generate 2 `shouldBe` "2"
-```
-
-テストを実行します。
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す FAILED [1]
-
-Failures:
-
-  test/FizzBuzz/FizzBuzzSpec.hs:12:7:
-  1) generate 2 を渡すと '2' を返す
-       expected: "2"
-        but got: "1"
-
-2 examples, 1 failure
-```
-
-テストが失敗しました。文字列 "1" しか返さないプログラムなのですから当然です。
-
-### Green: 一般化する
-
-数値を文字列に変換して返すように修正します。Haskell では `show` 関数で `Show` 型クラスのインスタンスを文字列に変換できます。
-
-```haskell
-generate :: Int -> String
-generate n = show n
-```
-
-テストを実行します。
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-
-Finished in 0.0001 seconds
-2 examples, 0 failures
-```
-
-テストが通りました。2 つ目のテストによって `generate` 関数の一般化を実現できました。このようなアプローチを **三角測量** と言います。
-
-> 三角測量
->
-> テストから最も慎重に一般化を引き出すやり方はどのようなものだろうか——2 つ以上の例があるときだけ、一般化を行うようにしよう。
->
-> — テスト駆動開発
-
-Rust では `number.to_string()` と書くところを、Haskell では `show n` を使います。Haskell の `show` は `Show` 型クラスを実装した任意の型で利用でき、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 の倍数のテスト
-
-```haskell
-    it "3 の倍数を渡すと 'Fizz' を返す" $
-      generate 3 `shouldBe` "Fizz"
-```
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-    3 の倍数を渡すと 'Fizz' を返す FAILED [1]
-
-Failures:
-
-  test/FizzBuzz/FizzBuzzSpec.hs:15:7:
-  1) generate 3 の倍数を渡すと 'Fizz' を返す
-       expected: "Fizz"
-        but got: "3"
-
-3 examples, 1 failure
-```
-
-### Green: ガード式による条件分岐
-
-3 の倍数のときは "Fizz" を返すように実装します。Haskell では **ガード式** を使って条件分岐を記述します。
-
-```haskell
-generate :: Int -> String
-generate n
-  | n `mod` 3 == 0 = "Fizz"
-  | otherwise       = show n
-```
-
-ガード式は `|` の後に条件を書き、`=` の後に条件が真のときの返り値を記述します。`otherwise` は常に `True` を返す定数で、すべての条件に合致しなかった場合のデフォルトケースとして機能します。`mod` 関数はバッククォートで囲むことで中置演算子として使えます（`n `mod` 3` は `mod n 3` と同じ意味です）。
-
-Rust の `if` 式や `match` 式に比べ、Haskell のガード式は数学的な関数定義に近い書き方ができます。
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-    3 の倍数を渡すと 'Fizz' を返す
-
-Finished in 0.0001 seconds
-3 examples, 0 failures
-```
-
-テストが通りました。三角測量として 6 のテストも追加して確認します。
-
-```haskell
-    it "6 を渡すと 'Fizz' を返す" $
-      generate 6 `shouldBe` "Fizz"
-```
-
-```bash
-$ stack test
-4 examples, 0 failures
-```
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.4 5 の倍数 -- Buzz
-
-### Red: 5 の倍数のテスト
-
-```haskell
-    it "5 の倍数を渡すと 'Buzz' を返す" $
-      generate 5 `shouldBe` "Buzz"
-```
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    5 の倍数を渡すと 'Buzz' を返す FAILED [1]
-
-Failures:
-
-  test/FizzBuzz/FizzBuzzSpec.hs:21:7:
-  1) generate 5 の倍数を渡すと 'Buzz' を返す
-       expected: "Buzz"
-        but got: "5"
-
-5 examples, 1 failure
-```
-
-### Green: Buzz の実装
-
-ガード式に 5 の倍数の条件を追加します。
-
-```haskell
-generate :: Int -> String
-generate n
-  | n `mod` 3 == 0 = "Fizz"
-  | n `mod` 5 == 0 = "Buzz"
-  | otherwise       = show n
-```
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-    3 の倍数を渡すと 'Fizz' を返す
-    5 の倍数を渡すと 'Buzz' を返す
-    6 を渡すと 'Fizz' を返す
-
-Finished in 0.0001 seconds
-5 examples, 0 failures
-```
-
-三角測量として 10 のテストも追加します。
-
-```haskell
-    it "10 を渡すと 'Buzz' を返す" $
-      generate 10 `shouldBe` "Buzz"
-```
-
-```bash
-$ stack test
-6 examples, 0 failures
-```
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 2.5 15 の倍数 -- FizzBuzz
-
-### Red: 15 の倍数のテスト
-
-```haskell
-    it "15 の倍数を渡すと 'FizzBuzz' を返す" $
-      generate 15 `shouldBe` "FizzBuzz"
-```
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    15 の倍数を渡すと 'FizzBuzz' を返す FAILED [1]
-
-Failures:
-
-  test/FizzBuzz/FizzBuzzSpec.hs:27:7:
-  1) generate 15 の倍数を渡すと 'FizzBuzz' を返す
-       expected: "FizzBuzz"
-        but got: "Fizz"
-
-7 examples, 1 failure
-```
-
-15 は 3 の倍数でもあるため、"Fizz" が返されてしまいました。ガード式は上から順番に評価されるので、3 の倍数の条件に先にマッチしてしまいます。3 と 5 の両方の倍数（つまり 15 の倍数）の判定を **先に** 行う必要があります。
-
-### Green: ガード式の順序を修正
-
-```haskell
-generate :: Int -> String
-generate n
-  | n `mod` 15 == 0 = "FizzBuzz"
-  | n `mod` 3 == 0  = "Fizz"
-  | n `mod` 5 == 0  = "Buzz"
-  | otherwise        = show n
-```
-
-ガード式は上から順に評価されるため、最も限定的な条件（15 の倍数）を最初に配置します。これは Rust の `match` 式のパターンの並び順や、Go の `switch` 文の `case` の順序と同じ考え方です。
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-    3 の倍数を渡すと 'Fizz' を返す
-    5 の倍数を渡すと 'Buzz' を返す
-    6 を渡すと 'Fizz' を返す
-    10 を渡すと 'Buzz' を返す
-    15 の倍数を渡すと 'FizzBuzz' を返す
-
-Finished in 0.0001 seconds
-7 examples, 0 failures
-```
-
-三角測量として 30 のテストも追加しておきます。
-
-```haskell
-    it "30 を渡すと 'FizzBuzz' を返す" $
-      generate 30 `shouldBe` "FizzBuzz"
-```
-
-```bash
-$ stack test
-8 examples, 0 failures
-```
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-ここまでの作業をコミットしておきましょう。
-
-```bash
-$ git add .
-$ git commit -m 'feat: FizzBuzz のコアロジックを実装'
-```
-
-## 2.6 まとめ
-
-この章では以下のことを学びました。
-
-- **三角測量** で 2 つ以上の例を使ってプログラムを一般化する手法
-- Haskell の `show` 関数による整数から文字列への変換
-- Haskell の `mod` 関数と中置記法（`` n `mod` 3 ``）による剰余判定
-- **ガード式** による条件分岐の記述（`|` と `otherwise`）
-- ガード式の **評価順序** の重要性（限定的な条件を先に配置）
-- Red-Green-Refactor サイクルを繰り返してコアロジックを段階的に構築する方法
-
-次章では、残りの TODO（リスト生成）を実装し、リファクタリングで「動作するきれいなコード」を目指します。

package/lib/assets/docs/article/getting-start-tdd/haskell/03-obvious-implementation-and-refactoring.md

@@ -1,266 +0,0 @@
----
-type: Article
-title: "第 3 章: 明白な実装とリファクタリング"
-description: "前章では、三角測量とガード式で FizzBuzz のコアロジックを完成させました。"
-tags: [article, getting-start-tdd, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 3 章: 明白な実装とリファクタリング
-
-## 3.1 はじめに
-
-前章では、三角測量とガード式で FizzBuzz のコアロジックを完成させました。この章では、残りの TODO（リスト生成）を実装し、リファクタリングで「動作するきれいなコード」を目指します。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-
-## 3.2 1 から 100 までのリスト生成
-
-### Red: リスト生成のテスト
-
-1 から指定した数までの FizzBuzz の結果をリストとして返す `generateList` 関数をテストします。
-
-```haskell
-  describe "generateList" $ do
-    it "100 件のリストを生成する" $
-      length (generateList 100) `shouldBe` 100
-
-    it "最初の要素は '1'" $
-      generateList 100 !! 0 `shouldBe` "1"
-
-    it "3 番目の要素は 'Fizz'" $
-      generateList 100 !! 2 `shouldBe` "Fizz"
-
-    it "5 番目の要素は 'Buzz'" $
-      generateList 100 !! 4 `shouldBe` "Buzz"
-
-    it "15 番目の要素は 'FizzBuzz'" $
-      generateList 100 !! 14 `shouldBe` "FizzBuzz"
-```
-
-`!!` は Haskell のリストのインデックスアクセス演算子で、0 始まりです。Rust の `result[0]` や Go の `result[0]` に相当します。
-
-```bash
-$ stack test
-error:
-    Variable not in scope: generateList :: Int -> [String]
-```
-
-`generateList` がまだ定義されていないため、コンパイルエラーになります。Haskell は静的型付け言語なので、関数が存在しないとコンパイルの段階でエラーが報告されます。
-
-### Green: 明白な実装
-
-ここでは **明白な実装** を適用します。`map` 関数を使って、リストの各要素に `generate` を適用します。
-
-> 明白な実装
->
-> シンプルな操作を実現するにはどうすればいいだろうか——そのまま実装しよう。
->
-> — テスト駆動開発
-
-まず `src/FizzBuzz.hs` にモジュールエクスポートと関数を追加します。
-
-```haskell
--- src/FizzBuzz.hs
-module FizzBuzz
-  ( generate
-  , generateList
-  ) where
-
-generate :: Int -> String
-generate n
-  | n `mod` 15 == 0 = "FizzBuzz"
-  | n `mod` 3 == 0  = "Fizz"
-  | n `mod` 5 == 0  = "Buzz"
-  | otherwise        = show n
-
-generateList :: Int -> [String]
-generateList n = map generate [1..n]
-```
-
-`[1..n]` は Haskell の **リスト内包表記**（正確にはリストの算術列）で、1 から `n` までの整数リストを生成します。`map generate [1..n]` は、このリストの各要素に `generate` 関数を適用し、新しいリストを返します。
-
-Rust の `(1..=n).map(generate).collect()` と比べると、Haskell ではリストが遅延評価されるため `collect()` のような明示的な変換が不要です。`map` は関数型プログラミングの基本操作であり、Haskell ではリスト操作のほとんどが `map`、`filter`、`fold` の組み合わせで記述できます。
-
-```bash
-$ stack test
-FizzBuzz.FizzBuzzSpec
-  generate
-    1 を渡すと '1' を返す
-    2 を渡すと '2' を返す
-    3 の倍数を渡すと 'Fizz' を返す
-    5 の倍数を渡すと 'Buzz' を返す
-    6 を渡すと 'Fizz' を返す
-    10 を渡すと 'Buzz' を返す
-    15 の倍数を渡すと 'FizzBuzz' を返す
-    30 を渡すと 'FizzBuzz' を返す
-  generateList
-    100 件のリストを生成する
-    最初の要素は '1'
-    3 番目の要素は 'Fizz'
-    5 番目の要素は 'Buzz'
-    15 番目の要素は 'FizzBuzz'
-
-Finished in 0.0001 seconds
-13 examples, 0 failures
-```
-
-すべてのテストが通りました。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [x] 1 から 100 までの数
-- [ ] プリントする
-
-## 3.3 プリント機能
-
-プリント機能は、生成したリストの各要素を標準出力に出力するものです。Haskell の `main` 関数で `generateList` の結果を出力する形になります。
-
-```haskell
--- app/Main.hs
-module Main where
-
-import FizzBuzz (generateList)
-
-main :: IO ()
-main = mapM_ putStrLn (generateList 100)
-```
-
-`mapM_` は `map` のモナド版で、各要素にアクション（ここでは `putStrLn`）を適用し、結果を捨てます。`putStrLn` は文字列を 1 行出力する IO アクションです。Haskell では副作用（画面出力など）は `IO` モナドの中で行われ、純粋な関数（`generate`、`generateList`）とは明確に分離されます。
-
-**TODO リスト**:
-
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [x] 1 から 100 までの数
-- [x] プリントする
-
-## 3.4 リファクタリング
-
-テスト駆動開発の流れを確認しておきましょう。
-
-> 1. レッド：動作しない、おそらく最初のうちはコンパイルも通らないテストを 1 つ書く。
-> 2. グリーン：そのテストを迅速に動作させる。このステップでは罪を犯してもよい。
-> 3. リファクタリング：テストを通すために発生した重複をすべて除去する。
->
-> レッド・グリーン・リファクタリング。それが TDD のマントラだ。
->
-> — テスト駆動開発
-
-### プロダクトコードの確認
-
-最終的な `src/FizzBuzz.hs` を確認します。
-
-```haskell
-module FizzBuzz
-  ( generate
-  , generateList
-  ) where
-
-generate :: Int -> String
-generate n
-  | n `mod` 15 == 0 = "FizzBuzz"
-  | n `mod` 3 == 0  = "Fizz"
-  | n `mod` 5 == 0  = "Buzz"
-  | otherwise        = show n
-
-generateList :: Int -> [String]
-generateList n = map generate [1..n]
-```
-
-Haskell のコードは非常に簡潔です。注目すべきポイントは以下の通りです。
-
-- **型シグネチャ**: `generate :: Int -> String` と `generateList :: Int -> [String]` により、関数の入出力の型が明確に宣言されています。Haskell では型推論が強力なため型シグネチャは省略可能ですが、トップレベル関数には明示的に書くのがベストプラクティスです。
-- **モジュールエクスポート**: `module FizzBuzz (generate, generateList) where` で、外部に公開する関数を明示的に列挙しています。エクスポートリストを省略するとすべてが公開されますが、情報隠蔽の観点から明示的に指定します。
-- **純粋関数**: `generate` と `generateList` はどちらも純粋関数です。副作用がなく、同じ入力に対して常に同じ出力を返します。これによりテストが非常に書きやすくなっています。
-
-### テストコードの確認
-
-最終的な `test/FizzBuzz/FizzBuzzSpec.hs` を確認します。
-
-```haskell
-module FizzBuzz.FizzBuzzSpec (spec) where
-
-import Test.Hspec
-import FizzBuzz
-
-spec :: Spec
-spec = do
-  describe "generate" $ do
-    it "1 を渡すと '1' を返す" $
-      generate 1 `shouldBe` "1"
-
-    it "2 を渡すと '2' を返す" $
-      generate 2 `shouldBe` "2"
-
-    it "3 の倍数を渡すと 'Fizz' を返す" $
-      generate 3 `shouldBe` "Fizz"
-
-    it "5 の倍数を渡すと 'Buzz' を返す" $
-      generate 5 `shouldBe` "Buzz"
-
-    it "15 の倍数を渡すと 'FizzBuzz' を返す" $
-      generate 15 `shouldBe` "FizzBuzz"
-
-    it "30 を渡すと 'FizzBuzz' を返す" $
-      generate 30 `shouldBe` "FizzBuzz"
-
-  describe "generateList" $ do
-    it "100 件のリストを生成する" $
-      length (generateList 100) `shouldBe` 100
-
-    it "最初の要素は '1'" $
-      generateList 100 !! 0 `shouldBe` "1"
-
-    it "3 番目の要素は 'Fizz'" $
-      generateList 100 !! 2 `shouldBe` "Fizz"
-
-    it "5 番目の要素は 'Buzz'" $
-      generateList 100 !! 4 `shouldBe` "Buzz"
-
-    it "15 番目の要素は 'FizzBuzz'" $
-      generateList 100 !! 14 `shouldBe` "FizzBuzz"
-```
-
-HSpec の `describe` と `it` による階層構造で、テストが仕様書のように読めます。`shouldBe` は `Eq` 型クラスと `Show` 型クラスを利用して値を比較・表示するため、テスト失敗時のエラーメッセージも分かりやすいものになります。
-
-## 3.5 他言語との比較
-
-| 概念 | Java | Python | TypeScript | Ruby | Go | Rust | Haskell |
-|------|------|--------|-----------|------|------|------|---------|
-| テストフレームワーク | JUnit 5 | pytest | Vitest | Minitest | testing（標準） | cargo test（標準） | HSpec |
-| テスト実行 | `./gradlew test` | `pytest` | `npx vitest` | `bundle exec rake test` | `go test ./...` | `cargo test` | `stack test` |
-| 文字列変換 | `String.valueOf(n)` | `str(n)` | `n.toString()` | `n.to_s` | `strconv.Itoa(n)` | `n.to_string()` | `show n` |
-| 剰余判定 | `n % 3 == 0` | `n % 3 == 0` | `n % 3 === 0` | `(n % 3).zero?` | `n%3 == 0` | `n % 3 == 0` | `` n `mod` 3 == 0 `` |
-| 条件分岐 | `if-else` | `if-elif` | `if-else` | `case-when` | `switch` | `match` | ガード式 |
-| リスト生成 | `IntStream.rangeClosed` | `[f(n) for n in range]` | `Array.from({length})` | `(1..100).map { }` | `for` + `append` | `(1..=100).map(f).collect()` | `map f [1..n]` |
-
-## 3.6 まとめ
-
-この章では以下のことを学びました。
-
-- **明白な実装** でシンプルな操作をそのまま実装する手法
-- Haskell の `map` 関数と `[1..n]` によるリスト生成
-- `!!` 演算子によるリストのインデックスアクセス
-- `mapM_` と `putStrLn` による IO アクションの実行
-- Haskell の **純粋関数** と **IO モナド** の分離
-- **型シグネチャ** と **モジュールエクスポート** によるコードの明確化
-- Red-Green-Refactor サイクルの完了
-
-第 1 部の 3 章を通じて、TDD の基本サイクル（仮実装 → 三角測量 → 明白な実装 → リファクタリング）を一通り体験しました。Haskell の純粋関数型プログラミングでは、副作用のない関数が基本となるため、TDD との相性が非常に良いことが分かりました。入力を与えて出力を検証するだけでテストが完結し、モック・スタブなどのテストダブルを必要としません。
-
-次の第 2 部では、開発環境の自動化（バージョン管理、パッケージ管理、CI/CD）に進みます。