@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/02-function-composition.md

@@ -0,0 +1,304 @@
+# 第2章: 関数合成と高階関数
+
+## はじめに
+
+関数型プログラミングの真髄は、小さな関数を組み合わせて複雑な処理を構築することにあります。Haskell では関数合成が言語の中心的な概念であり、演算子やカリー化により自然に表現できます。
+
+本章では、関数合成のテクニックと高階関数の活用方法を学びます。
+
+## 1. 関数合成の基本 (`.` と `>>>`)
+
+### `.` による関数合成（右から左）
+
+`.` 演算子は数学的な関数合成 `(f ∘ g)(x) = f(g(x))` を表現します：
+
+```haskell
+-- | 税金を追加
+addTax :: Double -> Double -> Double
+addTax rate amount = amount * (1 + rate)
+
+-- | 割引を適用
+applyDiscountRate :: Double -> Double -> Double
+applyDiscountRate rate amount = amount * (1 - rate)
+
+-- | 円単位に丸める
+roundToYen :: Double -> Integer
+roundToYen = round
+
+-- | (.) による関数合成（右から左）
+calculateFinalPriceCompose :: Double -> Integer
+calculateFinalPriceCompose = roundToYen . addTax 0.1 . applyDiscountRate 0.2
+
+-- 使用例
+calculateFinalPriceCompose 1000  -- => 880
+-- 処理順序: 1000 → 20%割引(800) → 10%税込(880) → 丸め(880)
+```
+
+### `>>>` による関数合成（左から右）
+
+`Control.Arrow` の `>>>` はパイプラインのように左から右へ処理を流します：
+
+```haskell
+import Control.Arrow ((>>>))
+
+-- | (>>>) による関数合成（左から右、より直感的）
+calculateFinalPrice :: Double -> Integer
+calculateFinalPrice = applyDiscountRate 0.2 >>> addTax 0.1 >>> roundToYen
+
+-- 使用例
+calculateFinalPrice 1000  -- => 880
+```
+
+### 関数合成の利点
+
+1. **宣言的な記述**: 処理の流れを関数のチェーンとして表現
+2. **再利用性**: 合成した関数を他の場所で再利用可能
+3. **テスト容易性**: 各関数を個別にテスト可能
+4. **ポイントフリースタイル**: 引数を明示しないエレガントな表現
+
+## 2. カリー化と部分適用
+
+### Haskell のカリー化
+
+Haskell では全ての関数がデフォルトでカリー化されています。複数引数の関数は「1引数を取り関数を返す関数」のチェーンです：
+
+```haskell
+-- | カリー化された挨拶関数
+greet :: String -> String -> String
+greet greeting name = greeting ++ ", " ++ name ++ "!"
+
+-- これは実際には次と等価：
+-- greet :: String -> (String -> String)
+
+-- | 部分適用で特化した関数を作成
+sayHello :: String -> String
+sayHello = greet "Hello"
+
+sayGoodbye :: String -> String
+sayGoodbye = greet "Goodbye"
+
+-- 使用例
+sayHello "田中"    -- => "Hello, 田中!"
+sayGoodbye "鈴木"  -- => "Goodbye, 鈴木!"
+```
+
+### 複数引数の部分適用
+
+```haskell
+-- | Email レコード
+data Email = Email
+    { emailFrom    :: String
+    , emailTo      :: String
+    , emailSubject :: String
+    , emailBody    :: String
+    } deriving (Show, Eq)
+
+-- | カリー化されたメール作成関数
+sendEmail :: String -> String -> String -> String -> Email
+sendEmail from to subject body = Email from to subject body
+
+-- | 部分適用でシステムメール送信関数を作成
+sendFromSystem :: String -> String -> String -> Email
+sendFromSystem = sendEmail "system@example.com"
+
+-- | さらに部分適用
+sendNotification :: String -> Email
+sendNotification = sendFromSystem "user@example.com" "通知"
+
+-- 使用例
+sendNotification "メッセージ本文"
+-- => Email { emailFrom = "system@example.com"
+--          , emailTo = "user@example.com"
+--          , emailSubject = "通知"
+--          , emailBody = "メッセージ本文" }
+```
+
+## 3. 複数の関数を並列適用 (juxt)
+
+Clojure の `juxt` に相当する機能はタプルで表現します：
+
+```haskell
+-- | 2つの関数を同じ入力に適用
+juxt2 :: (a -> b) -> (a -> c) -> a -> (b, c)
+juxt2 f1 f2 x = (f1 x, f2 x)
+
+-- | 3つの関数を同じ入力に適用
+juxt3 :: (a -> b) -> (a -> c) -> (a -> d) -> a -> (b, c, d)
+juxt3 f1 f2 f3 x = (f1 x, f2 x, f3 x)
+
+-- 使用例
+juxt2 (*2) (+10) 5  -- => (10, 15)
+juxt3 head last length [1, 2, 3]  -- => (1, 3, 3)
+```
+
+### 実用例：統計情報の取得
+
+```haskell
+-- | リストの統計情報を取得
+getStats :: [Int] -> (Int, Int, Int, Int, Int)
+getStats numbers =
+    ( head numbers      -- 最初の値
+    , last numbers      -- 最後の値
+    , length numbers    -- 要素数
+    , minimum numbers   -- 最小値
+    , maximum numbers   -- 最大値
+    )
+
+getStats [3, 1, 4, 1, 5, 9, 2, 6]  -- => (3, 6, 8, 1, 9)
+```
+
+### 実用例：人物分析
+
+```haskell
+data Category = Adult | Minor deriving (Show, Eq)
+
+data PersonAnalysis = PersonAnalysis
+    { analysisName     :: String
+    , analysisAge      :: Int
+    , analysisCategory :: Category
+    } deriving (Show, Eq)
+
+analyzePerson :: String -> Int -> PersonAnalysis
+analyzePerson name age = PersonAnalysis
+    { analysisName = name
+    , analysisAge = age
+    , analysisCategory = if age >= 18 then Adult else Minor
+    }
+
+analyzePerson "田中" 25  -- => PersonAnalysis {name="田中", age=25, category=Adult}
+analyzePerson "鈴木" 15  -- => PersonAnalysis {name="鈴木", age=15, category=Minor}
+```
+
+## 4. 高階関数
+
+高階関数は、関数を引数として受け取るか、関数を返す関数です。
+
+### ログ出力のラッパー
+
+```haskell
+-- | プロセスログ
+data ProcessLog a b = ProcessLog
+    { logInput  :: a
+    , logOutput :: b
+    } deriving (Show, Eq)
+
+-- | 関数をロギングでラップ（純粋バージョン）
+processWithLogging :: (a -> b) -> a -> (b, ProcessLog a b)
+processWithLogging f x =
+    let result = f x
+        logEntry = ProcessLog x result
+    in (result, logEntry)
+
+-- 使用例
+let (result, logEntry) = processWithLogging (*2) 5
+result      -- => 10
+logInput logEntry   -- => 5
+logOutput logEntry  -- => 10
+```
+
+### リトライ機能
+
+```haskell
+-- | リトライ結果
+data RetryResult a
+    = Success a
+    | Failure String Int  -- エラーメッセージと試行回数
+    deriving (Show, Eq)
+
+-- | 失敗する可能性のある関数をリトライ
+withRetry :: Int -> (a -> Either String b) -> a -> RetryResult b
+withRetry maxRetries f x = go 0
+  where
+    go attempts
+        | attempts >= maxRetries = Failure "Max retries exceeded" attempts
+        | otherwise = case f x of
+            Right result -> Success result
+            Left _ -> go (attempts + 1)
+
+-- 使用例
+let alwaysSucceed x = Right (x * 2)
+withRetry 3 alwaysSucceed 5  -- => Success 10
+
+let alwaysFail _ = Left "error" :: Either String Int
+withRetry 3 alwaysFail 5  -- => Failure "Max retries exceeded" 3
+```
+
+## 5. バリデーター（合成可能な関数）
+
+```haskell
+-- | バリデーション結果
+data ValidationResult
+    = Valid
+    | Invalid String
+    deriving (Show, Eq)
+
+-- | バリデーター型
+type Validator a = a -> ValidationResult
+
+-- | 空でないことを検証
+validateNonEmpty :: Validator String
+validateNonEmpty s
+    | null s    = Invalid "Value cannot be empty"
+    | otherwise = Valid
+
+-- | 最小長を検証
+validateMinLength :: Int -> Validator String
+validateMinLength minLen s
+    | length s < minLen = Invalid $ "Must be at least " ++ show minLen ++ " characters"
+    | otherwise = Valid
+
+-- | 最大長を検証
+validateMaxLength :: Int -> Validator String
+validateMaxLength maxLen s
+    | length s > maxLen = Invalid $ "Must be at most " ++ show maxLen ++ " characters"
+    | otherwise = Valid
+
+-- | メール形式を検証
+validateEmail :: Validator String
+validateEmail s
+    | '@' `elem` s && '.' `elem` s = Valid
+    | otherwise = Invalid "Invalid email format"
+
+-- | 2つのバリデーターを結合（AND論理）
+combineValidators :: Validator a -> Validator a -> Validator a
+combineValidators v1 v2 x = case v1 x of
+    Valid -> v2 x
+    invalid -> invalid
+
+-- | すべてのバリデーターで検証（エラーを収集）
+validateAll :: [Validator a] -> a -> [ValidationResult]
+validateAll validators x = filter isInvalid $ map ($ x) validators
+  where
+    isInvalid Valid = False
+    isInvalid (Invalid _) = True
+
+-- 使用例
+let combined = combineValidators validateNonEmpty (validateMinLength 3)
+combined "hello"  -- => Valid
+combined ""       -- => Invalid "Value cannot be empty"
+combined "hi"     -- => Invalid "Must be at least 3 characters"
+```
+
+## 6. まとめ
+
+| 概念 | Haskell での実現 |
+|-----|-----------------|
+| 関数合成 | `.` (右→左)、`>>>` (左→右) |
+| カリー化 | デフォルトで全関数がカリー化 |
+| 部分適用 | 引数を左から順に適用 |
+| 高階関数 | 関数を引数/戻り値として扱う |
+| 型シグネチャ | `a -> b -> c` は `a -> (b -> c)` |
+
+### ポイントフリースタイル
+
+```haskell
+-- ポイントあり（引数を明示）
+sumOfSquares xs = sum (map (^2) xs)
+
+-- ポイントフリー（引数を省略）
+sumOfSquares = sum . map (^2)
+```
+
+### 次のステップ
+
+- 第3章では型クラスによる多態性を学びます

