@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,342 @@
+# 第16章: 給与計算システム
+
+## はじめに
+
+本章では、給与計算システムを題材に、関数型プログラミングにおけるドメインモデリングと多態性の実現を学びます。
+
+この問題を通じて以下の概念を学びます：
+
+- Sealed trait と case class によるドメインモデリング
+- 型クラスによる給与タイプ別の計算
+- 支払いスケジュールのモデリング
+- イベントソーシング風の履歴管理
+
+## 1. ドメインモデル
+
+### 給与タイプ
+
+給与計算システムでは、以下の3種類の給与タイプをサポートします：
+
+- **月給制（Salaried）**: 固定月給
+- **時給制（Hourly）**: 労働時間に基づく給与
+- **歩合制（Commissioned）**: 基本給 + 売上に応じたコミッション
+
+```scala
+sealed trait PayClass:
+  def payType: String
+
+case class Salaried(salary: Money) extends PayClass:
+  def payType: String = "salaried"
+
+case class Hourly(hourlyRate: Money) extends PayClass:
+  def payType: String = "hourly"
+
+case class Commissioned(basePay: Money, commissionRate: Rate) extends PayClass:
+  def payType: String = "commissioned"
+```
+
+### 支払いスケジュール
+
+```scala
+enum Schedule:
+  case Monthly   // 月次（月末）
+  case Weekly    // 週次（毎週金曜日）
+  case Biweekly  // 隔週（隔週金曜日）
+```
+
+### 支払い方法
+
+```scala
+enum PaymentMethod:
+  case Hold                                   // 保留
+  case DirectDeposit(accountNumber: String)  // 口座振込
+  case Mail(address: String)                 // 小切手郵送
+```
+
+## 2. 従業員モデル
+
+```scala
+case class Employee(
+  id: EmployeeId,
+  name: String,
+  payClass: PayClass,
+  schedule: Schedule,
+  paymentMethod: PaymentMethod,
+  address: Option[String] = None
+)
+
+object Employee:
+  def salaried(id: EmployeeId, name: String, salary: Money): Employee =
+    Employee(id, name, Salaried(salary), Schedule.Monthly, PaymentMethod.Hold)
+
+  def hourly(id: EmployeeId, name: String, hourlyRate: Money): Employee =
+    Employee(id, name, Hourly(hourlyRate), Schedule.Weekly, PaymentMethod.Hold)
+
+  def commissioned(id: EmployeeId, name: String, basePay: Money, commissionRate: Rate): Employee =
+    Employee(id, name, Commissioned(basePay, commissionRate), Schedule.Biweekly, PaymentMethod.Hold)
+```
+
+## 3. コンテキスト（タイムカード、売上）
+
+```scala
+case class TimeCard(employeeId: EmployeeId, date: String, hours: Hours)
+case class SalesReceipt(employeeId: EmployeeId, date: String, amount: Money)
+
+case class PayrollContext(
+  timeCards: Map[EmployeeId, List[TimeCard]] = Map.empty.withDefaultValue(Nil),
+  salesReceipts: Map[EmployeeId, List[SalesReceipt]] = Map.empty.withDefaultValue(Nil)
+):
+  def addTimeCard(tc: TimeCard): PayrollContext = ...
+  def addSalesReceipt(sr: SalesReceipt): PayrollContext = ...
+```
+
+### 使用例
+
+```scala
+val ctx = PayrollContext.empty
+  .addTimeCard(TimeCard("E002", "2024-01-15", 8))
+  .addTimeCard(TimeCard("E002", "2024-01-16", 10))
+  .addSalesReceipt(SalesReceipt("E003", "2024-01-15", BigDecimal(100000)))
+```
+
+## 4. 給与計算
+
+### 型クラスアプローチ
+
+```scala
+trait PayCalculator[P <: PayClass]:
+  def calculate(payClass: P, context: PayrollContext, employeeId: EmployeeId): Money
+
+given PayCalculator[Salaried] with
+  def calculate(payClass: Salaried, context: PayrollContext, employeeId: EmployeeId): Money =
+    payClass.salary
+
+given PayCalculator[Hourly] with
+  def calculate(payClass: Hourly, context: PayrollContext, employeeId: EmployeeId): Money =
+    val timeCards = context.getTimeCards(employeeId)
+    val totalHours = timeCards.map(_.hours).sum
+    val regularHours = math.min(totalHours, 40.0)
+    val overtimeHours = math.max(0.0, totalHours - 40.0)
+    payClass.hourlyRate * BigDecimal(regularHours) +
+      payClass.hourlyRate * BigDecimal(overtimeHours) * BigDecimal(1.5)
+
+given PayCalculator[Commissioned] with
+  def calculate(payClass: Commissioned, context: PayrollContext, employeeId: EmployeeId): Money =
+    val salesReceipts = context.getSalesReceipts(employeeId)
+    val totalSales = salesReceipts.map(_.amount).sum
+    payClass.basePay + totalSales * BigDecimal(payClass.commissionRate)
+```
+
+### 計算例
+
+```scala
+// 月給制: 固定給与
+val salaried = Employee.salaried("E001", "田中", BigDecimal(500000))
+calculatePay(salaried, ctx) // => 500000
+
+// 時給制: 40時間 * 1500 + 5時間 * 1500 * 1.5 = 67500
+val hourly = Employee.hourly("E002", "佐藤", BigDecimal(1500))
+val ctx = PayrollContext.empty.addTimeCard(TimeCard("E002", "2024-01-15", 45))
+calculatePay(hourly, ctx) // => 67500
+
+// 歩合制: 200000 + 150000 * 0.1 = 215000
+val commissioned = Employee.commissioned("E003", "鈴木", BigDecimal(200000), 0.1)
+val ctx = PayrollContext.empty
+  .addSalesReceipt(SalesReceipt("E003", "2024-01-15", BigDecimal(150000)))
+calculatePay(commissioned, ctx) // => 215000
+```
+
+## 5. 支払いスケジュール判定
+
+```scala
+case class PayDate(
+  year: Int,
+  month: Int,
+  day: Int,
+  dayOfWeek: DayOfWeek,
+  isLastDayOfMonth: Boolean,
+  isPayWeek: Boolean = true
+)
+
+def isPayDay(employee: Employee, date: PayDate): Boolean =
+  employee.schedule match
+    case Schedule.Monthly => date.isLastDayOfMonth
+    case Schedule.Weekly => date.dayOfWeek == DayOfWeek.Friday
+    case Schedule.Biweekly => date.dayOfWeek == DayOfWeek.Friday && date.isPayWeek
+```
+
+## 6. 支払い処理
+
+```scala
+sealed trait PaymentResult:
+  def employeeId: EmployeeId
+  def amount: Money
+
+case class HeldPayment(employeeId: EmployeeId, amount: Money) extends PaymentResult
+case class DirectDepositPayment(employeeId: EmployeeId, amount: Money, accountNumber: String) extends PaymentResult
+case class MailedPayment(employeeId: EmployeeId, amount: Money, address: String) extends PaymentResult
+
+def processPayment(employee: Employee, amount: Money): PaymentResult =
+  employee.paymentMethod match
+    case PaymentMethod.Hold =>
+      HeldPayment(employee.id, amount)
+    case PaymentMethod.DirectDeposit(account) =>
+      DirectDepositPayment(employee.id, amount, account)
+    case PaymentMethod.Mail(address) =>
+      MailedPayment(employee.id, amount, address)
+```
+
+## 7. 給与支払い実行
+
+```scala
+def runPayroll(employees: Seq[Employee], context: PayrollContext, date: PayDate): Seq[PaymentResult] =
+  employees
+    .filter(isPayDay(_, date))
+    .map { emp =>
+      val pay = calculatePay(emp, context)
+      processPayment(emp, pay)
+    }
+```
+
+## 8. 給与明細と控除
+
+### 給与明細
+
+```scala
+case class Payslip(
+  employeeId: EmployeeId,
+  employeeName: String,
+  payPeriod: String,
+  grossPay: Money,
+  deductions: Map[String, Money] = Map.empty,
+  netPay: Money
+):
+  def addDeduction(name: String, amount: Money): Payslip =
+    val newDeductions = deductions + (name -> amount)
+    val newNetPay = grossPay - newDeductions.values.sum
+    copy(deductions = newDeductions, netPay = newNetPay)
+```
+
+### 控除タイプ
+
+```scala
+sealed trait Deduction:
+  def name: String
+  def calculate(grossPay: Money): Money
+
+case class FixedDeduction(name: String, amount: Money) extends Deduction:
+  def calculate(grossPay: Money): Money = amount
+
+case class PercentageDeduction(name: String, rate: Rate) extends Deduction:
+  def calculate(grossPay: Money): Money = grossPay * BigDecimal(rate)
+```
+
+### 使用例
+
+```scala
+val deductions = Seq(
+  FixedDeduction("健康保険", BigDecimal(10000)),
+  PercentageDeduction("所得税", 0.1)
+)
+val payslip = Payslip.create(emp, "2024-01", BigDecimal(500000))
+val result = applyDeductions(payslip, deductions)
+// grossPay: 500000, deductions: {健康保険: 10000, 所得税: 50000}, netPay: 440000
+```
+
+## 9. 給与計算サービス
+
+```scala
+class PayrollService(
+  repository: EmployeeRepository,
+  deductions: Seq[Deduction] = Seq.empty
+):
+  def addEmployee(employee: Employee): Employee = ...
+  def removeEmployee(id: EmployeeId): Option[Employee] = ...
+  def getEmployee(id: EmployeeId): Option[Employee] = ...
+  def updateEmployee(id: EmployeeId, f: Employee => Employee): Option[Employee] = ...
+
+  def runPayroll(context: PayrollContext, date: PayDate, payPeriod: String): Seq[Payslip] =
+    val employees = repository.findAll
+    employees
+      .filter(isPayDay(_, date))
+      .map { emp =>
+        val grossPay = calculatePay(emp, context)
+        val payslip = Payslip.create(emp, payPeriod, grossPay)
+        applyDeductions(payslip, deductions)
+      }
+```
+
+## 10. イベントソーシング
+
+```scala
+sealed trait PayrollEvent:
+  def timestamp: Long
+  def employeeId: EmployeeId
+
+case class EmployeeAdded(timestamp: Long, employeeId: EmployeeId, employee: Employee) extends PayrollEvent
+case class EmployeeRemoved(timestamp: Long, employeeId: EmployeeId) extends PayrollEvent
+case class TimeCardAdded(timestamp: Long, employeeId: EmployeeId, timeCard: TimeCard) extends PayrollEvent
+case class PayrollRun(timestamp: Long, employeeId: EmployeeId, amount: Money) extends PayrollEvent
+
+class EventStore:
+  private var events: List[PayrollEvent] = Nil
+  def append(event: PayrollEvent): Unit = events = event :: events
+  def getEvents: List[PayrollEvent] = events.reverse
+  def getEventsByEmployee(employeeId: EmployeeId): List[PayrollEvent] = ...
+```
+
+## 11. DSL
+
+```scala
+object PayrollDSL:
+  def employee(id: EmployeeId)(name: String): EmployeeBuilder =
+    EmployeeBuilder(id, name)
+
+  case class EmployeeBuilder(...):
+    def salaried(salary: Money): EmployeeBuilder = ...
+    def hourly(rate: Money): EmployeeBuilder = ...
+    def commissioned(basePay: Money, commissionRate: Rate): EmployeeBuilder = ...
+    def withDirectDeposit(account: String): EmployeeBuilder = ...
+    def withMailPayment(address: String): EmployeeBuilder = ...
+    def build: Employee = ...
+
+// 使用例
+import PayrollDSL.*
+val emp = employee("E001")("田中太郎")
+  .salaried(BigDecimal(500000))
+  .withDirectDeposit("1234567890")
+  .build
+```
+
+## 12. Clojure との比較
+
+| 概念 | Clojure | Scala |
+|------|---------|-------|
+| ドメインモデル | マップ + Spec | case class + sealed trait |
+| 多態性 | マルチメソッド | パターンマッチ / 型クラス |
+| 給与計算 | `defmulti`/`defmethod` | `given`/`summon` |
+| 支払い方法 | キーワード | enum |
+| コンテキスト | マップ | case class |
+
+## 13. 関数型アプローチの利点
+
+1. **テスト容易性**: 純粋関数なのでテストが簡単
+2. **拡張容易性**: 新しい給与タイプは新しい型クラスインスタンスを追加するだけ
+3. **関心の分離**: 給与計算、スケジュール判定、支払い処理が分離
+4. **型安全性**: コンパイル時に多くのエラーを検出
+
+## まとめ
+
+本章では、給与計算システムを通じて以下を学びました：
+
+1. **ドメインモデリング**: sealed trait と case class による表現
+2. **型クラス**: 給与タイプによる多態的な計算
+3. **イミュータブル設計**: すべての操作が新しいインスタンスを返す
+4. **DSL**: 流暢なAPIによる従業員定義
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/scala/part6/src/main/scala/PayrollSystem.scala`
+- テストコード: `apps/scala/part6/src/test/scala/PayrollSystemSpec.scala`

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

@@ -0,0 +1,324 @@
+# 第17章: レンタルビデオシステム
+
+## はじめに
+
+本章では、Martin Fowler の「リファクタリング」で有名なレンタルビデオシステムを題材に、関数型プログラミングによる料金計算ロジックの設計を学びます。
+
+この問題を通じて以下の概念を学びます：
+
+- パターンマッチによる料金計算
+- 明細書フォーマッターの実装
+- データと処理の分離
+- DSL による流暢な API
+
+## 1. ドメインモデル
+
+### 映画カテゴリ
+
+レンタルビデオシステムでは、以下の3種類の映画カテゴリをサポートします：
+
+- **通常（Regular）**: 2日まで2.0、以降1日ごとに1.5追加
+- **新作（New Release）**: 1日ごとに3.0
+- **子供向け（Children's）**: 3日まで1.5、以降1日ごとに1.5追加
+
+```scala
+enum MovieCategory:
+  case Regular     // 通常
+  case NewRelease  // 新作
+  case Childrens   // 子供向け
+```
+
+### 映画
+
+```scala
+case class Movie(title: String, category: MovieCategory)
+
+object Movie:
+  def regular(title: String): Movie = Movie(title, MovieCategory.Regular)
+  def newRelease(title: String): Movie = Movie(title, MovieCategory.NewRelease)
+  def childrens(title: String): Movie = Movie(title, MovieCategory.Childrens)
+```
+
+### レンタルと顧客
+
+```scala
+case class Rental(movie: Movie, days: Days)
+
+case class Customer(name: String, rentals: List[Rental] = Nil):
+  def addRental(rental: Rental): Customer = copy(rentals = rentals :+ rental)
+```
+
+## 2. 料金計算
+
+### 料金計算器
+
+```scala
+trait PriceCalculator:
+  def calculateAmount(days: Days): Money
+  def calculatePoints(days: Days): Points
+
+object RegularPricing extends PriceCalculator:
+  def calculateAmount(days: Days): Money =
+    if days > 2 then BigDecimal(2.0) + BigDecimal((days - 2) * 1.5)
+    else BigDecimal(2.0)
+  def calculatePoints(days: Days): Points = 1
+
+object NewReleasePricing extends PriceCalculator:
+  def calculateAmount(days: Days): Money = BigDecimal(days * 3.0)
+  def calculatePoints(days: Days): Points = if days > 1 then 2 else 1
+
+object ChildrensPricing extends PriceCalculator:
+  def calculateAmount(days: Days): Money =
+    if days > 3 then BigDecimal(1.5) + BigDecimal((days - 3) * 1.5)
+    else BigDecimal(1.5)
+  def calculatePoints(days: Days): Points = 1
+```
+
+### 計算例
+
+| カテゴリ | 日数 | 料金計算 | 結果 |
+|---------|------|---------|------|
+| 通常 | 2日 | 2.0 | 2.0 |
+| 通常 | 5日 | 2.0 + 3 * 1.5 | 6.5 |
+| 新作 | 3日 | 3 * 3.0 | 9.0 |
+| 子供向け | 3日 | 1.5 | 1.5 |
+| 子供向け | 6日 | 1.5 + 3 * 1.5 | 6.0 |
+
+## 3. 明細データ
+
+```scala
+case class RentalLine(
+  title: String,
+  days: Days,
+  amount: Money,
+  points: Points
+)
+
+case class StatementData(
+  customerName: String,
+  rentalLines: List[RentalLine],
+  totalAmount: Money,
+  totalPoints: Points
+)
+
+def generateStatementData(customer: Customer): StatementData =
+  val lines = customer.rentals.map { rental =>
+    RentalLine(
+      title = rental.movie.title,
+      days = rental.days,
+      amount = calculateRentalAmount(rental),
+      points = calculateRentalPoints(rental)
+    )
+  }
+  StatementData(
+    customerName = customer.name,
+    rentalLines = lines,
+    totalAmount = totalAmount(customer.rentals),
+    totalPoints = totalPoints(customer.rentals)
+  )
+```
+
+## 4. 明細書フォーマッター
+
+### フォーマット形式
+
+```scala
+enum StatementFormat:
+  case Text
+  case Html
+  case Json
+```
+
+### テキスト形式
+
+```scala
+object TextFormatter extends StatementFormatter:
+  def format(data: StatementData): String =
+    val header = s"Rental Record for ${data.customerName}\n"
+    val lines = data.rentalLines.map { line =>
+      s"\t${line.title}\t${line.amount}\n"
+    }.mkString
+    val footer = s"Amount owed is ${data.totalAmount}\n" +
+      s"You earned ${data.totalPoints} frequent renter points"
+    header + lines + footer
+```
+
+### HTML形式
+
+```scala
+object HtmlFormatter extends StatementFormatter:
+  def format(data: StatementData): String =
+    val header = s"<h1>Rental Record for <em>${data.customerName}</em></h1>\n<ul>\n"
+    val lines = data.rentalLines.map { line =>
+      s"  <li>${line.title} - ${line.amount}</li>\n"
+    }.mkString
+    val footer = s"</ul>\n" +
+      s"<p>Amount owed is <strong>${data.totalAmount}</strong></p>\n" +
+      s"<p>You earned <strong>${data.totalPoints}</strong> frequent renter points</p>"
+    header + lines + footer
+```
+
+### 出力例
+
+**テキスト形式:**
+```
+Rental Record for John
+  Inception  3.5
+  Frozen     3.0
+  New Movie  6.0
+Amount owed is 12.5
+You earned 4 frequent renter points
+```
+
+**HTML形式:**
+```html
+<h1>Rental Record for <em>John</em></h1>
+<ul>
+  <li>Inception - 3.5</li>
+  <li>Frozen - 3.0</li>
+  <li>New Movie - 6.0</li>
+</ul>
+<p>Amount owed is <strong>12.5</strong></p>
+<p>You earned <strong>4</strong> frequent renter points</p>
+```
+
+## 5. ポリシーベースの設計
+
+より柔軟な設計として、料金ポリシーを関数として表現できます。
+
+```scala
+case class PricingPolicy(
+  name: String,
+  calculateAmount: Days => Money,
+  calculatePoints: Days => Points
+)
+
+object PricingPolicies:
+  val regular: PricingPolicy = PricingPolicy(
+    "Regular",
+    days => if days > 2 then BigDecimal(2.0 + (days - 2) * 1.5) else BigDecimal(2.0),
+    _ => 1
+  )
+
+  val premium: PricingPolicy = PricingPolicy(
+    "Premium",
+    days => BigDecimal(days * 5.0),
+    days => days  // 日数分のポイント
+  )
+```
+
+## 6. レンタルショップ
+
+```scala
+class RentalShop:
+  private var movies: Map[String, Movie] = Map.empty
+  private var customers: Map[String, Customer] = Map.empty
+
+  def addMovie(movie: Movie): Unit = ...
+  def registerCustomer(name: String): Customer = ...
+  def rentMovie(customerName: String, movieTitle: String, days: Days): Option[Rental] = ...
+  def generateCustomerStatement(customerName: String, format: StatementFormat): Option[String] = ...
+```
+
+## 7. 割引計算
+
+```scala
+sealed trait Discount:
+  def apply(amount: Money): Money
+
+case class PercentageDiscount(percent: Double) extends Discount:
+  def apply(amount: Money): Money = amount * BigDecimal(1 - percent)
+
+case class FixedDiscount(value: Money) extends Discount:
+  def apply(amount: Money): Money = (amount - value) max BigDecimal(0)
+
+def applyDiscounts(amount: Money, discounts: Seq[Discount]): Money =
+  discounts.foldLeft(amount)((acc, d) => d.apply(acc))
+```
+
+## 8. 売上レポート
+
+```scala
+case class SalesReport(
+  period: String,
+  totalRentals: Int,
+  totalRevenue: Money,
+  rentalsByCategory: Map[MovieCategory, Int],
+  revenueByCategory: Map[MovieCategory, Money]
+)
+
+def generateSalesReport(rentals: Seq[Rental], period: String): SalesReport =
+  val rentalsByCategory = rentals.groupBy(_.movie.category).view.mapValues(_.size).toMap
+  val revenueByCategory = rentals.groupBy(_.movie.category).view.mapValues(rs => totalAmount(rs)).toMap
+  SalesReport(period, rentals.size, totalAmount(rentals), rentalsByCategory, revenueByCategory)
+```
+
+## 9. DSL
+
+```scala
+object RentalDSL:
+  def customer(name: String): CustomerBuilder = CustomerBuilder(name)
+
+  case class CustomerBuilder(name: String, rentals: List[Rental] = Nil):
+    def rents(movie: Movie, days: Days): CustomerBuilder =
+      copy(rentals = rentals :+ Rental(movie, days))
+    def build: Customer = Customer(name, rentals)
+    def statement: String = generateStatement(build)
+    def statementAs(format: StatementFormat): String = generateStatement(build, format)
+
+  def regular(title: String): Movie = Movie.regular(title)
+  def newRelease(title: String): Movie = Movie.newRelease(title)
+  def childrens(title: String): Movie = Movie.childrens(title)
+
+// 使用例
+import RentalDSL.*
+val statement = customer("John")
+  .rents(regular("Inception"), 3)
+  .rents(newRelease("New Movie"), 2)
+  .statement
+```
+
+## 10. Clojure との比較
+
+| 概念 | Clojure | Scala |
+|------|---------|-------|
+| 映画カテゴリ | キーワード (`:regular`) | enum |
+| 料金計算 | マルチメソッド | パターンマッチ / object |
+| 明細データ | マップ | case class |
+| フォーマッター | マルチメソッド | trait + object |
+
+## 11. リファクタリングのポイント
+
+### OOP vs FP
+
+**OOP アプローチ:**
+- `Movie` クラスに `getCharge()` メソッド
+- サブクラスでオーバーライド
+
+**FP アプローチ:**
+- 映画はデータのみ（case class）
+- 料金計算は別の関数/object
+- カテゴリに応じたディスパッチ
+
+### 利点
+
+1. **データと処理の分離**: テストが容易
+2. **拡張容易性**: 新しいカテゴリ追加が容易
+3. **オープン・クローズド原則**: 既存コード変更不要
+
+## まとめ
+
+本章では、レンタルビデオシステムを通じて以下を学びました：
+
+1. **パターンマッチ**: カテゴリによる料金計算のディスパッチ
+2. **データと処理の分離**: 映画データと計算ロジックの分離
+3. **フォーマッターパターン**: 複数の出力形式への対応
+4. **拡張性**: 新しいカテゴリやフォーマットの追加が容易
+5. **DSL**: 流暢な API による読みやすいコード
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/scala/part6/src/main/scala/VideoRentalSystem.scala`
+- テストコード: `apps/scala/part6/src/test/scala/VideoRentalSystemSpec.scala`