@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/16-payroll-system.md

@@ -1,228 +0,0 @@
----
-type: Article
-title: "第16章: 給与計算システム"
-description: "本章では、給与計算システムを題材に、関数型プログラミングにおけるドメインモデリングと多態性の実現を学びます。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第16章: 給与計算システム
-
-## はじめに
-
-本章では、給与計算システムを題材に、関数型プログラミングにおけるドメインモデリングと多態性の実現を学びます。
-
-この問題を通じて以下の概念を学びます：
-
-- ADT によるデータ仕様定義
-- パターンマッチングによる給与タイプ別の計算
-- 支払いスケジュールのモデリング
-
-## 1. ドメインモデル
-
-### 従業員の給与タイプ
-
-給与計算システムでは、以下の3種類の給与タイプをサポートします：
-
-- **月給制（Salaried）**: 固定月給
-- **時給制（Hourly）**: 労働時間に基づく給与（残業は1.5倍）
-- **歩合制（Commissioned）**: 基本給 + 売上に応じたコミッション
-
-## 2. 型定義
-
-### 給与分類
-
-```haskell
--- | Pay classification determines how pay is calculated
-data PayClass
-  = Salaried Double                    -- ^ Fixed salary
-  | Hourly Double                      -- ^ Hourly rate
-  | Commissioned Double Double         -- ^ Base pay, commission rate
-  deriving (Show, Eq)
-```
-
-### 支払いスケジュールと方法
-
-```haskell
--- | Payment schedule
-data PaySchedule
-  = Monthly    -- ^ Paid monthly (last day of month)
-  | Weekly     -- ^ Paid weekly (every Friday)
-  | BiWeekly   -- ^ Paid every two weeks
-  deriving (Show, Eq)
-
--- | Payment method
-data PaymentMethod
-  = Hold            -- ^ Hold for pickup
-  | DirectDeposit String  -- ^ Direct deposit to account
-  | Mail String     -- ^ Mail to address
-  deriving (Show, Eq)
-```
-
-### 従業員レコード
-
-```haskell
--- | Employee record
-data Employee = Employee
-  { employeeId :: EmployeeId
-  , employeeName :: String
-  , employeePayClass :: PayClass
-  , employeeSchedule :: PaySchedule
-  , employeePaymentMethod :: PaymentMethod
-  } deriving (Show, Eq)
-```
-
-## 3. 従業員の作成
-
-```haskell
--- | Create a salaried employee
-makeSalariedEmployee :: EmployeeId -> String -> Double -> Employee
-makeSalariedEmployee eid name salary = Employee
-  { employeeId = eid
-  , employeeName = name
-  , employeePayClass = Salaried salary
-  , employeeSchedule = Monthly
-  , employeePaymentMethod = Hold
-  }
-
--- | Create an hourly employee
-makeHourlyEmployee :: EmployeeId -> String -> Double -> Employee
-makeHourlyEmployee eid name hourlyRate = Employee
-  { employeeId = eid
-  , employeeName = name
-  , employeePayClass = Hourly hourlyRate
-  , employeeSchedule = Weekly
-  , employeePaymentMethod = Hold
-  }
-
--- | Create a commissioned employee
-makeCommissionedEmployee :: EmployeeId -> String -> Double -> Double -> Employee
-makeCommissionedEmployee eid name basePay commissionRate = Employee
-  { employeeId = eid
-  , employeeName = name
-  , employeePayClass = Commissioned basePay commissionRate
-  , employeeSchedule = BiWeekly
-  , employeePaymentMethod = Hold
-  }
-```
-
-## 4. タイムカードと売上データ
-
-```haskell
--- | Time card for hourly employees
-data TimeCard = TimeCard
-  { tcDate :: Day
-  , tcHours :: Double
-  } deriving (Show, Eq)
-
--- | Sales receipt for commissioned employees
-data SalesReceipt = SalesReceipt
-  { srDate :: Day
-  , srAmount :: Double
-  } deriving (Show, Eq)
-
--- | Context for pay calculation
-data PayContext = PayContext
-  { ctxTimeCards :: Map EmployeeId [TimeCard]
-  , ctxSalesReceipts :: Map EmployeeId [SalesReceipt]
-  , ctxPayDate :: Day
-  } deriving (Show, Eq)
-```
-
-## 5. 給与計算
-
-### パターンマッチングによる計算
-
-```haskell
--- | Calculate pay for an employee
-calculatePay :: Employee -> PayContext -> Double
-calculatePay emp ctx = case employeePayClass emp of
-  Salaried salary -> salary
-  Hourly rate -> calculateHourlyPay rate (getTimeCards emp ctx)
-  Commissioned basePay commRate -> 
-    calculateCommissionedPay basePay commRate (getSalesReceipts emp ctx)
-```
-
-### 時給制の計算
-
-```haskell
--- | Calculate hourly pay with overtime (1.5x for hours over 40)
-calculateHourlyPay :: Double -> [TimeCard] -> Double
-calculateHourlyPay rate cards =
-  let totalHours = sum (map tcHours cards)
-      regularHours = min totalHours 40
-      overtimeHours = max 0 (totalHours - 40)
-  in regularHours * rate + overtimeHours * rate * 1.5
-```
-
-### 歩合制の計算
-
-```haskell
--- | Calculate commissioned pay
-calculateCommissionedPay :: Double -> Double -> [SalesReceipt] -> Double
-calculateCommissionedPay basePay commRate receipts =
-  let totalSales = sum (map srAmount receipts)
-  in basePay + totalSales * commRate
-```
-
-## 6. 給与支払い処理
-
-```haskell
--- | Pay check issued to an employee
-data PayCheck = PayCheck
-  { checkEmployeeId :: EmployeeId
-  , checkEmployeeName :: String
-  , checkAmount :: Double
-  , checkMethod :: PaymentMethod
-  } deriving (Show, Eq)
-
--- | Process a single employee
-processEmployee :: Employee -> PayContext -> PayCheck
-processEmployee emp ctx = PayCheck
-  { checkEmployeeId = employeeId emp
-  , checkEmployeeName = employeeName emp
-  , checkAmount = calculatePay emp ctx
-  , checkMethod = employeePaymentMethod emp
-  }
-
--- | Run payroll for all employees
-runPayroll :: [Employee] -> PayContext -> [PayCheck]
-runPayroll employees ctx = map (`processEmployee` ctx) employees
-```
-
-## 7. テスト
-
-```haskell
-describe "calculatePay" $ do
-  it "calculates salaried pay" $ do
-    let emp = makeSalariedEmployee "E001" "John" 5000
-        ctx = emptyContext (fromGregorian 2026 1 31)
-    calculatePay emp ctx `shouldBe` 5000
-
-  it "calculates hourly pay with overtime" $ do
-    let emp = makeHourlyEmployee "E001" "Jane" 20.0
-        ctx = emptyContext (fromGregorian 2026 1 7)
-        cards = [TimeCard (fromGregorian 2026 1 d) 10.0 | d <- [1..5]]
-        ctx' = foldr (addTimeCard "E001") ctx cards
-    -- 40 * 20 + 10 * 20 * 1.5 = 800 + 300 = 1100
-    calculatePay emp ctx' `shouldBe` 1100.0
-
-  it "calculates commissioned pay" $ do
-    let emp = makeCommissionedEmployee "E001" "Bob" 1500 0.10
-        ctx = emptyContext (fromGregorian 2026 1 14)
-        sr1 = SalesReceipt (fromGregorian 2026 1 10) 5000.0
-        ctx' = addSalesReceipt "E001" sr1 ctx
-    -- 1500 + 5000 * 0.10 = 1500 + 500 = 2000
-    calculatePay emp ctx' `shouldBe` 2000.0
-```
-
-## まとめ
-
-給与計算システムの Haskell 実装のポイント：
-
-1. **ADT による分類**: `PayClass` で給与タイプを表現
-2. **パターンマッチング**: `case` 式で給与タイプ別に処理
-3. **コンテキストパターン**: `PayContext` で計算に必要なデータを渡す
-4. **純粋関数**: 副作用のない計算で予測可能な動作
-5. **スマートコンストラクタ**: `makeSalariedEmployee` 等で一貫した初期化