package/lib/assets/docs/article/functional-desgin-ppp/haskell/03-polymorphism.md

@@ -0,0 +1,362 @@
+# 第3章: 多態性とディスパッチ
+
+## はじめに
+
+多態性（ポリモーフィズム）は、同じインターフェースで異なる振る舞いを実現する強力な概念です。Haskell では、代数的データ型（ADT）、型クラス、パターンマッチという複数のメカニズムで多態性を実現します。
+
+本章では、これらのメカニズムを使い分けて、柔軟で拡張性の高いコードを書く方法を学びます。
+
+## 1. 代数的データ型（ADT）による多態性
+
+### 基本的な使い方
+
+Haskell の代数的データ型は有限のバリエーションを定義するのに最適です：
+
+```haskell
+-- | 図形を表す代数的データ型
+data Shape
+    = Rectangle' { rectWidth :: Double, rectHeight :: Double }
+    | Circle' { circleRadius :: Double }
+    | Triangle' { triBase :: Double, triHeight :: Double }
+    | Square' { squareSide :: Double }
+    deriving (Show, Eq)
+
+-- | 面積を計算（パターンマッチ）
+calculateArea :: Shape -> Double
+calculateArea shape = case shape of
+    Rectangle' w h -> w * h
+    Circle' r      -> pi * r * r
+    Triangle' b h  -> b * h / 2
+    Square' s      -> s * s
+
+-- | 周囲長を計算
+calculatePerimeter :: Shape -> Double
+calculatePerimeter shape = case shape of
+    Rectangle' w h -> 2 * (w + h)
+    Circle' r      -> 2 * pi * r
+    Triangle' b h  -> b + 2 * sqrt ((b/2)^2 + h^2)
+    Square' s      -> 4 * s
+
+-- 使用例
+calculateArea (Rectangle' 4 5)  -- => 20.0
+calculateArea (Circle' 3)       -- => 28.27...
+calculateArea (Triangle' 6 5)   -- => 15.0
+```
+
+### ADT の利点
+
+1. **網羅性チェック**: コンパイラがすべてのケースをカバーしているか確認
+2. **型安全性**: 不正な型の値を渡せない
+3. **パターンマッチ**: 分岐を簡潔に記述可能
+
+## 2. 複合ディスパッチ
+
+タプルを使ったパターンマッチで、複数の値に基づくディスパッチを実現できます：
+
+```haskell
+-- | 支払い方法
+data PaymentMethod
+    = CreditCard
+    | BankTransfer
+    | Cash
+    | Cryptocurrency
+    deriving (Show, Eq)
+
+-- | 通貨
+data Currency = JPY | USD | EUR
+    deriving (Show, Eq)
+
+-- | 支払い情報
+data Payment = Payment
+    { paymentMethod   :: PaymentMethod
+    , paymentCurrency :: Currency
+    , paymentAmount   :: Int
+    } deriving (Show, Eq)
+
+-- | 支払い結果
+data PaymentResult = PaymentResult
+    { resultStatus    :: String
+    , resultMessage   :: String
+    , resultAmount    :: Int
+    , resultConverted :: Maybe Int
+    } deriving (Show, Eq)
+
+-- | 支払い処理（複合ディスパッチ）
+processPayment :: Payment -> PaymentResult
+processPayment payment = case (paymentMethod payment, paymentCurrency payment) of
+    (CreditCard, JPY) -> PaymentResult
+        { resultStatus = "processed"
+        , resultMessage = "クレジットカード（円）で処理しました"
+        , resultAmount = paymentAmount payment
+        , resultConverted = Nothing
+        }
+    (CreditCard, USD) -> PaymentResult
+        { resultStatus = "processed"
+        , resultMessage = "Credit card (USD) processed"
+        , resultAmount = paymentAmount payment
+        , resultConverted = Just (paymentAmount payment * 150)
+        }
+    (BankTransfer, JPY) -> PaymentResult
+        { resultStatus = "pending"
+        , resultMessage = "銀行振込を受け付けました"
+        , resultAmount = paymentAmount payment
+        , resultConverted = Nothing
+        }
+    (Cash, _) -> PaymentResult
+        { resultStatus = "processed"
+        , resultMessage = "現金で処理しました"
+        , resultAmount = paymentAmount payment
+        , resultConverted = Nothing
+        }
+    _ -> PaymentResult
+        { resultStatus = "error"
+        , resultMessage = "サポートされていない支払い方法です"
+        , resultAmount = paymentAmount payment
+        , resultConverted = Nothing
+        }
+```
+
+## 3. 階層的ディスパッチ
+
+ADT を使って型階層を表現できます：
+
+```haskell
+-- | 口座タイプ
+data AccountType
+    = Savings
+    | PremiumSavings  -- Savings の特化型
+    | Checking
+    deriving (Show, Eq)
+
+-- | 口座
+data Account = Account
+    { accountType    :: AccountType
+    , accountBalance :: Int
+    } deriving (Show, Eq)
+
+-- | 利率を取得
+getInterestRate :: AccountType -> Double
+getInterestRate Savings        = 0.02
+getInterestRate PremiumSavings = 0.05
+getInterestRate Checking       = 0.001
+
+-- | 利息を計算
+calculateInterest :: Account -> Double
+calculateInterest account =
+    fromIntegral (accountBalance account) * getInterestRate (accountType account)
+
+-- 使用例
+calculateInterest (Account Savings 10000)        -- => 200.0
+calculateInterest (Account PremiumSavings 10000) -- => 500.0
+calculateInterest (Account Checking 10000)       -- => 10.0
+```
+
+## 4. 型クラス（アドホック多相性）
+
+型クラスは、異なる型に共通の操作を定義する Haskell の主要な多態性メカニズムです：
+
+### 型クラスの定義
+
+```haskell
+-- | 2D座標
+data Point = Point
+    { pointX :: Double
+    , pointY :: Double
+    } deriving (Show, Eq)
+
+-- | 描画可能な型クラス
+class Drawable a where
+    draw :: a -> String
+    boundingBox :: a -> (Point, Point)  -- (最小点, 最大点)
+
+-- | 変換可能な型クラス
+class Transformable a where
+    translate :: Double -> Double -> a -> a
+    scale :: Double -> a -> a
+```
+
+### 型クラスのインスタンス
+
+```haskell
+-- | 矩形
+data Rectangle = Rectangle
+    { rectangleX      :: Double
+    , rectangleY      :: Double
+    , rectangleWidth  :: Double
+    , rectangleHeight :: Double
+    } deriving (Show, Eq)
+
+-- | 円
+data Circle = Circle
+    { circleCenterX :: Double
+    , circleCenterY :: Double
+    , circleR       :: Double
+    } deriving (Show, Eq)
+
+-- Drawable インスタンス
+instance Drawable Rectangle where
+    draw r = "Rectangle at (" ++ show (rectangleX r) ++ ", " ++ show (rectangleY r) ++ 
+             ") with size " ++ show (rectangleWidth r) ++ "x" ++ show (rectangleHeight r)
+    boundingBox r = 
+        ( Point (rectangleX r) (rectangleY r)
+        , Point (rectangleX r + rectangleWidth r) (rectangleY r + rectangleHeight r)
+        )
+
+instance Drawable Circle where
+    draw c = "Circle at (" ++ show (circleCenterX c) ++ ", " ++ show (circleCenterY c) ++ 
+             ") with radius " ++ show (circleR c)
+    boundingBox c =
+        ( Point (circleCenterX c - circleR c) (circleCenterY c - circleR c)
+        , Point (circleCenterX c + circleR c) (circleCenterY c + circleR c)
+        )
+
+-- Transformable インスタンス
+instance Transformable Rectangle where
+    translate dx dy r = r { rectangleX = rectangleX r + dx, rectangleY = rectangleY r + dy }
+    scale factor r = r { rectangleWidth = rectangleWidth r * factor
+                       , rectangleHeight = rectangleHeight r * factor }
+
+instance Transformable Circle where
+    translate dx dy c = c { circleCenterX = circleCenterX c + dx
+                          , circleCenterY = circleCenterY c + dy }
+    scale factor c = c { circleR = circleR c * factor }
+```
+
+### 型クラスの利点
+
+1. **オープンな拡張**: 新しい型にインスタンスを追加可能
+2. **型安全**: コンパイル時に型チェック
+3. **既存型の拡張**: 自分で定義していない型にもインスタンスを定義可能
+
+## 5. 存在型による異種コレクション
+
+異なる型を同じリストに格納するには存在型を使用します：
+
+```haskell
+-- | 描画可能な図形のラッパー
+data DrawableShape
+    = DrawableRect Rectangle
+    | DrawableCircle Circle
+    deriving (Show, Eq)
+
+instance Drawable DrawableShape where
+    draw (DrawableRect r) = draw r
+    draw (DrawableCircle c) = draw c
+    boundingBox (DrawableRect r) = boundingBox r
+    boundingBox (DrawableCircle c) = boundingBox c
+
+-- 異種リストの使用
+shapes :: [DrawableShape]
+shapes = 
+    [ DrawableRect (Rectangle 0 0 10 10)
+    , DrawableCircle (Circle 5 5 3)
+    ]
+
+-- すべての図形を描画
+drawAll :: [DrawableShape] -> [String]
+drawAll = map draw
+```
+
+## 6. 式の評価（Expression Problem）
+
+ADT は閉じた型のセットに対する操作の追加に適しています：
+
+```haskell
+-- | 式を表すADT
+data Expr
+    = Lit Int
+    | Add Expr Expr
+    | Mul Expr Expr
+    | Neg Expr
+    deriving (Show, Eq)
+
+-- | 式を評価
+eval :: Expr -> Int
+eval expr = case expr of
+    Lit n     -> n
+    Add e1 e2 -> eval e1 + eval e2
+    Mul e1 e2 -> eval e1 * eval e2
+    Neg e     -> negate (eval e)
+
+-- | 式を整形表示
+prettyPrint :: Expr -> String
+prettyPrint expr = case expr of
+    Lit n     -> show n
+    Add e1 e2 -> "(" ++ prettyPrint e1 ++ " + " ++ prettyPrint e2 ++ ")"
+    Mul e1 e2 -> "(" ++ prettyPrint e1 ++ " * " ++ prettyPrint e2 ++ ")"
+    Neg e     -> "(-" ++ prettyPrint e ++ ")"
+
+-- 使用例
+let expr = Add (Mul (Lit 2) (Lit 3)) (Neg (Lit 1))
+eval expr        -- => 5
+prettyPrint expr -- => "(2 * 3) + (-1)"
+```
+
+## 7. 動物の鳴き声（古典的な例）
+
+```haskell
+-- | 動物のADT
+data Animal
+    = Dog { dogName :: String }
+    | Cat { catName :: String }
+    | Bird { birdName :: String, birdCanFly :: Bool }
+    deriving (Show, Eq)
+
+-- | 鳴き声
+speak :: Animal -> String
+speak animal = case animal of
+    Dog name   -> name ++ " says: Woof!"
+    Cat name   -> name ++ " says: Meow!"
+    Bird name _ -> name ++ " says: Tweet!"
+
+-- | 移動方法
+move :: Animal -> String
+move animal = case animal of
+    Dog name      -> name ++ " runs on four legs"
+    Cat name      -> name ++ " prowls silently"
+    Bird name True -> name ++ " flies through the air"
+    Bird name False -> name ++ " hops on the ground"
+
+-- 使用例
+speak (Dog "Pochi")      -- => "Pochi says: Woof!"
+move (Bird "Kiwi" False) -- => "Kiwi hops on the ground"
+```
+
+## 8. まとめ
+
+```plantuml
+@startuml
+title Haskell における多態性のメカニズム
+
+package "ADT（代数的データ型）" {
+    [閉じた型のバリエーション]
+    [パターンマッチで処理]
+    [コンパイラによる網羅性チェック]
+}
+
+package "型クラス" {
+    [オープンな拡張]
+    [アドホック多相性]
+    [既存型への追加可能]
+}
+
+package "複合ディスパッチ" {
+    [タプルパターンマッチ]
+    [複数値に基づく分岐]
+}
+
+[ADT（代数的データ型）] --> [新しい操作の追加が容易]
+[型クラス] --> [新しい型の追加が容易]
+@enduml
+```
+
+| 方法 | 用途 | 利点 |
+|-----|------|------|
+| ADT + パターンマッチ | 閉じた型セット | 網羅性チェック、操作追加が容易 |
+| 型クラス | オープンな拡張 | 新しい型の追加が容易 |
+| 複合ディスパッチ | 複数条件での分岐 | 柔軟なマッチング |
+
+### 次のステップ
+
+- 第4章ではデータ検証について学びます
+- 第5章ではプロパティベーステスト（QuickCheck）を探ります