@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,231 +0,0 @@
----
-type: Article
-title: "第 9 章: モジュール設計と型による設計"
-description: "前章では判別共用体とパターンマッチを導入しました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 9 章: モジュール設計と型による設計
-
-## 9.1 はじめに
-
-前章では判別共用体とパターンマッチを導入しました。この章では、FizzBuzz プログラム全体を **モジュール分割** し、**型による設計（Type-Driven Design）** でアーキテクチャを整理します。
-
-## 9.2 現在のコード構造の課題
-
-これまでの実装では、すべてのコードが 1 つのモジュールに集約されています。プログラムの規模が大きくなると以下の課題が生じます。
-
-- **責務の混在**: ドメインロジックとアプリケーションロジックが分離されていない
-- **再利用性の低下**: 特定の機能だけを利用することが困難
-- **テストの複雑化**: 依存関係が絡み合いテストが書きにくい
-
-## 9.3 モジュール分割
-
-### Domain モジュール
-
-ビジネスルールとデータ型を定義するモジュールです。
-
-```fsharp
-module Domain =
-
-    // 値オブジェクト
-    type FizzBuzzValue =
-        { Number: int
-          Value: string }
-
-        override this.ToString() = sprintf "%d:%s" this.Number this.Value
-
-    let createValue number value = { Number = number; Value = value }
-
-    // 判別共用体
-    type FizzBuzzType =
-        | Standard
-        | NumberOnly
-        | FizzBuzzOnly
-
-    // ドメインロジック
-    let private isFizz number = number % 3 = 0
-    let private isBuzz number = number % 5 = 0
-    let private isFizzBuzz number = isFizz number && isBuzz number
-
-    let generate (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
-        match fizzBuzzType with
-        | Standard ->
-            if isFizzBuzz number then createValue number "FizzBuzz"
-            elif isFizz number then createValue number "Fizz"
-            elif isBuzz number then createValue number "Buzz"
-            else createValue number (string number)
-        | NumberOnly ->
-            createValue number (string number)
-        | FizzBuzzOnly ->
-            if number % 15 = 0 then createValue number "FizzBuzz"
-            else createValue number (string number)
-```
-
-### FizzBuzzList 型
-
-FizzBuzzValue のコレクションを専用の型でラップする **ファーストクラスコレクション** を定義します。
-
-```fsharp
-    type FizzBuzzList =
-        { Values: FizzBuzzValue list }
-
-        member this.Count = this.Values.Length
-        member this.Get(index) = this.Values.[index]
-
-        member this.Filter(predicate: FizzBuzzValue -> bool) =
-            { Values = this.Values |> List.filter predicate }
-
-        member this.FindFirst(predicate: FizzBuzzValue -> bool) =
-            this.Values |> List.tryFind predicate
-
-        member this.ToStringValues() =
-            this.Values |> List.map (fun v -> v.Value)
-
-        member this.Add(value: FizzBuzzValue) =
-            { Values = this.Values @ [ value ] }
-
-        override this.ToString() =
-            this.Values
-            |> List.map (fun v -> v.ToString())
-            |> String.concat ", "
-
-    let emptyList = { Values = [] }
-
-    let createList (values: FizzBuzzValue list) = { Values = values }
-```
-
-### テストを書く
-
-```fsharp
-module FizzBuzzListTests =
-
-    [<Fact>]
-    let ``空のリストを作成できる`` () =
-        let list = emptyList
-        Assert.Equal(0, list.Count)
-
-    [<Fact>]
-    let ``値を追加できる`` () =
-        let list = emptyList
-        let newList = list.Add(createValue 1 "1")
-        Assert.Equal(1, newList.Count)
-        Assert.Equal(0, list.Count)  // 元のリストは不変
-
-    [<Fact>]
-    let ``フィルタリングできる`` () =
-        let list =
-            createList
-                [ createValue 1 "1"
-                  createValue 3 "Fizz"
-                  createValue 5 "Buzz"
-                  createValue 15 "FizzBuzz" ]
-        let filtered = list.Filter(fun v -> v.Value = "Fizz")
-        Assert.Equal(1, filtered.Count)
-```
-
-`list.Add` は新しいリストを返し、元のリストは変更されません。F# のレコード型は不変であるため、すべての操作が新しい値を返します。
-
-### Application モジュール
-
-ユースケースを実行するモジュールです。Domain モジュールに依存します。
-
-```fsharp
-module Application =
-    open Domain
-
-    let executeValue (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
-        generate fizzBuzzType number
-
-    let executeList (fizzBuzzType: FizzBuzzType) (count: int) : FizzBuzzList =
-        [ 1..count ]
-        |> List.map (generate fizzBuzzType)
-        |> createList
-```
-
-### FizzBuzz モジュール（公開 API）
-
-外部に公開するシンプルな API を提供するモジュールです。
-
-```fsharp
-module FizzBuzz =
-    open Domain
-    open Application
-
-    let generate (number: int) : string =
-        let value = executeValue Standard number
-        value.Value
-
-    let generateList (count: int) : string list =
-        let list = executeList Standard count
-        list.ToStringValues()
-```
-
-### テストを書く
-
-```fsharp
-module ApplicationTests =
-
-    [<Fact>]
-    let ``executeValueで単一値を取得できる`` () =
-        let result = executeValue Standard 3
-        Assert.Equal("Fizz", result.Value)
-
-    [<Fact>]
-    let ``executeListでリストを生成できる`` () =
-        let result = executeList Standard 100
-        Assert.Equal(100, result.Count)
-```
-
-## 9.4 依存関係
-
-```
-FizzBuzz (公開 API)
-    ↓
-Application (ユースケース)
-    ↓
-Domain (ドメインモデル)
-```
-
-- `FizzBuzz` モジュールは `Application` と `Domain` に依存
-- `Application` モジュールは `Domain` に依存
-- `Domain` モジュールは外部に依存しない（純粋なドメインロジック）
-- 逆方向の依存は存在しない（単方向依存）
-
-## 9.5 型による設計の利点
-
-### 不正な状態を表現できない
-
-判別共用体を使うことで、存在しないタイプを指定することがコンパイル時に防止されます。
-
-```fsharp
-// 型安全: コンパイルエラーになる
-let result = generate InvalidType 1  // FizzBuzzType に InvalidType は定義されていない
-
-// 型安全: 正しい使い方
-let result = generate Standard 1
-```
-
-### SOLID 原則の適用
-
-| 原則 | 適用内容 |
-|------|---------|
-| SRP | Domain / Application / FizzBuzz の責務分離 |
-| OCP | 判別共用体にケースを追加して拡張 |
-| LSP | FizzBuzzType の各ケースは同じ generate 関数で処理 |
-| ISP | 各モジュールは必要な関数のみ公開 |
-| DIP | Application は Domain の型に依存（抽象に依存） |
-
-## 9.6 まとめ
-
-この章では以下を実現しました。
-
-| モジュール | 責務 | 含まれる型 |
-|-----------|------|-----------|
-| `Domain` | ドメインモデルとビジネスルール | FizzBuzzValue, FizzBuzzType, FizzBuzzList |
-| `Application` | ユースケースの実行 | executeValue, executeList |
-| `FizzBuzz` | 公開 API | generate, generateList |
-
-第 3 部を通じて、F# のレコード型、判別共用体、モジュールシステムを使った関数型アプローチによる設計を学びました。次の第 4 部では、F# の高度な関数型プログラミング機能（高階関数、関数合成、エラーハンドリング）を活用します。

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

