@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/12-visitor-pattern.md

@@ -1,348 +0,0 @@
----
-type: Article
-title: "第12章: Visitor パターン"
-description: "Visitor パターンは、データ構造と操作を分離し、既存のデータ構造を変更することなく新しい操作を追加できるようにするパターンです。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第12章: Visitor パターン
-
-## はじめに
-
-Visitor パターンは、データ構造と操作を分離し、既存のデータ構造を変更することなく新しい操作を追加できるようにするパターンです。
-
-本章では、図形（Shape）に対する様々な操作（JSON 変換、XML 変換、面積計算、周囲長計算）を通じて、判別共用体とパターンマッチングによる Visitor パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Visitor パターンは以下の要素で構成されます：
-
-- **Visitor**: 操作のインターフェース
-- **ConcreteVisitor**: 具体的な操作の実装
-- **Element**: 訪問される要素のインターフェース
-- **ConcreteElement**: 具体的な要素
-
-```plantuml
-@startuml
-package "Elements (図形)" {
-  class "Circle" as circle
-  class "Square" as square
-  class "Rectangle" as rectangle
-}
-
-package "Visitors (操作)" {
-  class "JsonVisitor" as json
-  class "XmlVisitor" as xml
-  class "AreaVisitor" as area
-  class "PerimeterVisitor" as perimeter
-}
-
-json --> circle
-json --> square
-json --> rectangle
-area --> circle
-area --> square
-area --> rectangle
-@enduml
-```
-
-## 2. Element: 図形の定義
-
-### 判別共用体による図形定義
-
-```fsharp
-[<RequireQualifiedAccess>]
-type Shape =
-    | Circle of center: (float * float) * radius: float
-    | Square of topLeft: (float * float) * side: float
-    | Rectangle of topLeft: (float * float) * width: float * height: float
-    | Triangle of p1: (float * float) * p2: (float * float) * p3: (float * float)
-```
-
-### 図形の操作
-
-```fsharp
-module Shape =
-    /// 図形を移動
-    let translate (dx: float) (dy: float) (shape: Shape) : Shape =
-        match shape with
-        | Shape.Circle((x, y), r) -> Shape.Circle((x + dx, y + dy), r)
-        | Shape.Square((x, y), s) -> Shape.Square((x + dx, y + dy), s)
-        | Shape.Rectangle((x, y), w, h) -> Shape.Rectangle((x + dx, y + dy), w, h)
-        | Shape.Triangle((x1, y1), (x2, y2), (x3, y3)) ->
-            Shape.Triangle((x1 + dx, y1 + dy), (x2 + dx, y2 + dy), (x3 + dx, y3 + dy))
-
-    /// 図形を拡大/縮小
-    let scale (factor: float) (shape: Shape) : Shape =
-        match shape with
-        | Shape.Circle(c, r) -> Shape.Circle(c, r * factor)
-        | Shape.Square(tl, s) -> Shape.Square(tl, s * factor)
-        | Shape.Rectangle(tl, w, h) -> Shape.Rectangle(tl, w * factor, h * factor)
-        // ...
-```
-
-## 3. Visitor: JSON 変換
-
-```fsharp
-module JsonVisitor =
-    /// 図形を JSON 文字列に変換
-    let toJson (shape: Shape) : string =
-        match shape with
-        | Shape.Circle((x, y), r) ->
-            sprintf """{"type":"circle","center":[%g,%g],"radius":%g}""" x y r
-        | Shape.Square((x, y), s) ->
-            sprintf """{"type":"square","topLeft":[%g,%g],"side":%g}""" x y s
-        | Shape.Rectangle((x, y), w, h) ->
-            sprintf """{"type":"rectangle","topLeft":[%g,%g],"width":%g,"height":%g}""" x y w h
-        | Shape.Triangle((x1, y1), (x2, y2), (x3, y3)) ->
-            sprintf """{"type":"triangle","points":[[%g,%g],[%g,%g],[%g,%g]]}""" x1 y1 x2 y2 x3 y3
-
-    /// 複数の図形を JSON 配列に変換
-    let shapesToJson (shapes: Shape list) : string =
-        let jsonShapes = shapes |> List.map toJson |> String.concat ","
-        sprintf "[%s]" jsonShapes
-```
-
-### 使用例
-
-```fsharp
-let circle = Shape.Circle((10.0, 20.0), 5.0)
-let json = JsonVisitor.toJson circle
-// => {"type":"circle","center":[10,20],"radius":5}
-```
-
-## 4. Visitor: XML 変換
-
-```fsharp
-module XmlVisitor =
-    /// 図形を XML 文字列に変換
-    let toXml (shape: Shape) : string =
-        match shape with
-        | Shape.Circle((x, y), r) ->
-            sprintf """<circle><center x="%g" y="%g"/><radius>%g</radius></circle>""" x y r
-        | Shape.Square((x, y), s) ->
-            sprintf """<square><topLeft x="%g" y="%g"/><side>%g</side></square>""" x y s
-        | Shape.Rectangle((x, y), w, h) ->
-            sprintf """<rectangle><topLeft x="%g" y="%g"/><width>%g</width><height>%g</height></rectangle>""" x y w h
-        | Shape.Triangle((x1, y1), (x2, y2), (x3, y3)) ->
-            sprintf """<triangle><p1 x="%g" y="%g"/><p2 x="%g" y="%g"/><p3 x="%g" y="%g"/></triangle>""" x1 y1 x2 y2 x3 y3
-```
-
-## 5. Visitor: 面積計算
-
-```fsharp
-module AreaVisitor =
-    /// 図形の面積を計算
-    let calculateArea (shape: Shape) : float =
-        match shape with
-        | Shape.Circle(_, r) -> System.Math.PI * r * r
-        | Shape.Square(_, s) -> s * s
-        | Shape.Rectangle(_, w, h) -> w * h
-        | Shape.Triangle((x1, y1), (x2, y2), (x3, y3)) ->
-            // ヘロンの公式
-            let a = sqrt((x2 - x1) ** 2.0 + (y2 - y1) ** 2.0)
-            let b = sqrt((x3 - x2) ** 2.0 + (y3 - y2) ** 2.0)
-            let c = sqrt((x1 - x3) ** 2.0 + (y1 - y3) ** 2.0)
-            let s = (a + b + c) / 2.0
-            sqrt(s * (s - a) * (s - b) * (s - c))
-
-    /// 複数の図形の合計面積を計算
-    let totalArea (shapes: Shape list) : float =
-        shapes |> List.sumBy calculateArea
-```
-
-## 6. Visitor: 周囲長計算
-
-```fsharp
-module PerimeterVisitor =
-    /// 図形の周囲長を計算
-    let calculatePerimeter (shape: Shape) : float =
-        match shape with
-        | Shape.Circle(_, r) -> 2.0 * System.Math.PI * r
-        | Shape.Square(_, s) -> 4.0 * s
-        | Shape.Rectangle(_, w, h) -> 2.0 * (w + h)
-        | Shape.Triangle((x1, y1), (x2, y2), (x3, y3)) ->
-            let a = sqrt((x2 - x1) ** 2.0 + (y2 - y1) ** 2.0)
-            let b = sqrt((x3 - x2) ** 2.0 + (y3 - y2) ** 2.0)
-            let c = sqrt((x1 - x3) ** 2.0 + (y1 - y3) ** 2.0)
-            a + b + c
-```
-
-## 7. Visitor: バウンディングボックス計算
-
-```fsharp
-type BoundingBox =
-    { MinX: float
-      MinY: float
-      MaxX: float
-      MaxY: float }
-
-module BoundingBoxVisitor =
-    /// 図形のバウンディングボックスを計算
-    let calculateBoundingBox (shape: Shape) : BoundingBox =
-        match shape with
-        | Shape.Circle((x, y), r) ->
-            { MinX = x - r; MinY = y - r; MaxX = x + r; MaxY = y + r }
-        | Shape.Square((x, y), s) ->
-            { MinX = x; MinY = y; MaxX = x + s; MaxY = y + s }
-        | Shape.Rectangle((x, y), w, h) ->
-            { MinX = x; MinY = y; MaxX = x + w; MaxY = y + h }
-        // ...
-```
-
-## 8. Expression Visitor（式の評価）
-
-```fsharp
-[<RequireQualifiedAccess>]
-type Expr =
-    | Num of float
-    | Add of Expr * Expr
-    | Sub of Expr * Expr
-    | Mul of Expr * Expr
-    | Div of Expr * Expr
-    | Neg of Expr
-    | Var of string
-
-module ExprVisitor =
-    /// 式を評価
-    let rec evaluate (env: Map<string, float>) (expr: Expr) : float =
-        match expr with
-        | Expr.Num n -> n
-        | Expr.Add(a, b) -> evaluate env a + evaluate env b
-        | Expr.Sub(a, b) -> evaluate env a - evaluate env b
-        | Expr.Mul(a, b) -> evaluate env a * evaluate env b
-        | Expr.Div(a, b) -> evaluate env a / evaluate env b
-        | Expr.Neg e -> -(evaluate env e)
-        | Expr.Var name -> Map.tryFind name env |> Option.defaultValue 0.0
-
-    /// 式を文字列に変換
-    let rec toString (expr: Expr) : string =
-        match expr with
-        | Expr.Num n -> sprintf "%g" n
-        | Expr.Add(a, b) -> sprintf "(%s + %s)" (toString a) (toString b)
-        // ...
-
-    /// 式を簡約
-    let rec simplify (expr: Expr) : Expr =
-        match expr with
-        | Expr.Add(Expr.Num 0.0, e) -> simplify e
-        | Expr.Mul(Expr.Num 1.0, e) -> simplify e
-        | Expr.Mul(Expr.Num 0.0, _) -> Expr.Num 0.0
-        // ...
-```
-
-### 使用例
-
-```fsharp
-let expr = Expr.Add(Expr.Num 3.0, Expr.Mul(Expr.Num 2.0, Expr.Num 4.0))
-let result = ExprVisitor.evaluate Map.empty expr
-// => 11.0
-
-let expr = Expr.Add(Expr.Var "x", Expr.Num 5.0)
-let env = Map.ofList [ ("x", 10.0) ]
-let result = ExprVisitor.evaluate env expr
-// => 15.0
-```
-
-## 9. Tree Visitor
-
-```fsharp
-type Tree<'T> =
-    | Leaf of 'T
-    | Node of Tree<'T> list
-
-module TreeVisitor =
-    /// ツリーの全ての葉の値を収集
-    let rec collectLeaves (tree: Tree<'T>) : 'T list =
-        match tree with
-        | Leaf v -> [ v ]
-        | Node children -> children |> List.collect collectLeaves
-
-    /// ツリーの深さを計算
-    let rec depth (tree: Tree<'T>) : int =
-        match tree with
-        | Leaf _ -> 1
-        | Node [] -> 1
-        | Node children -> 1 + (children |> List.map depth |> List.max)
-
-    /// ツリーを変換
-    let rec map (f: 'T -> 'U) (tree: Tree<'T>) : Tree<'U> =
-        match tree with
-        | Leaf v -> Leaf(f v)
-        | Node children -> Node(children |> List.map (map f))
-
-    /// ツリーをフォールド
-    let rec fold (leafFn: 'T -> 'Acc) (nodeFn: 'Acc list -> 'Acc) (tree: Tree<'T>) : 'Acc =
-        match tree with
-        | Leaf v -> leafFn v
-        | Node children -> nodeFn (children |> List.map (fold leafFn nodeFn))
-```
-
-### 使用例
-
-```fsharp
-let tree = Node [ Leaf 1; Node [ Leaf 2; Leaf 3 ]; Leaf 4 ]
-
-let leaves = TreeVisitor.collectLeaves tree
-// => [1; 2; 3; 4]
-
-let d = TreeVisitor.depth tree
-// => 3
-
-let sum = TreeVisitor.fold id List.sum tree
-// => 10
-```
-
-## 10. パターンの利点
-
-1. **操作の追加が容易**: 新しい Visitor を追加するだけで新しい操作を実装
-2. **単一責任の原則**: 各 Visitor は一つの操作に専念
-3. **関連する操作の一元化**: 同じ操作のコードが一箇所にまとまる
-4. **データ構造と操作の分離**: 要素クラスを変更せずに操作を追加
-
-## 11. 関数型プログラミングでの特徴
-
-F# での Visitor パターンの実装には以下の特徴があります：
-
-1. **パターンマッチング**: 判別共用体と match 式で自然に実装
-2. **網羅性チェック**: コンパイラが全てのケースを処理しているか検証
-3. **再帰的データ構造**: 式やツリーなどの再帰的構造に最適
-4. **純粋関数**: 副作用のない変換処理
-5. **合成しやすさ**: 複数の Visitor を組み合わせ可能
-
-```fsharp
-// パイプライン演算子を使った複数の操作
-let shapes = [
-    Shape.Circle((0.0, 0.0), 5.0)
-    Shape.Square((10.0, 10.0), 10.0)
-]
-
-let totalArea = AreaVisitor.totalArea shapes
-let json = JsonVisitor.shapesToJson shapes
-```
-
-## まとめ
-
-本章では、Visitor パターンについて学びました：
-
-1. **図形の定義**: 判別共用体による Element の表現
-2. **JSON/XML 変換**: シリアライゼーション Visitor
-3. **面積/周囲長計算**: 数学的計算 Visitor
-4. **バウンディングボックス**: 空間計算 Visitor
-5. **式の評価**: 再帰的データ構造への Visitor
-6. **ツリー操作**: 汎用的なツリー Visitor
-
-F# では、判別共用体とパターンマッチングにより、Visitor パターンを非常に自然に実装できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part4/src/Library.fs`
-- テストコード: `apps/fsharp/part4/tests/Tests.fs`
-
-## 次章予告
-
-次章では、**Abstract Factory パターン**について学びます。関連するオブジェクトのファミリーを生成するインターフェースを提供する方法を探ります。

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/13-abstract-factory-pattern.md

