@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,313 +0,0 @@
----
-type: Article
-title: "第2章: 関数合成と高階関数"
-description: "関数型プログラミングの真髄は、小さな関数を組み合わせて複雑な処理を構築することにあります。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,371 +0,0 @@
----
-type: Article
-title: "第3章: 多態性とディスパッチ"
-description: "多態性（ポリモーフィズム）は、同じインターフェースで異なる振る舞いを実現する強力な概念です。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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）を探ります