@@ -1,198 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "F# は関数型プログラミングの機能を豊富にサポートしています。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 10 章: 高階関数と関数合成
-
-## 10.1 はじめに
-
-F# は関数型プログラミングの機能を豊富にサポートしています。この章では **パイプライン演算子**、**部分適用**、**カリー化**、**関数合成** を中心に、高階関数の考え方を学びます。
-
-## 10.2 パイプライン演算子
-
-F# の **パイプライン演算子** `|>` は、値を関数に渡すための構文です。Unix のパイプ `|` と同様に、データの流れを左から右に読めるようにします。
-
-```fsharp
-// 通常の関数呼び出し（内側から外側へ読む）
-List.map (fun v -> v.Value) (List.filter (fun v -> v.Number > 5) values)
-
-// パイプライン演算子（左から右へ読む）
-values
-|> List.filter (fun v -> v.Number > 5)
-|> List.map (fun v -> v.Value)
-```
-
-パイプライン演算子により、データの変換処理が自然な流れで読めるようになります。
-
-### FizzBuzz での活用例
-
-```fsharp
-// 1 から 100 までの FizzBuzz リストを生成
-let fizzBuzzList =
-    [ 1..100 ]
-    |> List.map (generate Standard)
-    |> createList
-
-// リストから Fizz の値だけを抽出してカウント
-let fizzCount =
-    fizzBuzzList.Values
-    |> List.filter (fun v -> v.Value = "Fizz")
-    |> List.length
-```
-
-## 10.3 カリー化と部分適用
-
-### カリー化
-
-F# の関数はデフォルトで **カリー化** されています。複数の引数を取る関数は、1 つの引数を取り「残りの引数を取る関数」を返す関数として解釈されます。
-
-```fsharp
-// generate は FizzBuzzType -> int -> FizzBuzzValue
-// つまり、FizzBuzzType を受け取り、(int -> FizzBuzzValue) を返す関数
-let generate (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue = ...
-```
-
-### 部分適用
-
-カリー化された関数に一部の引数だけを渡すことで、新しい関数を作成できます。
-
-```fsharp
-// generate に Standard だけを適用して新しい関数を作成
-let generateStandard = generate Standard
-// generateStandard は int -> FizzBuzzValue 型
-
-// 使用例
-let result = generateStandard 15
-Assert.Equal("FizzBuzz", result.Value)
-
-// List.map と組み合わせる
-let values = [ 1..10 ] |> List.map generateStandard
-```
-
-Rust ではクロージャ `|n| generate(n, Standard)` で同様のことを実現しますが、F# ではカリー化のおかげで自然に部分適用が行えます。
-
-### テストで確認
-
-```fsharp
-[<Fact>]
-let ``部分適用でStandard専用の関数を作成できる`` () =
-    let generateStandard = generate Standard
-    Assert.Equal("FizzBuzz", (generateStandard 15).Value)
-    Assert.Equal("Fizz", (generateStandard 3).Value)
-    Assert.Equal("Buzz", (generateStandard 5).Value)
-
-[<Fact>]
-let ``部分適用でNumberOnly専用の関数を作成できる`` () =
-    let generateNumberOnly = generate NumberOnly
-    Assert.Equal("3", (generateNumberOnly 3).Value)
-    Assert.Equal("15", (generateNumberOnly 15).Value)
-```
-
-## 10.4 関数合成演算子
-
-### >> 演算子
-
-F# の **関数合成演算子** `>>` は、2 つの関数を連結して新しい関数を作成します。
-
-```fsharp
-// f >> g は「まず f を適用し、その結果に g を適用する」関数
-let classify = generate Standard
-let toString (value: FizzBuzzValue) = value.Value
-
-// 関数合成で新しい関数を作成
-let fizzBuzz = classify >> toString
-// fizzBuzz は int -> string 型
-
-// 使用例
-Assert.Equal("FizzBuzz", fizzBuzz 15)
-Assert.Equal("1", fizzBuzz 1)
-```
-
-### パイプライン演算子との違い
-
-| 演算子 | 用途 | 型 |
-|--------|------|-----|
-| `\|>` | 値を関数に渡す | `'a -> ('a -> 'b) -> 'b` |
-| `>>` | 関数を合成する | `('a -> 'b) -> ('b -> 'c) -> ('a -> 'c)` |
-
-```fsharp
-// パイプライン: 値に対して関数を適用
-15 |> classify |> toString  // "FizzBuzz"
-
-// 関数合成: 関数同士を結合して新しい関数を作成
-let fizzBuzz = classify >> toString
-fizzBuzz 15  // "FizzBuzz"
-```
-
-パイプライン演算子は「値」を流すのに対し、関数合成演算子は「関数」を結合します。
-
-## 10.5 高階関数
-
-### 関数を引数として受け取る
-
-```fsharp
-// applyToRange: 指定した関数を範囲に適用する高階関数
-let applyToRange (f: int -> 'a) (start: int) (end': int) : 'a list =
-    [ start..end' ] |> List.map f
-
-// 使用例
-let fizzBuzzRange = applyToRange (generate Standard >> (fun v -> v.Value)) 1 20
-// ["1"; "2"; "Fizz"; "4"; "Buzz"; ...]
-```
-
-### FizzBuzzList への関数型メソッド追加
-
-```fsharp
-member this.CountByValue() =
-    this.Values
-    |> List.groupBy (fun v -> v.Value)
-    |> List.map (fun (key, group) -> (key, List.length group))
-    |> Map.ofList
-```
-
-### テストで確認
-
-```fsharp
-[<Fact>]
-let ``値ごとにカウントできる`` () =
-    let list =
-        createList
-            [ createValue 1 "1"
-              createValue 2 "2"
-              createValue 3 "Fizz"
-              createValue 6 "Fizz"
-              createValue 5 "Buzz" ]
-    let counts = list.CountByValue()
-    Assert.Equal(1, counts.["1"])
-    Assert.Equal(2, counts.["Fizz"])
-    Assert.Equal(1, counts.["Buzz"])
-```
-
-## 10.6 他言語との比較
-
-| 概念 | F# | Rust | Java |
-|------|-----|------|------|
-| パイプライン | `x \|> f` | — (メソッドチェーン) | — (Stream API) |
-| 部分適用 | `generate Standard` | クロージャで代替 | — |
-| 関数合成 | `f >> g` | — | `f.andThen(g)` |
-| 高階関数 | `List.map f` | `.iter().map(f)` | `.stream().map(f)` |
-| カリー化 | デフォルト | — | — |
-
-## 10.7 まとめ
-
-この章では以下を学びました。
-
-| 概念 | F# の記法 | 用途 |
-|------|----------|------|
-| パイプライン演算子 | `\|>` | 値を関数に渡す |
-| 関数合成演算子 | `>>` | 関数を結合して新しい関数を作成 |
-| カリー化 | デフォルト | 複数引数関数の段階的適用 |
-| 部分適用 | `generate Standard` | 引数の一部を固定した新しい関数 |
-| 高階関数 | `List.map`, `List.filter` | 関数を引数に取る関数 |
-
-次章では、**不変データ** と **コレクション処理** を深掘りし、F# のイミュータブル設計を学びます。

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

