@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,335 +0,0 @@
----
-type: Article
-title: "第12章: Visitor パターン"
-description: "Visitor パターンは、オブジェクト構造の要素に対して実行する操作を分離し、構造を変更せずに新しい操作を追加できるようにするパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第12章: Visitor パターン
-
-## はじめに
-
-Visitor パターンは、オブジェクト構造の要素に対して実行する操作を分離し、構造を変更せずに新しい操作を追加できるようにするパターンです。
-
-本章では、図形のシリアライズ、数式の評価と簡約、ツリー構造の操作などを通じて Visitor パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Visitor パターンは以下の要素で構成されます：
-
-- **Visitor**: 各要素型に対する操作を定義
-- **Element**: accept メソッドを持つ要素
-- **ConcreteElement**: 具体的な要素の実装
-
-```plantuml
-@startuml
-skinparam classAttributeIconSize 0
-
-interface Visitor {
-  +visitElementA(e: ElementA)
-  +visitElementB(e: ElementB)
-}
-
-interface Element {
-  +accept(v: Visitor)
-}
-
-class ConcreteVisitor {
-  +visitElementA(e: ElementA)
-  +visitElementB(e: ElementB)
-}
-
-class ElementA {
-  +accept(v: Visitor)
-}
-
-class ElementB {
-  +accept(v: Visitor)
-}
-
-Visitor <|.. ConcreteVisitor
-Element <|.. ElementA
-Element <|.. ElementB
-@enduml
-```
-
-## 2. Haskell における Visitor パターン
-
-Haskell では ADT とパターンマッチングにより、Visitor パターンを自然に表現できます。Visitor は単なる関数として実装されます。
-
-### 図形の定義
-
-```haskell
--- | 2D Point
-data Point = Point Double Double
-  deriving (Show, Eq)
-
--- | Shape ADT
-data Shape
-  = Circle Point Double           -- ^ Circle with center and radius
-  | Square Point Double           -- ^ Square with top-left and side
-  | Rectangle Point Double Double -- ^ Rectangle with top-left, width, height
-  deriving (Show, Eq)
-```
-
-## 3. 図形への Visitor
-
-### JSON シリアライズ
-
-```haskell
--- | Convert shape to JSON string
-shapeToJson :: Shape -> String
-shapeToJson shape = case shape of
-  Circle (Point x y) r ->
-    "{\"type\":\"circle\",\"center\":[" ++ show x ++ "," ++ show y 
-    ++ "],\"radius\":" ++ show r ++ "}"
-  
-  Square (Point x y) s ->
-    "{\"type\":\"square\",\"topLeft\":[" ++ show x ++ "," ++ show y 
-    ++ "],\"side\":" ++ show s ++ "}"
-  
-  Rectangle (Point x y) w h ->
-    "{\"type\":\"rectangle\",\"topLeft\":[" ++ show x ++ "," ++ show y 
-    ++ "],\"width\":" ++ show w ++ ",\"height\":" ++ show h ++ "}"
-```
-
-### XML シリアライズ
-
-```haskell
--- | Convert shape to XML string
-shapeToXml :: Shape -> String
-shapeToXml shape = case shape of
-  Circle (Point x y) r ->
-    "<circle><center x=\"" ++ show x ++ "\" y=\"" ++ show y 
-    ++ "\"/><radius>" ++ show r ++ "</radius></circle>"
-  
-  Square (Point x y) s ->
-    "<square><topLeft x=\"" ++ show x ++ "\" y=\"" ++ show y 
-    ++ "\"/><side>" ++ show s ++ "</side></square>"
-  
-  Rectangle (Point x y) w h ->
-    "<rectangle><topLeft x=\"" ++ show x ++ "\" y=\"" ++ show y 
-    ++ "\"/><width>" ++ show w ++ "</width><height>" 
-    ++ show h ++ "</height></rectangle>"
-```
-
-### 面積と周囲長の計算
-
-```haskell
--- | Calculate shape area
-shapeArea :: Shape -> Double
-shapeArea shape = case shape of
-  Circle _ r -> pi * r * r
-  Square _ s -> s * s
-  Rectangle _ w h -> w * h
-
--- | Calculate shape perimeter
-shapePerimeter :: Shape -> Double
-shapePerimeter shape = case shape of
-  Circle _ r -> 2 * pi * r
-  Square _ s -> 4 * s
-  Rectangle _ w h -> 2 * (w + h)
-
--- | Calculate bounding box (minX, minY, maxX, maxY)
-shapeBoundingBox :: Shape -> (Double, Double, Double, Double)
-shapeBoundingBox shape = case shape of
-  Circle (Point x y) r -> (x - r, y - r, x + r, y + r)
-  Square (Point x y) s -> (x, y, x + s, y + s)
-  Rectangle (Point x y) w h -> (x, y, x + w, y + h)
-```
-
-## 4. Visitor の合成
-
-```haskell
--- | Visit multiple shapes with a visitor function
-visitShapes :: (Shape -> a) -> [Shape] -> [a]
-visitShapes = map
-
--- | Calculate total area of shapes
-totalArea :: [Shape] -> Double
-totalArea = sum . visitShapes shapeArea
-
--- | Calculate total perimeter of shapes
-totalPerimeter :: [Shape] -> Double
-totalPerimeter = sum . visitShapes shapePerimeter
-```
-
-## 5. 数式への Visitor
-
-### 数式 ADT
-
-```haskell
--- | Expression ADT
-data Expr
-  = Num Double                    -- ^ Numeric literal
-  | Var String                    -- ^ Variable
-  | Add Expr Expr                 -- ^ Addition
-  | Sub Expr Expr                 -- ^ Subtraction
-  | Mul Expr Expr                 -- ^ Multiplication
-  | Div Expr Expr                 -- ^ Division
-  | Neg Expr                      -- ^ Negation
-  deriving (Show, Eq)
-```
-
-### 評価 Visitor
-
-```haskell
--- | Evaluate an expression with variable bindings
-evaluate :: [(String, Double)] -> Expr -> Maybe Double
-evaluate env expr = case expr of
-  Num n -> Just n
-  Var name -> lookup name env
-  Add l r -> (+) <$> evaluate env l <*> evaluate env r
-  Sub l r -> (-) <$> evaluate env l <*> evaluate env r
-  Mul l r -> (*) <$> evaluate env l <*> evaluate env r
-  Div l r -> do
-    lv <- evaluate env l
-    rv <- evaluate env r
-    if rv == 0 then Nothing else Just (lv / rv)
-  Neg e -> negate <$> evaluate env e
-```
-
-### Pretty Print Visitor
-
-```haskell
--- | Pretty print an expression
-prettyPrint :: Expr -> String
-prettyPrint expr = case expr of
-  Num n -> show n
-  Var name -> name
-  Add l r -> "(" ++ prettyPrint l ++ " + " ++ prettyPrint r ++ ")"
-  Sub l r -> "(" ++ prettyPrint l ++ " - " ++ prettyPrint r ++ ")"
-  Mul l r -> "(" ++ prettyPrint l ++ " * " ++ prettyPrint r ++ ")"
-  Div l r -> "(" ++ prettyPrint l ++ " / " ++ prettyPrint r ++ ")"
-  Neg e -> "-" ++ prettyPrint e
-```
-
-### 変数抽出 Visitor
-
-```haskell
--- | Get all variable names in an expression
-exprVariables :: Expr -> [String]
-exprVariables expr = nub $ go expr
-  where
-    go (Num _) = []
-    go (Var name) = [name]
-    go (Add l r) = go l ++ go r
-    go (Sub l r) = go l ++ go r
-    go (Mul l r) = go l ++ go r
-    go (Div l r) = go l ++ go r
-    go (Neg e) = go e
-```
-
-### 簡約 Visitor
-
-```haskell
--- | Simplify an expression
-simplify :: Expr -> Expr
-simplify expr = case expr of
-  Add l r -> case (simplify l, simplify r) of
-    (Num 0, r') -> r'
-    (l', Num 0) -> l'
-    (Num a, Num b) -> Num (a + b)
-    (l', r') -> Add l' r'
-  
-  Sub l r -> case (simplify l, simplify r) of
-    (l', Num 0) -> l'
-    (Num a, Num b) -> Num (a - b)
-    (l', r') | l' == r' -> Num 0
-    (l', r') -> Sub l' r'
-  
-  Mul l r -> case (simplify l, simplify r) of
-    (Num 0, _) -> Num 0
-    (_, Num 0) -> Num 0
-    (Num 1, r') -> r'
-    (l', Num 1) -> l'
-    (Num a, Num b) -> Num (a * b)
-    (l', r') -> Mul l' r'
-  
-  Neg e -> case simplify e of
-    Num n -> Num (-n)
-    Neg e' -> e'
-    e' -> Neg e'
-  
-  e -> e
-```
-
-## 6. ツリーへの Visitor
-
-### ジェネリックなツリー構造
-
-```haskell
--- | Generic tree
-data Tree a
-  = Leaf a
-  | Node a [Tree a]
-  deriving (Show, Eq)
-```
-
-### Fold Visitor
-
-```haskell
--- | Fold a tree with functions for leaf and node
-treeFold :: (a -> b) -> (a -> [b] -> b) -> Tree a -> b
-treeFold leafFn nodeFn tree = case tree of
-  Leaf x -> leafFn x
-  Node x children -> nodeFn x (map (treeFold leafFn nodeFn) children)
-
--- | Map a function over tree values
-treeMap :: (a -> b) -> Tree a -> Tree b
-treeMap f tree = case tree of
-  Leaf x -> Leaf (f x)
-  Node x children -> Node (f x) (map (treeMap f) children)
-```
-
-### 派生する Visitor
-
-```haskell
--- | Count nodes in tree
-treeSize :: Tree a -> Int
-treeSize = treeFold (const 1) (\_ sizes -> 1 + sum sizes)
-
--- | Calculate tree depth
-treeDepth :: Tree a -> Int
-treeDepth = treeFold (const 1) (\_ depths -> 1 + maximum (0 : depths))
-
--- | Convert tree to list (preorder)
-treeToList :: Tree a -> [a]
-treeToList = treeFold (: []) (\x childLists -> x : concat childLists)
-```
-
-## 7. テスト
-
-```haskell
-describe "Shape Visitors" $ do
-  it "converts to JSON" $ do
-    shapeToJson (Circle (Point 10 20) 5) 
-      `shouldBe` "{\"type\":\"circle\",\"center\":[10.0,20.0],\"radius\":5.0}"
-  
-  it "calculates area" $ do
-    shapeArea (Square (Point 0 0) 4) `shouldBe` 16
-
-describe "Expression Visitors" $ do
-  it "evaluates expression" $ do
-    evaluate [("x", 2)] (Add (Var "x") (Num 3)) `shouldBe` Just 5
-  
-  it "simplifies expression" $ do
-    simplify (Add (Var "x") (Num 0)) `shouldBe` Var "x"
-
-describe "Tree Visitors" $ do
-  it "counts nodes" $ do
-    let tree = Node 1 [Leaf 2, Node 3 [Leaf 4, Leaf 5]]
-    treeSize tree `shouldBe` 5
-```
-
-## まとめ
-
-Visitor パターンの Haskell における実装のポイント：
-
-1. **パターンマッチング**: ADT に対するパターンマッチングで自然に Visitor を実装
-2. **関数としての Visitor**: 各 Visitor は単なる関数として表現
-3. **合成可能性**: `map` や `fold` を使って Visitor を合成
-4. **再帰的構造**: ツリーや数式などの再帰的データ構造に対応
-5. **新しい操作の追加**: 既存の型を変更せずに新しい Visitor を追加可能

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