package/lib/assets/docs/article/functional-desgin-ppp/haskell/17-video-rental-system.md

@@ -1,253 +0,0 @@
----
-type: Article
-title: "第17章: レンタルビデオシステム"
-description: "本章では、Martin Fowler の「リファクタリング」で有名なレンタルビデオシステムを題材に、関数型プログラミングによる料金計算ロジックの設計を学びます。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第17章: レンタルビデオシステム
-
-## はじめに
-
-本章では、Martin Fowler の「リファクタリング」で有名なレンタルビデオシステムを題材に、関数型プログラミングによる料金計算ロジックの設計を学びます。
-
-この問題を通じて以下の概念を学びます：
-
-- ADT によるカテゴリ別ポリシーパターン
-- 明細書フォーマッターの実装
-- データと処理の分離
-
-## 1. ドメインモデル
-
-### 映画のカテゴリ
-
-レンタルビデオシステムでは、以下の3種類の映画カテゴリをサポートします：
-
-- **通常（Regular）**: 2日まで$2.0、以降1日ごとに$1.5追加
-- **新作（New Release）**: 1日ごとに$3.0
-- **子供向け（Children's）**: 3日まで$1.5、以降1日ごとに$1.5追加
-
-## 2. 型定義
-
-### 映画とカテゴリ
-
-```haskell
--- | Movie category determines pricing rules
-data Category
-  = Regular       -- ^ 2 days for $2, then $1.5/day
-  | NewRelease    -- ^ $3/day
-  | Childrens     -- ^ 3 days for $1.5, then $1.5/day
-  deriving (Show, Eq)
-
--- | A movie with title and category
-data Movie = Movie
-  { movieTitle :: String
-  , movieCategory :: Category
-  } deriving (Show, Eq)
-```
-
-### 映画作成のヘルパー
-
-```haskell
--- | Create a movie
-makeMovie :: String -> Category -> Movie
-makeMovie = Movie
-
--- | Create a regular movie
-makeRegular :: String -> Movie
-makeRegular title = makeMovie title Regular
-
--- | Create a new release movie
-makeNewRelease :: String -> Movie
-makeNewRelease title = makeMovie title NewRelease
-
--- | Create a children's movie
-makeChildrens :: String -> Movie
-makeChildrens title = makeMovie title Childrens
-```
-
-### レンタル
-
-```haskell
--- | A rental of a movie for a number of days
-data Rental = Rental
-  { rentalMovie :: Movie
-  , rentalDays :: Int
-  } deriving (Show, Eq)
-
--- | Create a rental
-makeRental :: Movie -> Int -> Rental
-makeRental = Rental
-```
-
-## 3. 料金計算
-
-### パターンマッチングによる料金計算
-
-```haskell
--- | Calculate the rental amount based on movie category and days
-calculateAmount :: Rental -> Double
-calculateAmount rental = case movieCategory (rentalMovie rental) of
-  Regular ->
-    if days > 2
-    then 2.0 + fromIntegral (days - 2) * 1.5
-    else 2.0
-  
-  NewRelease ->
-    fromIntegral days * 3.0
-  
-  Childrens ->
-    if days > 3
-    then 1.5 + fromIntegral (days - 3) * 1.5
-    else 1.5
-  where
-    days = rentalDays rental
-```
-
-### ポイント計算
-
-```haskell
--- | Calculate frequent renter points
-calculatePoints :: Rental -> Int
-calculatePoints rental = case movieCategory (rentalMovie rental) of
-  NewRelease -> if rentalDays rental > 1 then 2 else 1
-  _ -> 1
-```
-
-## 4. 顧客モデル
-
-```haskell
--- | A customer with name and rentals
-data Customer = Customer
-  { customerName :: String
-  , customerRentals :: [Rental]
-  } deriving (Show, Eq)
-
--- | Create a customer with no rentals
-makeCustomer :: String -> Customer
-makeCustomer name = Customer name []
-
--- | Add a rental to a customer
-addRental :: Rental -> Customer -> Customer
-addRental rental customer = customer
-  { customerRentals = rental : customerRentals customer
-  }
-```
-
-### 集計関数
-
-```haskell
--- | Calculate total amount for all rentals
-totalAmount :: Customer -> Double
-totalAmount = sum . map calculateAmount . customerRentals
-
--- | Calculate total points for all rentals
-totalPoints :: Customer -> Int
-totalPoints = sum . map calculatePoints . customerRentals
-```
-
-## 5. 明細書フォーマッター
-
-### フォーマット種別
-
-```haskell
--- | Statement format
-data StatementFormat = TextFormat | HtmlFormat
-  deriving (Show, Eq)
-
--- | Generate a rental statement in the specified format
-generateStatement :: StatementFormat -> Customer -> String
-generateStatement format = case format of
-  TextFormat -> generateTextStatement
-  HtmlFormat -> generateHtmlStatement
-```
-
-### テキストフォーマット
-
-```haskell
--- | Generate a plain text statement
-generateTextStatement :: Customer -> String
-generateTextStatement customer = unlines
-  [ "Rental Record for " ++ customerName customer
-  , ""
-  ] ++ rentalLines ++ unlines
-  [ ""
-  , "Amount owed is " ++ show (totalAmount customer)
-  , "You earned " ++ show (totalPoints customer) ++ " frequent renter points"
-  ]
-  where
-    rentalLines = unlines $ map formatRentalLine (customerRentals customer)
-    formatRentalLine rental = 
-      "\t" ++ movieTitle (rentalMovie rental) ++ "\t" ++ show (calculateAmount rental)
-```
-
-### HTML フォーマット
-
-```haskell
--- | Generate an HTML statement
-generateHtmlStatement :: Customer -> String
-generateHtmlStatement customer = unlines
-  [ "<html>"
-  , "<head><title>Rental Statement</title></head>"
-  , "<body>"
-  , "<h1>Rental Record for " ++ customerName customer ++ "</h1>"
-  , "<table>"
-  , "<tr><th>Movie</th><th>Amount</th></tr>"
-  ] ++ rentalRows ++ unlines
-  [ "</table>"
-  , "<p>Amount owed is <strong>" ++ show (totalAmount customer) ++ "</strong></p>"
-  , "<p>You earned <strong>" ++ show (totalPoints customer) 
-    ++ "</strong> frequent renter points</p>"
-  , "</body>"
-  , "</html>"
-  ]
-  where
-    rentalRows = unlines $ map formatRentalRow (customerRentals customer)
-    formatRentalRow rental =
-      "<tr><td>" ++ movieTitle (rentalMovie rental) 
-      ++ "</td><td>" ++ show (calculateAmount rental) ++ "</td></tr>"
-```
-
-## 6. テスト
-
-```haskell
-describe "calculateAmount" $ do
-  it "charges $2 for 1-2 day regular rental" $ do
-    let rental = makeRental (makeRegular "Test") 2
-    calculateAmount rental `shouldBe` 2.0
-  
-  it "charges extra for regular rental over 2 days" $ do
-    let rental = makeRental (makeRegular "Test") 5
-    -- 2 + 3 * 1.5 = 6.5
-    calculateAmount rental `shouldBe` 6.5
-  
-  it "charges $3/day for new release" $ do
-    let rental = makeRental (makeNewRelease "Test") 5
-    calculateAmount rental `shouldBe` 15.0
-
-describe "calculatePoints" $ do
-  it "earns bonus points for new release over 1 day" $ do
-    let rental = makeRental (makeNewRelease "Test") 2
-    calculatePoints rental `shouldBe` 2
-
-describe "generateStatement" $ do
-  it "generates correct text statement" $ do
-    let customer = addRental (makeRental (makeRegular "The Matrix") 3)
-                 $ makeCustomer "John"
-    let statement = generateTextStatement customer
-    statement `shouldContain` "Rental Record for John"
-    statement `shouldContain` "The Matrix"
-```
-
-## まとめ
-
-レンタルビデオシステムの Haskell 実装のポイント：
-
-1. **ADT でカテゴリを表現**: `Category` 型でビジネスルールを型に埋め込む
-2. **パターンマッチングで料金計算**: 各カテゴリの計算ルールを明示的に記述
-3. **不変データ構造**: `addRental` は新しい `Customer` を返す
-4. **関数合成で集計**: `totalAmount = sum . map calculateAmount . customerRentals`
-5. **フォーマッター分離**: ビジネスロジックと表示ロジックを分離
-6. **拡張性**: 新しいカテゴリやフォーマットを追加しやすい設計