@@ -1,221 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとコレクション処理"
-description: "前章ではパイプライン演算子と関数合成を学びました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 11 章: 不変データとコレクション処理
-
-## 11.1 はじめに
-
-前章ではパイプライン演算子と関数合成を学びました。この章では F# の **不変データ** の考え方と、**List モジュール** / **Seq モジュール** によるコレクション処理を深掘りします。
-
-## 11.2 F# の不変性
-
-F# では変数はデフォルトで **不変（immutable）** です。
-
-```fsharp
-let x = 5        // 不変（デフォルト）
-let mutable y = 10  // 可変（明示的）
-```
-
-Rust と同様に、不変がデフォルトの設計です。Rust では `let` が不変、`let mut` が可変ですが、F# では `let` が不変、`let mutable` が可変です。
-
-### レコード型の不変性
-
-FizzBuzzValue レコード型はデフォルトで不変です。
-
-```fsharp
-let value = createValue 3 "Fizz"
-// value.Value <- "Buzz"  // コンパイルエラー: レコードフィールドは変更できない
-
-// 新しい値を作成する場合は with 式を使う
-let newValue = { value with Value = "Buzz" }
-Assert.Equal("Fizz", value.Value)    // 元の値は変わらない
-Assert.Equal("Buzz", newValue.Value) // 新しい値が作成される
-```
-
-### FizzBuzzList の不変設計
-
-`Add` メソッドは元のリストを変更せず、新しいリストを返します。
-
-```fsharp
-[<Fact>]
-let ``値を追加できる`` () =
-    let list = emptyList
-    let newList = list.Add(createValue 1 "1")
-    Assert.Equal(1, newList.Count)
-    Assert.Equal(0, list.Count)  // 元のリストは不変
-```
-
-## 11.3 List モジュール
-
-F# の `List` モジュールはイミュータブルなリンクドリストを操作する関数群を提供します。
-
-### List.map — 要素の変換
-
-```fsharp
-// 各 FizzBuzzValue の Value フィールドを取得
-let stringValues =
-    fizzBuzzList.Values
-    |> List.map (fun v -> v.Value)
-// ["1"; "2"; "Fizz"; "4"; "Buzz"; ...]
-```
-
-### List.filter — 要素の選別
-
-```fsharp
-// Fizz の値だけを抽出
-let fizzValues =
-    fizzBuzzList.Values
-    |> List.filter (fun v -> v.Value = "Fizz")
-```
-
-### List.fold — 集約
-
-```fsharp
-// すべての Value を改行区切りで連結
-let joined =
-    fizzBuzzList.Values
-    |> List.map (fun v -> v.Value)
-    |> List.fold (fun acc v ->
-        if acc = "" then v
-        else acc + "\n" + v) ""
-```
-
-`List.fold` は Rust の `.fold()` や Java の `Stream.reduce()` に相当します。初期値と累積関数を受け取り、リストの各要素を順に処理します。
-
-### List.groupBy — グルーピング
-
-```fsharp
-// Value でグルーピングしてカウント
-let counts =
-    fizzBuzzList.Values
-    |> List.groupBy (fun v -> v.Value)
-    |> List.map (fun (key, group) -> (key, List.length group))
-    |> Map.ofList
-```
-
-### List.tryFind — 最初の一致要素
-
-```fsharp
-let firstFizz =
-    fizzBuzzList.Values
-    |> List.tryFind (fun v -> v.Value = "Fizz")
-
-match firstFizz with
-| Some value -> printfn "Found: %s" (value.ToString())
-| None -> printfn "Not found"
-```
-
-`List.tryFind` は `Option<'T>` を返します。Rust の `.find()` が `Option<T>` を返すのと同様です。
-
-## 11.4 Seq モジュール
-
-`Seq` モジュールは **遅延評価** されるシーケンスを操作します。
-
-```fsharp
-// Seq は遅延評価（必要な分だけ計算）
-let firstFiveFizzBuzz =
-    Seq.initInfinite (fun i -> generate Standard (i + 1))
-    |> Seq.map (fun v -> v.Value)
-    |> Seq.take 5
-    |> Seq.toList
-// ["1"; "2"; "Fizz"; "4"; "Buzz"]
-```
-
-### List と Seq の使い分け
-
-| 特徴 | List | Seq |
-|------|------|-----|
-| 評価方式 | 即時評価 | 遅延評価 |
-| メモリ使用 | 全要素をメモリに保持 | 必要な分だけ計算 |
-| 無限列 | 不可 | 可能（Seq.initInfinite） |
-| パフォーマンス | 小〜中サイズに最適 | 大量データに最適 |
-| 用途 | 一般的なコレクション操作 | ストリーム処理、大量データ |
-
-Rust のイテレータも遅延評価ですが、F# では `List`（即時）と `Seq`（遅延）を明示的に使い分けます。
-
-## 11.5 FizzBuzzList のイミュータブル設計
-
-### パイプラインによるコレクション操作
-
-FizzBuzzList にコレクション操作メソッドを追加します。
-
-```fsharp
-member this.Filter(predicate: FizzBuzzValue -> bool) =
-    { Values = this.Values |> List.filter predicate }
-
-member this.FindFirst(predicate: FizzBuzzValue -> bool) =
-    this.Values |> List.tryFind predicate
-
-member this.ToStringValues() =
-    this.Values |> List.map (fun v -> v.Value)
-
-member this.Add(value: FizzBuzzValue) =
-    { Values = this.Values @ [ value ] }
-
-member this.AddRange(values: FizzBuzzValue list) =
-    { Values = this.Values @ values }
-```
-
-すべてのメソッドが **新しい値を返す** 設計です。元のリストは変更されません。
-
-### テストで確認
-
-```fsharp
-[<Fact>]
-let ``文字列リストに変換できる`` () =
-    let list =
-        createList
-            [ createValue 1 "1"
-              createValue 3 "Fizz"
-              createValue 5 "Buzz" ]
-    let strings = list.ToStringValues()
-    Assert.Equal<string list>([ "1"; "Fizz"; "Buzz" ], strings)
-
-[<Fact>]
-let ``最初の一致する値を取得できる`` () =
-    let list =
-        createList
-            [ createValue 1 "1"
-              createValue 3 "Fizz"
-              createValue 6 "Fizz" ]
-    let found = list.FindFirst(fun v -> v.Value = "Fizz")
-    Assert.True(found.IsSome)
-    Assert.Equal(3, found.Value.Number)
-
-[<Fact>]
-let ``一致する値がない場合はNoneを返す`` () =
-    let list =
-        createList [ createValue 1 "1"; createValue 2 "2" ]
-    let found = list.FindFirst(fun v -> v.Value = "Fizz")
-    Assert.True(found.IsNone)
-```
-
-## 11.6 他言語との比較
-
-| 概念 | F# | Rust | Java |
-|------|-----|------|------|
-| 不変デフォルト | `let x = 5` | `let x = 5` | `final` で明示 |
-| パイプライン | `\|> List.filter f \|> List.map g` | `.iter().filter(f).map(g)` | `.stream().filter(f).map(g)` |
-| fold | `List.fold f init list` | `.fold(init, f)` | `.reduce(init, f)` |
-| 遅延評価 | `Seq` モジュール | イテレータ（デフォルト遅延） | `Stream`（デフォルト遅延） |
-| Option | `Some v / None` | `Some(v) / None` | `Optional.of(v) / empty()` |
-
-## 11.7 まとめ
-
-この章では以下を学びました。
-
-| 概念 | F# の実現方法 |
-|------|---------------|
-| 不変性 | `let` バインディング、レコード型 |
-| コピー | `with` 式によるレコードの部分更新 |
-| List モジュール | map, filter, fold, groupBy, tryFind |
-| Seq モジュール | 遅延評価によるストリーム処理 |
-| イミュータブル設計 | 操作は常に新しい値を返す |
-
-次章では、**Option 型** と **Result 型** を使ったエラーハンドリングと型安全性を学びます。