@@ -1,341 +0,0 @@
----
-type: Article
-title: "第13章: Abstract Factory パターン"
-description: "Abstract Factory パターンは、関連するオブジェクトの家族を、その具体的なクラスを指定せずに生成するためのインターフェースを提供するパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第13章: Abstract Factory パターン
-
-## はじめに
-
-Abstract Factory パターンは、関連するオブジェクトの家族を、その具体的なクラスを指定せずに生成するためのインターフェースを提供するパターンです。
-
-本章では、図形ファクトリー（標準、アウトライン、塗りつぶし）と UI ファクトリー（Windows、MacOS、Linux）を通じて Abstract Factory パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Abstract Factory パターンは以下の要素で構成されます：
-
-- **AbstractFactory**: 製品群を生成するインターフェース
-- **ConcreteFactory**: 具体的な製品群を生成するファクトリー
-- **AbstractProduct**: 製品の抽象インターフェース
-- **ConcreteProduct**: 具体的な製品
-
-```plantuml
-@startuml
-skinparam classAttributeIconSize 0
-
-interface AbstractFactory {
-  +createProductA(): ProductA
-  +createProductB(): ProductB
-}
-
-class ConcreteFactory1 {
-  +createProductA(): ProductA
-  +createProductB(): ProductB
-}
-
-class ConcreteFactory2 {
-  +createProductA(): ProductA
-  +createProductB(): ProductB
-}
-
-interface ProductA
-interface ProductB
-
-class ProductA1
-class ProductA2
-class ProductB1
-class ProductB2
-
-AbstractFactory <|.. ConcreteFactory1
-AbstractFactory <|.. ConcreteFactory2
-ProductA <|.. ProductA1
-ProductA <|.. ProductA2
-ProductB <|.. ProductB1
-ProductB <|.. ProductB2
-
-ConcreteFactory1 ..> ProductA1
-ConcreteFactory1 ..> ProductB1
-ConcreteFactory2 ..> ProductA2
-ConcreteFactory2 ..> ProductB2
-@enduml
-```
-
-## 2. 図形ファクトリー
-
-### 製品の定義
-
-```haskell
--- | 2D Point
-data Point = Point Double Double
-  deriving (Show, Eq)
-
--- | Shape style
-data ShapeStyle = ShapeStyle
-  { styleOutlineColor :: Maybe String
-  , styleOutlineWidth :: Maybe Double
-  , styleFillColor :: Maybe String
-  } deriving (Show, Eq)
-
--- | Default (empty) style
-defaultStyle :: ShapeStyle
-defaultStyle = ShapeStyle Nothing Nothing Nothing
-
--- | Shape with style
-data Shape
-  = Circle Point Double ShapeStyle
-  | Square Point Double ShapeStyle
-  | Rectangle Point Double Double ShapeStyle
-  deriving (Show, Eq)
-```
-
-### 型クラスによるファクトリーの定義
-
-```haskell
--- | Abstract factory for creating shapes
-class ShapeFactory f where
-  createCircle :: f -> Point -> Double -> Shape
-  createSquare :: f -> Point -> Double -> Shape
-  createRectangle :: f -> Point -> Double -> Double -> Shape
-```
-
-### 標準ファクトリー
-
-```haskell
--- | Standard shape factory (no styling)
-data StandardFactory = StandardFactory
-  deriving (Show, Eq)
-
-instance ShapeFactory StandardFactory where
-  createCircle _ center radius = Circle center radius defaultStyle
-  createSquare _ topLeft side = Square topLeft side defaultStyle
-  createRectangle _ topLeft width height = Rectangle topLeft width height defaultStyle
-```
-
-### アウトラインファクトリー
-
-```haskell
--- | Factory that creates shapes with outline
-data OutlinedFactory = OutlinedFactory
-  { ofOutlineColor :: String
-  , ofOutlineWidth :: Double
-  } deriving (Show, Eq)
-
--- | Create an outlined factory
-makeOutlinedFactory :: String -> Double -> OutlinedFactory
-makeOutlinedFactory = OutlinedFactory
-
-instance ShapeFactory OutlinedFactory where
-  createCircle f center radius = Circle center radius style
-    where style = defaultStyle { styleOutlineColor = Just (ofOutlineColor f)
-                                , styleOutlineWidth = Just (ofOutlineWidth f) }
-  
-  createSquare f topLeft side = Square topLeft side style
-    where style = defaultStyle { styleOutlineColor = Just (ofOutlineColor f)
-                                , styleOutlineWidth = Just (ofOutlineWidth f) }
-  
-  createRectangle f topLeft width height = Rectangle topLeft width height style
-    where style = defaultStyle { styleOutlineColor = Just (ofOutlineColor f)
-                                , styleOutlineWidth = Just (ofOutlineWidth f) }
-```
-
-### 塗りつぶしファクトリー
-
-```haskell
--- | Factory that creates shapes with fill color
-data FilledFactory = FilledFactory
-  { ffFillColor :: String
-  } deriving (Show, Eq)
-
--- | Create a filled factory
-makeFilledFactory :: String -> FilledFactory
-makeFilledFactory = FilledFactory
-
-instance ShapeFactory FilledFactory where
-  createCircle f center radius = Circle center radius style
-    where style = defaultStyle { styleFillColor = Just (ffFillColor f) }
-  
-  createSquare f topLeft side = Square topLeft side style
-    where style = defaultStyle { styleFillColor = Just (ffFillColor f) }
-  
-  createRectangle f topLeft width height = Rectangle topLeft width height style
-    where style = defaultStyle { styleFillColor = Just (ffFillColor f) }
-```
-
-## 3. UI ファクトリー
-
-### UI コンポーネントの定義
-
-```haskell
--- | Button component
-data Button = Button
-  { buttonLabel :: String
-  , buttonPlatform :: String
-  } deriving (Show, Eq)
-
--- | Text field component
-data TextField = TextField
-  { textFieldPlaceholder :: String
-  , textFieldPlatform :: String
-  } deriving (Show, Eq)
-
--- | Check box component
-data CheckBox = CheckBox
-  { checkBoxLabel :: String
-  , checkBoxChecked :: Bool
-  , checkBoxPlatform :: String
-  } deriving (Show, Eq)
-```
-
-### UI ファクトリーの型クラス
-
-```haskell
--- | Abstract factory for creating UI components
-class UIFactory f where
-  createButton :: f -> String -> Button
-  createTextField :: f -> String -> TextField
-  createCheckBox :: f -> String -> Bool -> CheckBox
-```
-
-### プラットフォーム別ファクトリー
-
-```haskell
--- | Windows UI factory
-data WindowsFactory = WindowsFactory
-  deriving (Show, Eq)
-
-instance UIFactory WindowsFactory where
-  createButton _ label = Button label "windows"
-  createTextField _ placeholder = TextField placeholder "windows"
-  createCheckBox _ label checked = CheckBox label checked "windows"
-
--- | MacOS UI factory
-data MacOSFactory = MacOSFactory
-  deriving (Show, Eq)
-
-instance UIFactory MacOSFactory where
-  createButton _ label = Button label "macos"
-  createTextField _ placeholder = TextField placeholder "macos"
-  createCheckBox _ label checked = CheckBox label checked "macos"
-
--- | Linux UI factory
-data LinuxFactory = LinuxFactory
-  deriving (Show, Eq)
-
-instance UIFactory LinuxFactory where
-  createButton _ label = Button label "linux"
-  createTextField _ placeholder = TextField placeholder "linux"
-  createCheckBox _ label checked = CheckBox label checked "linux"
-```
-
-## 4. レンダリング
-
-```haskell
--- | Render a button to string
-renderButton :: Button -> String
-renderButton btn = case buttonPlatform btn of
-  "windows" -> "[" ++ buttonLabel btn ++ "]"
-  "macos"   -> "(" ++ buttonLabel btn ++ ")"
-  "linux"   -> "<" ++ buttonLabel btn ++ ">"
-  _         -> buttonLabel btn
-
--- | Render a text field to string
-renderTextField :: TextField -> String
-renderTextField tf = case textFieldPlatform tf of
-  "windows" -> "[____" ++ textFieldPlaceholder tf ++ "____]"
-  "macos"   -> "(____" ++ textFieldPlaceholder tf ++ "____)"
-  "linux"   -> "<____" ++ textFieldPlaceholder tf ++ "____>"
-  _         -> textFieldPlaceholder tf
-
--- | Render a check box to string
-renderCheckBox :: CheckBox -> String
-renderCheckBox cb = 
-  let mark = if checkBoxChecked cb then "X" else " "
-  in case checkBoxPlatform cb of
-    "windows" -> "[" ++ mark ++ "] " ++ checkBoxLabel cb
-    "macos"   -> "(" ++ mark ++ ") " ++ checkBoxLabel cb
-    "linux"   -> "<" ++ mark ++ "> " ++ checkBoxLabel cb
-    _         -> "[" ++ mark ++ "] " ++ checkBoxLabel cb
-```
-
-## 5. ファクトリーを使用するコード
-
-```haskell
--- | Form containing UI components
-data Form = Form
-  { formButton :: Button
-  , formTextField :: TextField
-  , formCheckBox :: CheckBox
-  } deriving (Show, Eq)
-
--- | Create a form using a factory
-createForm :: UIFactory f => f -> Form
-createForm factory = Form
-  { formButton = createButton factory "Submit"
-  , formTextField = createTextField factory "Email"
-  , formCheckBox = createCheckBox factory "Subscribe" False
-  }
-```
-
-### 使用例
-
-```haskell
--- Windows フォーム
-let windowsForm = createForm WindowsFactory
-renderButton (formButton windowsForm)  -- "[Submit]"
-
--- MacOS フォーム
-let macForm = createForm MacOSFactory
-renderButton (formButton macForm)  -- "(Submit)"
-
--- Linux フォーム
-let linuxForm = createForm LinuxFactory
-renderButton (formButton linuxForm)  -- "<Submit>"
-```
-
-## 6. テスト
-
-```haskell
-describe "Shape Factory" $ do
-  describe "StandardFactory" $ do
-    it "creates shapes without style" $ do
-      let factory = StandardFactory
-          circle = createCircle factory (Point 0 0) 10
-      case circle of
-        Circle _ _ style -> do
-          styleOutlineColor style `shouldBe` Nothing
-          styleFillColor style `shouldBe` Nothing
-        _ -> expectationFailure "Expected Circle"
-  
-  describe "OutlinedFactory" $ do
-    it "creates shapes with outline" $ do
-      let factory = makeOutlinedFactory "black" 2.0
-          circle = createCircle factory (Point 0 0) 10
-      case circle of
-        Circle _ _ style -> do
-          styleOutlineColor style `shouldBe` Just "black"
-          styleOutlineWidth style `shouldBe` Just 2.0
-        _ -> expectationFailure "Expected Circle"
-
-describe "UI Factory" $ do
-  it "creates platform-specific components" $ do
-    let form = createForm WindowsFactory
-    buttonPlatform (formButton form) `shouldBe` "windows"
-    
-    let macForm = createForm MacOSFactory
-    buttonPlatform (formButton macForm) `shouldBe` "macos"
-```
-
-## まとめ
-
-Abstract Factory パターンの Haskell における実装のポイント：
-
-1. **型クラスによる抽象化**: ファクトリーインターフェースを型クラスで定義
-2. **インスタンスによる具象化**: 各具象ファクトリーを型クラスのインスタンスとして実装
-3. **多態的な使用**: `UIFactory f => f -> ...` のような制約付きの型で抽象ファクトリーを使用
-4. **製品の一貫性**: 同じファクトリーから生成される製品は一貫したスタイル/プラットフォームを持つ
-5. **テスト容易性**: ファクトリーを差し替えることでテストが容易