npm - @k2works/claude-code-booster - Versions diffs - 6.2.0 → 6.3.1 - Mend

@k2works/claude-code-booster 6.2.0 → 6.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (618) hide show

package/lib/assets/docs/article/functional-desgin-ppp/scala/01-immutability-and-data-transformation.md DELETED Viewed

@@ -1,337 +0,0 @@
----
-type: Article
-title: "第1章: 不変性とデータ変換"
-description: "関数型プログラミングの最も重要な概念の一つが不変性（Immutability）です。"
-tags: [article, functional-desgin-ppp, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-27T04:43:33Z }
----
-# 第1章: 不変性とデータ変換
-## はじめに
-関数型プログラミングの最も重要な概念の一つが**不変性（Immutability）**です。不変データ構造を使用することで、プログラムの予測可能性が向上し、並行処理でのバグを防ぎ、コードの理解と保守が容易になります。
-本章では、Scala における不変データ構造の基本から、データ変換パイプライン、副作用の分離まで、実践的な例を通じて学びます。
-## 1. 不変データ構造の基本
-### なぜ不変性が重要なのか
-従来の命令型プログラミングでは、変数やオブジェクトの状態を直接変更します：
-```java
-// Java（可変）
-person.setAge(31);  // 元のオブジェクトが変更される
-```
-これに対し、Scala の case class はデフォルトで不変です。データを「変更」すると、新しいデータ構造が作成されます：
-```scala
-case class Person(name: String, age: Int)
-def updateAge(person: Person, newAge: Int): Person =
-  person.copy(age = newAge)
-// 使用例
-val originalPerson = Person("田中", 30)
-val updatedPerson = updateAge(originalPerson, 31)
-originalPerson   // => Person("田中", 30)  ← 元のデータは変わらない
-updatedPerson    // => Person("田中", 31)  ← 新しいデータ
-```
-### 不変性の利点
-1. **予測可能性**: データが変更されないため、関数の動作を予測しやすい
-2. **スレッドセーフ**: 複数のスレッドから安全にアクセスできる
-3. **履歴の保持**: 変更前のデータを保持できる（Undo/Redo の実装が容易）
-4. **デバッグの容易さ**: データの変更履歴を追跡しやすい
-## 2. 構造共有（Structural Sharing）
-「毎回新しいデータ構造を作成すると非効率では？」と思うかもしれません。Scala の永続的データ構造は**構造共有**により、効率的にメモリを使用します。
-```scala
-case class Member(name: String, role: String)
-case class Team(name: String, members: List[Member])
-def addMember(team: Team, member: Member): Team =
-  team.copy(members = team.members :+ member)
-val team = Team("開発チーム", List(
-  Member("田中", "developer"),
-  Member("鈴木", "designer"),
-  Member("佐藤", "manager")
-))
-val newTeam = addMember(team, Member("山田", "developer"))
-```
-`newTeam` は新しい Team ですが、`name` の値や既存のメンバーデータは `team` と共有されています。変更されていない部分はコピーされず、参照が共有されます。
-```plantuml
-@startuml
-title 構造共有（Structural Sharing）
-object "team" as team {
-  name = "開発チーム"
-}
-object "newTeam" as newTeam {
-  name = "開発チーム"
-}
-object "List(田中, 鈴木, 佐藤)" as oldList
-object "山田" as newMember
-team --> oldList : members
-newTeam --> oldList : 共有
-newTeam --> newMember : 新規追加のみ
-note bottom of oldList
-  既存データは共有され
-  コピーされない
-end note
-@enduml
-```
-## 3. データ変換パイプライン
-関数型プログラミングでは、データを変換する一連の処理を**パイプライン**として表現します。Scala ではメソッドチェーンを使用して、読みやすいパイプラインを構築できます。
-### 実践例：注文処理システム
-```scala
-case class Item(name: String, price: Int, quantity: Int)
-case class Customer(name: String, membership: String)
-case class Order(items: List[Item], customer: Customer)
-// 各アイテムの小計を計算
-def calculateSubtotal(item: Item): Int =
-  item.price * item.quantity
-// 会員種別に応じた割引率を取得
-def membershipDiscount(membership: String): Double =
-  membership match
-    case "gold"   => 0.1
-    case "silver" => 0.05
-    case "bronze" => 0.02
-    case _        => 0.0
-// 注文の合計金額を計算
-def calculateTotal(order: Order): Int =
-  order.items.map(calculateSubtotal).sum
-// 割引後の金額を計算
-def applyDiscount(order: Order, total: Int): Double =
-  val discountRate = membershipDiscount(order.customer.membership)
-  total * (1 - discountRate)
-// 注文を処理し、割引後の合計金額を返す
-def processOrder(order: Order): Double =
-  val total = calculateTotal(order)
-  applyDiscount(order, total)
-```
-### Scala のパイプライン記法
-Scala では複数の方法でパイプラインを表現できます：
-```scala
-// メソッドチェーン
-order.items.map(calculateSubtotal).sum
-// パターンマッチングと組み合わせ
-order.customer.membership match
-  case "gold"   => 0.1
-  case "silver" => 0.05
-  case _        => 0.0
-// for 式（モナディックな合成）
-for
-  item <- order.items
-  subtotal = calculateSubtotal(item)
-yield subtotal
-```
-## 4. 副作用の分離
-関数型プログラミングでは、**純粋関数**と**副作用を持つ関数**を明確に分離することが重要です。
-### 純粋関数とは
-- 同じ入力に対して常に同じ出力を返す
-- 外部の状態を変更しない（副作用がない）
-```scala
-// 純粋関数
-def pureCalculateTax(amount: Int, taxRate: Double): Double =
-  amount * taxRate
-// 何度呼んでも同じ結果
-pureCalculateTax(1000, 0.1)  // => 100.0
-pureCalculateTax(1000, 0.1)  // => 100.0
-```
-### 副作用の分離パターン
-ビジネスロジック（純粋関数）と副作用（I/O）を分離します：
-```scala
-case class Invoice(subtotal: Int, tax: Double, total: Double)
-// ビジネスロジック（純粋関数）
-def calculateInvoice(items: List[Item], taxRate: Double): Invoice =
-  val subtotal = items.map(calculateSubtotal).sum
-  val tax = pureCalculateTax(subtotal, taxRate)
-  val total = subtotal + tax
-  Invoice(subtotal, tax, total)
-// 副作用を含む処理（分離）
-def saveInvoice(invoice: Invoice): Invoice =
-  // データベースへの保存（副作用）
-  println(s"Saving invoice: $invoice")
-  invoice
-def sendNotification(invoice: Invoice, customerEmail: String): Invoice =
-  // メール送信（副作用）
-  println(s"Sending notification to: $customerEmail")
-  invoice
-// 処理全体のオーケストレーション
-def processAndSaveInvoice(items: List[Item], taxRate: Double, customerEmail: String): Invoice =
-  val invoice = calculateInvoice(items, taxRate)
-  val saved = saveInvoice(invoice)
-  sendNotification(saved, customerEmail)
-```
-Scala では副作用を持つ関数に特別なサフィックスを付ける慣例はありませんが、コメントやドキュメントで明示することが推奨されます。また、Cats Effect や ZIO などの関数型エフェクトシステムを使用することで、副作用を型レベルで追跡することも可能です。
-## 5. 永続的データ構造の活用：Undo/Redo の実装
-不変データ構造を活用すると、履歴管理が非常に簡単に実装できます。
-```scala
-case class History[A](current: Option[A], past: List[A], future: List[A])
-// 履歴を保持するデータ構造を作成する
-def createHistory[A](): History[A] =
-  History(current = None, past = List.empty, future = List.empty)
-// 新しい状態を履歴にプッシュする
-def pushState[A](history: History[A], newState: A): History[A] =
-  History(
-    current = Some(newState),
-    past = history.current.toList ++ history.past,
-    future = List.empty
-  )
-// 直前の状態に戻す
-def undo[A](history: History[A]): History[A] =
-  history.past match
-    case Nil => history
-    case previous :: rest =>
-      History(
-        current = Some(previous),
-        past = rest,
-        future = history.current.toList ++ history.future
-      )
-// やり直し操作
-def redo[A](history: History[A]): History[A] =
-  history.future match
-    case Nil => history
-    case nextState :: rest =>
-      History(
-        current = Some(nextState),
-        past = history.current.toList ++ history.past,
-        future = rest
-      )
-```
-### 使用例
-```scala
-val history = pushState(
-  pushState(
-    pushState(createHistory[Map[String, String]](), Map("text" -> "Hello")),
-    Map("text" -> "Hello World")
-  ),
-  Map("text" -> "Hello World!")
-)
-history.current  // => Some(Map("text" -> "Hello World!"))
-val afterUndo = undo(history)
-afterUndo.current  // => Some(Map("text" -> "Hello World"))
-val afterRedo = redo(afterUndo)
-afterRedo.current  // => Some(Map("text" -> "Hello World!"))
-```
-## 6. Iterator による効率的な変換
-複数の変換を行う場合、通常は中間コレクションが作成されます。Scala では **Iterator** を使用すると、複数の変換を1回のパスで処理できます。
-```scala
-case class ProcessedItem(name: String, price: Int, quantity: Int, subtotal: Int)
-// 通常のコレクション処理（中間コレクションが作成される）
-def processItemsEfficiently(items: List[Item]): List[ProcessedItem] =
-  items
-    .filter(_.quantity > 0)
-    .map(item => ProcessedItem(item.name, item.price, item.quantity, calculateSubtotal(item)))
-    .filter(_.subtotal > 100)
-// Iterator を使用した効率的な処理（中間コレクションを作成しない）
-def processItemsWithIterator(items: List[Item]): List[ProcessedItem] =
-  items.iterator
-    .filter(_.quantity > 0)
-    .map(item => ProcessedItem(item.name, item.price, item.quantity, calculateSubtotal(item)))
-    .filter(_.subtotal > 100)
-    .toList
-```
-Iterator の利点：
-- 中間コレクションを作成しない
-- 遅延評価により必要な要素のみ処理
-- メモリ効率が良い
-### LazyList による遅延評価
-Scala 2.13 以降では LazyList を使用した遅延評価も可能です：
-```scala
-val lazyNumbers = LazyList.from(1)
-  .filter(_ % 2 == 0)
-  .take(10)
-  .toList  // => List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
-```
-## まとめ
-本章では、関数型プログラミングの基礎である不変性について学びました：
-1. **不変データ構造**: case class と copy メソッドによる不変性の実現
-2. **構造共有**: 効率的なメモリ使用を実現する永続的データ構造
-3. **データ変換パイプライン**: メソッドチェーンによる読みやすい変換処理
-4. **副作用の分離**: 純粋関数と I/O 処理の明確な分離
-5. **履歴管理**: 不変性を活用した Undo/Redo の簡潔な実装
-6. **Iterator**: 効率的な遅延評価による複合変換
-これらの概念は、関数型プログラミングの他のすべてのパターンの基盤となります。
-## 参考コード
-本章のコード例は以下のファイルで確認できます：
-- ソースコード: `apps/scala/part1/src/main/scala/Immutability.scala`
-- テストコード: `apps/scala/part1/src/test/scala/ImmutabilitySpec.scala`
-## 次章予告
-次章では、**関数合成と高階関数**について学びます。小さな関数を組み合わせて複雑な処理を構築する方法を探ります。

