@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,326 @@
+# 第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

@@ -0,0 +1,332 @@
+# 第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. **テスト容易性**: ファクトリーを差し替えることでテストが容易