@@ -1,318 +0,0 @@
----
-type: Article
-title: "第13章: Abstract Factory パターン"
-description: "Abstract Factory パターンは、関連するオブジェクトのファミリーを、その具体的なクラスを指定することなく生成するためのインターフェースを提供するパターンです。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第13章: Abstract Factory パターン
-
-## はじめに
-
-Abstract Factory パターンは、関連するオブジェクトのファミリーを、その具体的なクラスを指定することなく生成するためのインターフェースを提供するパターンです。
-
-本章では、図形ファクトリ、UI ファクトリ、データベースファクトリなどの例を通じて、判別共用体による Abstract Factory パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Abstract Factory パターンは以下の要素で構成されます：
-
-- **AbstractFactory**: オブジェクト生成の抽象インターフェース
-- **ConcreteFactory**: 具体的なオブジェクトを生成するファクトリ
-- **AbstractProduct**: 生成されるオブジェクトの抽象インターフェース
-- **ConcreteProduct**: 具体的な製品
-
-```plantuml
-@startuml
-interface "AbstractFactory" as factory {
-  +createProductA()
-  +createProductB()
-}
-
-class "ConcreteFactory1" as factory1
-class "ConcreteFactory2" as factory2
-
-factory1 ..|> factory
-factory2 ..|> factory
-@enduml
-```
-
-## 2. 図形ファクトリ
-
-### スタイル情報の定義
-
-```fsharp
-type ShapeStyle =
-    { OutlineColor: string option
-      OutlineWidth: float option
-      FillColor: string option
-      Opacity: float option }
-
-module ShapeStyle =
-    let empty =
-        { OutlineColor = None
-          OutlineWidth = None
-          FillColor = None
-          Opacity = None }
-
-    let withOutline color width style =
-        { style with OutlineColor = Some color; OutlineWidth = Some width }
-
-    let withFill color style =
-        { style with FillColor = Some color }
-```
-
-### ファクトリの定義
-
-```fsharp
-[<RequireQualifiedAccess>]
-type ShapeFactory =
-    | Standard
-    | Outlined of color: string * width: float
-    | Filled of color: string
-    | Custom of style: ShapeStyle
-```
-
-### ファクトリの実装
-
-```fsharp
-module ShapeFactory =
-    /// 円を作成
-    let createCircle (factory: ShapeFactory) (center: float * float) (radius: float) : StyledShape =
-        let shape = Shape.Circle(center, radius)
-        let style =
-            match factory with
-            | ShapeFactory.Standard -> ShapeStyle.empty
-            | ShapeFactory.Outlined(color, width) -> ShapeStyle.empty |> ShapeStyle.withOutline color width
-            | ShapeFactory.Filled color -> ShapeStyle.empty |> ShapeStyle.withFill color
-            | ShapeFactory.Custom style -> style
-        { Shape = shape; Style = style }
-```
-
-### 使用例
-
-```fsharp
-// 標準ファクトリ
-let standardFactory = ShapeFactory.Standard
-let circle = ShapeFactory.createCircle standardFactory (10.0, 20.0) 5.0
-
-// 輪郭線付きファクトリ
-let outlinedFactory = ShapeFactory.Outlined("black", 2.0)
-let square = ShapeFactory.createSquare outlinedFactory (0.0, 0.0) 10.0
-
-// カスタムスタイルファクトリ
-let customStyle =
-    ShapeStyle.empty
-    |> ShapeStyle.withOutline "blue" 3.0
-    |> ShapeStyle.withFill "yellow"
-let customFactory = ShapeFactory.Custom customStyle
-let rect = ShapeFactory.createRectangle customFactory (0.0, 0.0) 20.0 10.0
-```
-
-## 3. UI ファクトリ
-
-### コンポーネントの定義
-
-```fsharp
-type Button =
-    { Label: string
-      Platform: string
-      Style: Map<string, string> }
-
-type TextField =
-    { Placeholder: string
-      Platform: string
-      Style: Map<string, string> }
-
-type Checkbox =
-    { Label: string
-      Checked: bool
-      Platform: string
-      Style: Map<string, string> }
-```
-
-### ファクトリの定義
-
-```fsharp
-[<RequireQualifiedAccess>]
-type UIFactory =
-    | Windows
-    | MacOS
-    | Linux
-    | Web
-```
-
-### ファクトリの実装
-
-```fsharp
-module UIFactory =
-    /// ボタンを作成
-    let createButton (factory: UIFactory) (label: string) : Button =
-        let platform = match factory with
-            | UIFactory.Windows -> "windows"
-            | UIFactory.MacOS -> "macos"
-            | UIFactory.Linux -> "linux"
-            | UIFactory.Web -> "web"
-        let style = match factory with
-            | UIFactory.Windows -> Map.ofList [ ("border", "1px solid gray") ]
-            | UIFactory.MacOS -> Map.ofList [ ("borderRadius", "5px") ]
-            // ...
-        { Label = label; Platform = platform; Style = style }
-```
-
-### 使用例
-
-```fsharp
-// Windows UI を作成
-let windowsFactory = UIFactory.Windows
-let okButton = UIFactory.createButton windowsFactory "OK"
-let nameField = UIFactory.createTextField windowsFactory "Enter name"
-
-// MacOS UI を作成
-let macFactory = UIFactory.MacOS
-let submitButton = UIFactory.createButton macFactory "Submit"
-```
-
-## 4. データベースファクトリ
-
-```fsharp
-type DatabaseConnection =
-    { ConnectionString: string
-      DatabaseType: string
-      MaxPoolSize: int }
-
-[<RequireQualifiedAccess>]
-type DatabaseFactory =
-    | SqlServer of connectionString: string
-    | PostgreSQL of connectionString: string
-    | MySQL of connectionString: string
-    | SQLite of filePath: string
-
-module DatabaseFactory =
-    let createConnection (factory: DatabaseFactory) : DatabaseConnection =
-        match factory with
-        | DatabaseFactory.SqlServer connStr ->
-            { ConnectionString = connStr
-              DatabaseType = "SqlServer"
-              MaxPoolSize = 100 }
-        | DatabaseFactory.PostgreSQL connStr ->
-            { ConnectionString = connStr
-              DatabaseType = "PostgreSQL"
-              MaxPoolSize = 50 }
-        | DatabaseFactory.SQLite path ->
-            { ConnectionString = sprintf "Data Source=%s" path
-              DatabaseType = "SQLite"
-              MaxPoolSize = 1 }
-        // ...
-```
-
-## 5. ドキュメントファクトリ
-
-```fsharp
-[<RequireQualifiedAccess>]
-type DocumentFactory =
-    | HTML
-    | Markdown
-    | PlainText
-
-module DocumentFactory =
-    /// 段落を作成
-    let createParagraph (factory: DocumentFactory) (text: string) : string =
-        match factory with
-        | DocumentFactory.HTML -> sprintf "<p>%s</p>" text
-        | DocumentFactory.Markdown -> text + "\n"
-        | DocumentFactory.PlainText -> text + "\n"
-
-    /// 見出しを作成
-    let createHeading (factory: DocumentFactory) (level: int) (text: string) : string =
-        match factory with
-        | DocumentFactory.HTML -> sprintf "<h%d>%s</h%d>" level text level
-        | DocumentFactory.Markdown -> String.replicate level "#" + " " + text + "\n"
-        | DocumentFactory.PlainText -> text.ToUpper() + "\n"
-```
-
-## 6. テーマファクトリ
-
-```fsharp
-type ThemeColors =
-    { Primary: string
-      Secondary: string
-      Background: string
-      Text: string }
-
-type Theme =
-    { Name: string
-      Colors: ThemeColors
-      Fonts: ThemeFonts }
-
-[<RequireQualifiedAccess>]
-type ThemeFactory =
-    | Light
-    | Dark
-    | HighContrast
-
-module ThemeFactory =
-    let createTheme (factory: ThemeFactory) : Theme =
-        match factory with
-        | ThemeFactory.Light ->
-            { Name = "Light"
-              Colors = { Primary = "#007bff"; Background = "#ffffff"; ... }
-              ... }
-        | ThemeFactory.Dark ->
-            { Name = "Dark"
-              Colors = { Primary = "#0d6efd"; Background = "#212529"; ... }
-              ... }
-```
-
-## 7. パターンの利点
-
-1. **製品ファミリーの一貫性**: 同じファクトリから生成された製品は互いに互換性がある
-2. **具体クラスの分離**: クライアントは具体的な製品クラスを知る必要がない
-3. **ファクトリの交換**: ファクトリを切り替えるだけで異なる製品ファミリーを使用可能
-4. **新しいファミリーの追加**: 新しいファクトリを追加するだけで新しい製品ファミリーに対応
-
-## 8. 関数型プログラミングでの特徴
-
-F# での Abstract Factory パターンの実装には以下の特徴があります：
-
-1. **判別共用体**: ファクトリの種類を型安全に表現
-2. **パターンマッチング**: ファクトリの種類に応じた処理を明確に記述
-3. **モジュール関数**: ファクトリの操作を関数として定義
-4. **不変データ**: 生成された製品はイミュータブル
-5. **合成しやすさ**: ファクトリ関数を合成可能
-
-```fsharp
-// パイプライン演算子を使った利用
-let createForm factory =
-    let button = UIFactory.createButton factory "Submit"
-    let field = UIFactory.createTextField factory "Email"
-    (button, field)
-
-let (windowsBtn, windowsField) = createForm UIFactory.Windows
-let (macBtn, macField) = createForm UIFactory.MacOS
-```
-
-## まとめ
-
-本章では、Abstract Factory パターンについて学びました：
-
-1. **図形ファクトリ**: スタイル付き図形の生成
-2. **UI ファクトリ**: プラットフォーム別 UI コンポーネントの生成
-3. **データベースファクトリ**: DB 接続とコマンドの生成
-4. **ドキュメントファクトリ**: フォーマット別ドキュメント要素の生成
-5. **テーマファクトリ**: テーマ設定の生成
-
-F# では、判別共用体とパターンマッチングにより、Abstract Factory パターンを型安全かつ簡潔に実装できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part4/src/Library.fs`
-- テストコード: `apps/fsharp/part4/tests/Tests.fs`
-
-## 次章予告
-
-次章では、**Abstract Server パターン**について学びます。クライアントとサーバー間の抽象化層を提供する方法を探ります。