package/lib/assets/docs/article/functional-desgin-ppp/scala/02-function-composition.md DELETED Viewed

@@ -1,357 +0,0 @@
----
-type: Article
-title: "第2章: 関数合成と高階関数"
-description: "関数型プログラミングの真髄は、小さな関数を組み合わせて複雑な処理を構築することにあります。"
-tags: [article, functional-desgin-ppp, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第2章: 関数合成と高階関数
-## はじめに
-関数型プログラミングの真髄は、小さな関数を組み合わせて複雑な処理を構築することにあります。本章では、Scala における関数合成のテクニックと高階関数の活用方法を学びます。
-## 1. 関数合成の基本 (andThen, compose)
-### andThen と compose による関数の連結
-Scala では `andThen` と `compose` メソッドを使用して関数を合成できます。
-- **`andThen`**: 左から右へ順番に適用（直感的）
-- **`compose`**: 右から左へ順番に適用（数学的な関数合成）
-```scala
-def addTax(rate: Double)(amount: Double): Double =
-  amount * (1 + rate)
-def applyDiscountRate(rate: Double)(amount: Double): Double =
-  amount * (1 - rate)
-def roundToYen(amount: Double): Long =
-  Math.round(amount)
-// andThen による関数合成（左から右）
-val calculateFinalPrice: Double => Long =
-  applyDiscountRate(0.2) andThen addTax(0.1) andThen roundToYen
-// compose による関数合成（右から左）
-val calculateFinalPriceCompose: Double => Long =
-  (roundToYen _) compose addTax(0.1) compose applyDiscountRate(0.2)
-// 使用例
-calculateFinalPrice(1000)
-// => 880
-// 処理順序: 1000 → 20%割引(800) → 10%税込(880) → 丸め(880)
-```
-### 関数合成の利点
-1. **宣言的な記述**: 処理の流れを関数のチェーンとして表現
-2. **再利用性**: 合成した関数を別の場所で再利用可能
-3. **テスト容易性**: 各関数を個別にテスト可能
-## 2. カリー化と部分適用
-### カリー化による引数の固定
-Scala では関数をカリー化形式で定義することで、部分適用が自然に行えます。
-```scala
-// カリー化された関数
-def greetCurried(greeting: String)(name: String): String =
-  s"$greeting, $name!"
-val sayHello: String => String = greetCurried("Hello")
-val sayGoodbye: String => String = greetCurried("Goodbye")
-sayHello("田中")    // => "Hello, 田中!"
-sayGoodbye("鈴木")  // => "Goodbye, 鈴木!"
-```
-### 複数引数の部分適用
-```scala
-case class Email(from: String, to: String, subject: String, body: String)
-def sendEmail(from: String)(to: String)(subject: String)(body: String): Email =
-  Email(from, to, subject, body)
-val sendFromSystem = sendEmail("system@example.com")
-val sendNotification = sendFromSystem("user@example.com")("通知")
-sendNotification("メッセージ本文")
-// => Email(from = "system@example.com",
-//          to = "user@example.com",
-//          subject = "通知",
-//          body = "メッセージ本文")
-```
-## 3. 複数の関数を並列適用
-Clojure の `juxt` に相当する機能は、Scala ではタプルやケースクラスを使って表現します。
-```scala
-// 数値リストの統計情報を取得する
-def getStats(numbers: List[Int]): (Int, Int, Int, Int, Int) =
-  (numbers.head, numbers.last, numbers.length, numbers.min, numbers.max)
-getStats(List(3, 1, 4, 1, 5, 9, 2, 6))
-// => (3, 6, 8, 1, 9)
-// (最初の値, 最後の値, 要素数, 最小値, 最大値)
-```
-### 実用例：データ分析
-```scala
-case class PersonAnalysis(name: String, age: Int, category: String)
-def analyzePerson(person: Map[String, Any]): PersonAnalysis =
-  val name = person("name").asInstanceOf[String]
-  val age = person("age").asInstanceOf[Int]
-  val category = if age >= 18 then "adult" else "minor"
-  PersonAnalysis(name, age, category)
-analyzePerson(Map("name" -> "田中", "age" -> 25))
-// => PersonAnalysis("田中", 25, "adult")
-analyzePerson(Map("name" -> "鈴木", "age" -> 15))
-// => PersonAnalysis("鈴木", 15, "minor")
-```
-## 4. 高階関数によるデータ処理
-高階関数とは、関数を引数として受け取るか、関数を返す関数のことです。
-### ログ出力のラッパー
-```scala
-def processWithLogging[A, B](f: A => B): A => B =
-  (input: A) =>
-    println(s"入力: $input")
-    val result = f(input)
-    println(s"出力: $result")
-    result
-val doubleWithLog = processWithLogging[Int, Int](_ * 2)
-doubleWithLog(5)
-// 入力: 5
-// 出力: 10
-// => 10
-```
-### リトライ機能の追加
-```scala
-def retry[A, B](f: A => B, maxRetries: Int): A => B =
-  (input: A) =>
-    def attempt(attempts: Int): B =
-      try
-        f(input)
-      catch
-        case e: Exception =>
-          if attempts < maxRetries then attempt(attempts + 1)
-          else throw e
-    attempt(0)
-// 不安定なAPI呼び出しをリトライ付きでラップ
-val fetchWithRetry = retry(fetchData, 3)
-```
-### TTL 付きメモ化
-```scala
-def memoizeWithTtl[A, B](f: A => B, ttlMs: Long): A => B =
-  var cache: Map[A, (B, Long)] = Map.empty
-  (input: A) =>
-    val now = System.currentTimeMillis()
-    cache.get(input) match
-      case Some((value, time)) if now - time < ttlMs => value
-      case _ =>
-        val result = f(input)
-        cache = cache + (input -> (result, now))
-        result
-```
-## 5. パイプライン処理
-複数の関数を順次適用するパイプラインを構築します。
-```scala
-def pipeline[A](fns: (A => A)*): A => A =
-  (input: A) => fns.foldLeft(input)((acc, f) => f(acc))
-```
-### 注文処理パイプラインの実装
-```scala
-case class OrderItem(price: Int, quantity: Int)
-case class Customer(membership: String)
-case class Order(items: List[OrderItem], customer: Customer, total: Double = 0, shipping: Int = 0)
-def validateOrder(order: Order): Order =
-  if order.items.isEmpty then
-    throw new IllegalArgumentException("注文にアイテムがありません")
-  else
-    order
-def calculateOrderTotal(order: Order): Order =
-  val total = order.items.map(item => item.price * item.quantity).sum
-  order.copy(total = total)
-def applyOrderDiscount(order: Order): Order =
-  val discountRates = Map("gold" -> 0.1, "silver" -> 0.05, "bronze" -> 0.02)
-  val discountRate = discountRates.getOrElse(order.customer.membership, 0.0)
-  order.copy(total = order.total * (1 - discountRate))
-def addShipping(order: Order): Order =
-  val shipping = if order.total >= 5000 then 0 else 500
-  order.copy(shipping = shipping, total = order.total + shipping)
-val processOrderPipeline: Order => Order =
-  pipeline(validateOrder, calculateOrderTotal, applyOrderDiscount, addShipping)
-// 使用例
-processOrderPipeline(Order(
-  items = List(OrderItem(1000, 2), OrderItem(500, 3)),
-  customer = Customer("gold")
-))
-// => Order(items = [...], customer = Customer("gold"), total = 3650.0, shipping = 500)
-```
-## 6. 関数合成によるバリデーション
-バリデーションロジックを関数合成で表現します。
-```scala
-case class ValidationResult[A](valid: Boolean, value: A, error: Option[String] = None)
-def validator[A](pred: A => Boolean, errorMsg: String): A => ValidationResult[A] =
-  (value: A) =>
-    if pred(value) then ValidationResult(valid = true, value = value)
-    else ValidationResult(valid = false, value = value, error = Some(errorMsg))
-def combineValidators[A](validators: (A => ValidationResult[A])*): A => ValidationResult[A] =
-  (value: A) =>
-    validators.foldLeft(ValidationResult(valid = true, value = value)) { (result, v) =>
-      if result.valid then v(result.value)
-      else result
-    }
-// 個別のバリデータ
-val validatePositive = validator[Int](_ > 0, "値は正の数である必要があります")
-val validateUnder100 = validator[Int](_ < 100, "値は100未満である必要があります")
-// バリデータの合成
-def validateQuantity(value: Int): ValidationResult[Int] =
-  combineValidators(validatePositive, validateUnder100)(value)
-// 使用例
-validateQuantity(50)   // => ValidationResult(true, 50, None)
-validateQuantity(-1)   // => ValidationResult(false, -1, Some("値は正の数である必要があります"))
-validateQuantity(100)  // => ValidationResult(false, 100, Some("値は100未満である必要があります"))
-```
-## 7. 関数の変換
-関数自体を変換するユーティリティ関数を作成します。
-### 引数の順序を反転
-```scala
-def flip[A, B, C](f: (A, B) => C): (B, A) => C =
-  (b: B, a: A) => f(a, b)
-val subtract = (a: Int, b: Int) => a - b
-flip(subtract)(3, 5)  // => 2  (5 - 3)
-```
-### カリー化と非カリー化
-```scala
-def curry[A, B, C](f: (A, B) => C): A => B => C =
-  (a: A) => (b: B) => f(a, b)
-def uncurry[A, B, C](f: A => B => C): (A, B) => C =
-  (a: A, b: B) => f(a)(b)
-val add = (a: Int, b: Int) => a + b
-val curriedAdd = curry(add)
-val add5 = curriedAdd(5)
-add5(3)  // => 8
-```
-### 補関数（complement）
-```scala
-def complementFn[A](pred: A => Boolean): A => Boolean =
-  (a: A) => !pred(a)
-val isEven = (x: Int) => x % 2 == 0
-val isOdd = complementFn(isEven)
-isOdd(3)  // => true
-```
-## 8. 関数合成のパターン
-### 述語の合成
-```scala
-def composePredicates[A](preds: (A => Boolean)*): A => Boolean =
-  (x: A) => preds.forall(_(x))
-def composePredicatesOr[A](preds: (A => Boolean)*): A => Boolean =
-  (x: A) => preds.exists(_(x))
-// 有効な年齢チェック
-val validAge: Int => Boolean =
-  composePredicates[Int](
-    _ > 0,
-    _ <= 150
-  )
-validAge(25)   // => true
-validAge(-1)   // => false
-validAge(200)  // => false
-// プレミアム顧客チェック
-case class CustomerInfo(membership: String, purchaseCount: Int, totalSpent: Int)
-val premiumCustomer: CustomerInfo => Boolean =
-  composePredicatesOr[CustomerInfo](
-    _.membership == "gold",
-    _.purchaseCount >= 100,
-    _.totalSpent >= 100000
-  )
-premiumCustomer(CustomerInfo("gold", 0, 0))           // => true
-premiumCustomer(CustomerInfo("bronze", 100, 0))       // => true
-premiumCustomer(CustomerInfo("bronze", 10, 1000))     // => false
-```
-## まとめ
-本章では、関数合成と高階関数について学びました：
-1. **andThen/compose**: 関数を合成して新しい関数を作成
-2. **カリー化**: 引数を部分適用して特化した関数を作成
-3. **タプル/ケースクラス**: 複数の関数を並列適用して結果を取得
-4. **高階関数**: ログ、リトライ、メモ化などの横断的関心事を抽象化
-5. **パイプライン**: 処理の流れを関数のチェーンとして表現
-6. **バリデーション**: 関数合成による柔軟な検証ロジック
-7. **述語合成**: AND/OR で複数の条件を組み合わせ
-これらのテクニックにより、小さく再利用可能な関数から複雑なビジネスロジックを構築できます。
-## 参考コード
-本章のコード例は以下のファイルで確認できます：
-- ソースコード: `apps/scala/part1/src/main/scala/Composition.scala`
-- テストコード: `apps/scala/part1/src/test/scala/CompositionSpec.scala`
-## 次章予告
-次章では、**多態性とディスパッチ**について学びます。トレイト、型クラス、パターンマッチングを活用した柔軟な設計パターンを探ります。