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/07-composite-pattern.md DELETED Viewed

@@ -1,372 +0,0 @@
----
-type: Article
-title: "第7章: Composite パターン"
-description: "Composite パターンは、オブジェクトをツリー構造で構成し、個々のオブジェクトとオブジェクトの集合を同じように扱うことができるようにするパターンです。"
-tags: [article, functional-desgin-ppp, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第7章: Composite パターン
-## はじめに
-Composite パターンは、オブジェクトをツリー構造で構成し、個々のオブジェクトとオブジェクトの集合を同じように扱うことができるようにするパターンです。このパターンを使用すると、クライアントは個々のオブジェクトとその組み合わせを区別せずに操作できます。
-本章では、図形（Shape）、スイッチ（Switchable）、ファイルシステム、メニュー、数式など、様々な例を通じて Composite パターンの実装を学びます。
-## 1. パターンの構造
-Composite パターンは以下の要素で構成されます：
-- **Component**: 全てのオブジェクトの共通インターフェース
-- **Leaf**: 子要素を持たない末端オブジェクト
-- **Composite**: 子要素を持つコンテナオブジェクト
-```plantuml
-@startuml
-title Composite パターン構造
-interface "<<sealed trait>>\nComponent" as Component {
-  +operation(): Result
-}
-class "Leaf" as Leaf {
-  +operation(): Result
-}
-class "Composite" as Composite {
-  +children: List[Component]
-  +add(c: Component)
-  +remove(c: Component)
-  +operation(): Result
-}
-Component <|-- Leaf
-Component <|-- Composite
-Composite o-- Component : children
-@enduml
-```
-## 2. Shape の例 - 図形の Composite パターン
-### sealed trait による共通インターフェース
-```scala
-/** 2D座標 */
-case class Point(x: Double, y: Double):
-  def +(other: Point): Point = Point(x + other.x, y + other.y)
-  def *(factor: Double): Point = Point(x * factor, y * factor)
-/** 図形の共通インターフェース（sealed trait） */
-sealed trait Shape:
-  def translate(dx: Double, dy: Double): Shape
-  def scale(factor: Double): Shape
-  def area: Double
-  def boundingBox: BoundingBox
-```
-### Leaf の実装
-```scala
-/** 円（Leaf） */
-case class Circle(center: Point, radius: Double) extends Shape:
-  def translate(dx: Double, dy: Double): Circle =
-    copy(center = Point(center.x + dx, center.y + dy))
-  def scale(factor: Double): Circle =
-    copy(radius = radius * factor)
-  def area: Double = math.Pi * radius * radius
-  def boundingBox: BoundingBox =
-    BoundingBox(
-      Point(center.x - radius, center.y - radius),
-      Point(center.x + radius, center.y + radius)
-    )
-/** 正方形（Leaf） */
-case class Square(topLeft: Point, side: Double) extends Shape:
-  def translate(dx: Double, dy: Double): Square =
-    copy(topLeft = Point(topLeft.x + dx, topLeft.y + dy))
-  def scale(factor: Double): Square =
-    copy(side = side * factor)
-  def area: Double = side * side
-  def boundingBox: BoundingBox =
-    BoundingBox(topLeft, Point(topLeft.x + side, topLeft.y + side))
-```
-### Composite の実装
-```scala
-/** 複合図形（Composite） */
-case class CompositeShape(shapes: List[Shape] = Nil) extends Shape:
-  def add(shape: Shape): CompositeShape = copy(shapes = shapes :+ shape)
-  def remove(shape: Shape): CompositeShape = copy(shapes = shapes.filterNot(_ == shape))
-  def translate(dx: Double, dy: Double): CompositeShape =
-    copy(shapes = shapes.map(_.translate(dx, dy)))
-  def scale(factor: Double): CompositeShape =
-    copy(shapes = shapes.map(_.scale(factor)))
-  def area: Double = shapes.map(_.area).sum
-  def boundingBox: BoundingBox =
-    shapes match
-      case Nil => BoundingBox(Point(0, 0), Point(0, 0))
-      case head :: tail => tail.foldLeft(head.boundingBox)((acc, s) => acc.union(s.boundingBox))
-  def flatten: List[Shape] =
-    shapes.flatMap {
-      case cs: CompositeShape => cs.flatten
-      case s => List(s)
-    }
-```
-### 使用例
-```scala
-// 個々の図形を作成
-val circle = Circle(Point(10, 10), 5)
-val square = Square(Point(0, 0), 10)
-// 複合図形を作成
-val group = CompositeShape()
-  .add(circle)
-  .add(square)
-// 複合図形を移動（全ての子要素が移動する）
-val moved = group.translate(5, 5)
-// 複合図形を拡大（全ての子要素が拡大する）
-val scaled = group.scale(2)
-// 面積は全ての子要素の合計
-val totalArea = group.area
-```
-## 3. Switchable の例 - スイッチの Composite パターン
-```scala
-/** スイッチの共通インターフェース */
-sealed trait Switchable:
-  def turnOn: Switchable
-  def turnOff: Switchable
-  def isOn: Boolean
-/** 照明（Leaf） */
-case class Light(on: Boolean = false, name: String = "Light") extends Switchable:
-  def turnOn: Light = copy(on = true)
-  def turnOff: Light = copy(on = false)
-  def isOn: Boolean = on
-/** 調光可能な照明（Leaf） */
-case class DimmableLight(intensity: Int = 0, name: String = "DimmableLight") extends Switchable:
-  def turnOn: DimmableLight = copy(intensity = 100)
-  def turnOff: DimmableLight = copy(intensity = 0)
-  def isOn: Boolean = intensity > 0
-  def setIntensity(value: Int): DimmableLight =
-    copy(intensity = math.max(0, math.min(100, value)))
-/** 複合スイッチ（Composite） */
-case class CompositeSwitchable(
-  switchables: List[Switchable] = Nil,
-  name: String = "Group"
-) extends Switchable:
-  def add(switchable: Switchable): CompositeSwitchable =
-    copy(switchables = switchables :+ switchable)
-  def turnOn: CompositeSwitchable =
-    copy(switchables = switchables.map(_.turnOn))
-  def turnOff: CompositeSwitchable =
-    copy(switchables = switchables.map(_.turnOff))
-  def isOn: Boolean = switchables.exists(_.isOn)
-  def allOn: Boolean = switchables.nonEmpty && switchables.forall(_.isOn)
-```
-### 使用例
-```scala
-val bedroom = CompositeSwitchable(name = "Bedroom")
-  .add(Light(name = "Ceiling"))
-  .add(DimmableLight(name = "Bedside"))
-val livingRoom = CompositeSwitchable(name = "LivingRoom")
-  .add(Light(name = "Main"))
-  .add(Fan(name = "Ceiling Fan"))
-val house = CompositeSwitchable(name = "House")
-  .add(bedroom)
-  .add(livingRoom)
-// 家中の全てのスイッチをオン
-val allOn = house.turnOn
-```
-## 4. FileSystem の例
-```scala
-/** ファイルシステムエントリの共通インターフェース */
-sealed trait FileSystemEntry:
-  def name: String
-  def size: Long
-  def path: String
-  def find(predicate: FileSystemEntry => Boolean): List[FileSystemEntry]
-/** ファイル（Leaf） */
-case class File(name: String, size: Long, parentPath: String = "") extends FileSystemEntry:
-  def path: String = if parentPath.isEmpty then name else s"$parentPath/$name"
-  def find(predicate: FileSystemEntry => Boolean): List[FileSystemEntry] =
-    if predicate(this) then List(this) else Nil
-/** ディレクトリ（Composite） */
-case class Directory(
-  name: String,
-  children: List[FileSystemEntry] = Nil,
-  parentPath: String = ""
-) extends FileSystemEntry:
-  def add(entry: FileSystemEntry): Directory = ...
-  def size: Long = children.map(_.size).sum
-  def fileCount: Int = ...
-  def directoryCount: Int = ...
-```
-## 5. Expression の例 - 数式の Composite パターン
-```scala
-/** 数式の共通インターフェース */
-sealed trait Expression:
-  def evaluate: Double
-  def simplify: Expression
-  def variables: Set[String]
-/** 数値（Leaf） */
-case class Number(value: Double) extends Expression:
-  def evaluate: Double = value
-  def simplify: Expression = this
-  def variables: Set[String] = Set.empty
-/** 変数（Leaf） */
-case class Variable(name: String, value: Option[Double] = None) extends Expression:
-  def evaluate: Double = value.getOrElse(
-    throw new IllegalStateException(s"Variable $name has no value")
-  )
-  def simplify: Expression = value.map(Number(_)).getOrElse(this)
-  def variables: Set[String] = if value.isEmpty then Set(name) else Set.empty
-/** 加算（Composite） */
-case class Add(left: Expression, right: Expression) extends Expression:
-  def evaluate: Double = left.evaluate + right.evaluate
-  def simplify: Expression =
-    (left.simplify, right.simplify) match
-      case (Number(0), r) => r
-      case (l, Number(0)) => l
-      case (Number(a), Number(b)) => Number(a + b)
-      case (l, r) => Add(l, r)
-  def variables: Set[String] = left.variables ++ right.variables
-```
-### 使用例
-```scala
-// (2 + 3) * 4 = 20
-val expr = Multiply(Add(Number(2), Number(3)), Number(4))
-expr.evaluate // 20.0
-// 変数を含む式
-val exprWithVars = Add(Variable("x"), Variable("y"))
-val bound = Expression.bind(exprWithVars, Map("x" -> 10.0, "y" -> 20.0))
-bound.evaluate // 30.0
-// 式の簡略化
-Add(Variable("x"), Number(0)).simplify // Variable("x")
-Multiply(Variable("x"), Number(1)).simplify // Variable("x")
-```
-## 6. パターンの利点
-1. **統一的な操作**: 個々のオブジェクトとグループを同じインターフェースで操作可能
-2. **階層構造**: ネストした構造を自然に表現可能
-3. **拡張性**: 新しい Leaf や Composite を追加しやすい
-4. **再帰的な構造**: Composite は他の Composite を含むことも可能
-## 7. Scala での特徴
-### sealed trait による網羅性チェック
-```scala
-sealed trait Shape
-case class Circle(...) extends Shape
-case class Square(...) extends Shape
-case class CompositeShape(...) extends Shape
-// パターンマッチで全ケースをカバーしないと警告
-def process(shape: Shape): Unit = shape match
-  case Circle(...) => ...
-  case Square(...) => ...
-  // CompositeShape を忘れると警告
-```
-### case class による不変性
-```scala
-// 全ての操作が新しいオブジェクトを返す（元のオブジェクトは変更されない）
-val original = CompositeShape().add(Circle(Point(0, 0), 5))
-val moved = original.translate(10, 10)
-// original は変更されていない
-original.shapes(0).asInstanceOf[Circle].center // Point(0, 0)
-moved.shapes(0).asInstanceOf[Circle].center    // Point(10, 10)
-```
-### copy メソッドによる簡潔な更新
-```scala
-case class Circle(center: Point, radius: Double):
-  def translate(dx: Double, dy: Double): Circle =
-    copy(center = Point(center.x + dx, center.y + dy))
-```
-## Clojure との比較
-| 概念 | Clojure | Scala |
-|------|---------|-------|
-| インターフェース | マルチメソッド | sealed trait |
-| Leaf | defmethod | case class extends trait |
-| Composite | defmethod + mapv | case class extends trait |
-| データ構造 | マップ | case class |
-| 操作の委譲 | mapv | shapes.map(...) |
-| 不変性 | デフォルト | case class + copy |
-## まとめ
-本章では、Composite パターンについて学びました：
-1. **Shape の例**: 図形の移動と拡大を統一的に操作
-2. **Switchable の例**: 複数のスイッチをグループ化して操作
-3. **FileSystem の例**: ファイルとディレクトリの階層構造
-4. **Menu の例**: 単品とセットメニューの価格計算
-5. **Expression の例**: 数式の評価と簡略化
-Composite パターンは、ツリー構造のデータを扱う際に非常に有効なパターンです。Scala の sealed trait と case class を使うことで、型安全で不変なツリー構造を簡潔に実装できます。
-## 参考コード
-本章のコード例は以下のファイルで確認できます：
-- ソースコード: `apps/scala/part3/src/main/scala/CompositePattern.scala`
-- テストコード: `apps/scala/part3/src/test/scala/CompositePatternSpec.scala`
-## 次章予告
-次章では、**Decorator パターン**について学びます。既存の機能に新しい機能を動的に追加する方法を探ります。

package/lib/assets/docs/article/functional-desgin-ppp/scala/08-decorator-pattern.md DELETED Viewed

@@ -1,336 +0,0 @@
----
-type: Article
-title: "第8章: Decorator パターン"
-description: "Decorator パターンは、既存のオブジェクトに新しい機能を動的に追加するパターンです。"
-tags: [article, functional-desgin-ppp, scala]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第8章: Decorator パターン
-## はじめに
-Decorator パターンは、既存のオブジェクトに新しい機能を動的に追加するパターンです。このパターンを使用すると、サブクラス化による継承よりも柔軟な方法で機能を拡張できます。
-関数型プログラミングでは、高階関数を使って関数をラップし、横断的関心事（ログ、キャッシュ、認証など）を追加します。本章では、形状のジャーナリングと関数デコレータについて学びます。
-## 1. パターンの構造
-```plantuml
-@startuml
-title Decorator パターン構造
-interface "Component" as Component {
-  +operation(): Result
-}
-class "ConcreteComponent" as Concrete {
-  +operation(): Result
-}
-class "Decorator" as Decorator {
-  +wrapped: Component
-  +operation(): Result
-}
-Component <|-- Concrete
-Component <|-- Decorator
-Decorator o--> Component : delegates to
-@enduml
-```
-## 2. JournaledShape - 形状デコレータ
-### 基本形状の定義
-```scala
-trait Shape:
-  def translate(dx: Double, dy: Double): Shape
-  def scale(factor: Double): Shape
-  def area: Double
-case class Circle(centerX: Double, centerY: Double, radius: Double) extends Shape:
-  def translate(dx: Double, dy: Double): Circle =
-    copy(centerX = centerX + dx, centerY = centerY + dy)
-  def scale(factor: Double): Circle = copy(radius = radius * factor)
-  def area: Double = math.Pi * radius * radius
-```
-### ジャーナル付き形状（デコレータ）
-```scala
-enum JournalEntry:
-  case Translate(dx: Double, dy: Double)
-  case Scale(factor: Double)
-  case Rotate(angle: Double)
-case class JournaledShape(
-  shape: Shape,
-  journal: List[JournalEntry] = Nil
-) extends Shape:
-  def translate(dx: Double, dy: Double): JournaledShape =
-    copy(
-      shape = shape.translate(dx, dy),
-      journal = journal :+ JournalEntry.Translate(dx, dy)
-    )
-  def scale(factor: Double): JournaledShape =
-    copy(
-      shape = shape.scale(factor),
-      journal = journal :+ JournalEntry.Scale(factor)
-    )
-  def area: Double = shape.area
-  def clearJournal: JournaledShape = copy(journal = Nil)
-  def replay(entries: List[JournalEntry]): JournaledShape =
-    entries.foldLeft(this) { (js, entry) =>
-      entry match
-        case JournalEntry.Translate(dx, dy) => js.translate(dx, dy)
-        case JournalEntry.Scale(factor) => js.scale(factor)
-        case JournalEntry.Rotate(_) => js
-    }
-```
-### 使用例
-```scala
-val circle = Circle(0, 0, 5)
-val journaled = JournaledShape(circle)
-  .translate(2, 3)
-  .scale(5)
-journaled.journal // List(Translate(2, 3), Scale(5))
-journaled.shape   // Circle(2, 3, 25)
-```
-## 3. 関数デコレータ
-関数型プログラミングでは、高階関数を使って関数をデコレートします。
-### ログデコレータ
-```scala
-def withLogging[A, B](f: A => B, name: String)(implicit log: LogCollector): A => B =
-  (a: A) =>
-    log.add(s"[$name] called with: $a")
-    val result = f(a)
-    log.add(s"[$name] returned: $result")
-    result
-// 使用例
-implicit val log = new LogCollector
-val add: Int => Int = _ + 10
-val logged = withLogging(add, "add")
-logged(5) // 15 (ログも記録される)
-```
-### リトライデコレータ
-```scala
-def withRetry[A, B](f: A => B, maxRetries: Int, delay: Long = 0): A => B =
-  (a: A) =>
-    def attempt(remaining: Int): B =
-      Try(f(a)) match
-        case Success(result) => result
-        case Failure(e) if remaining > 0 =>
-          if delay > 0 then Thread.sleep(delay)
-          attempt(remaining - 1)
-        case Failure(e) => throw e
-    attempt(maxRetries)
-// 使用例
-val unreliableFn = withRetry(callExternalService, maxRetries = 3)
-```
-### キャッシュデコレータ
-```scala
-def withCache[A, B](f: A => B): A => B =
-  val cache = mutable.Map.empty[A, B]
-  (a: A) => cache.getOrElseUpdate(a, f(a))
-// TTL付きキャッシュ
-def withTTLCache[A, B](f: A => B, ttlMs: Long): A => B =
-  val cache = mutable.Map.empty[A, (B, Long)]
-  (a: A) =>
-    val now = System.currentTimeMillis()
-    cache.get(a) match
-      case Some((value, timestamp)) if now - timestamp < ttlMs => value
-      case _ =>
-        val result = f(a)
-        cache(a) = (result, now)
-        result
-```
-### バリデーションデコレータ
-```scala
-def withValidation[A, B](f: A => B)(validator: A => Boolean, errorMsg: String): A => B =
-  (a: A) =>
-    if validator(a) then f(a)
-    else throw new IllegalArgumentException(s"$errorMsg: $a")
-// 使用例
-val positiveOnly = withValidation[Int, Int](_ * 2)(_ > 0, "Must be positive")
-positiveOnly(5)   // 10
-positiveOnly(-5)  // Exception!
-```
-### エラーハンドリングデコレータ
-```scala
-// Option に変換
-def withOptionResult[A, B](f: A => B): A => Option[B] =
-  (a: A) => Try(f(a)).toOption
-// Either に変換
-def withEitherResult[A, B](f: A => B): A => Either[Throwable, B] =
-  (a: A) => Try(f(a)).toEither
-// デフォルト値を返す
-def withDefault[A, B](f: A => B, default: B): A => B =
-  (a: A) => Try(f(a)).getOrElse(default)
-```
-## 4. デコレータの合成
-```scala
-object DecoratorComposition:
-  def compose[A, B](f: A => B, decorators: List[(A => B) => (A => B)]): A => B =
-    decorators.foldLeft(f) { (decorated, decorator) =>
-      decorator(decorated)
-    }
-// 使用例
-val fn: Int => Int = _ * 2
-val decorators: List[(Int => Int) => (Int => Int)] = List(
-  f => withCache(f),
-  f => withLogging(f, "fn")
-)
-val composed = DecoratorComposition.compose(fn, decorators)
-```
-## 5. AuditedList - コレクションデコレータ
-```scala
-case class AuditedList[A](
-  items: List[A],
-  operations: List[String] = Nil
-):
-  def add(item: A): AuditedList[A] =
-    copy(items = items :+ item, operations = operations :+ s"add($item)")
-  def remove(item: A): AuditedList[A] =
-    copy(items = items.filterNot(_ == item), operations = operations :+ s"remove($item)")
-  def map[B](f: A => B): AuditedList[B] =
-    AuditedList(items.map(f), operations :+ "map")
-  def filter(p: A => Boolean): AuditedList[A] =
-    copy(items = items.filter(p), operations :+ "filter")
-// 使用例
-val list = AuditedList.empty[Int].add(1).add(2).add(3)
-list.operations // List("add(1)", "add(2)", "add(3)")
-```
-## 6. HTTPクライアントデコレータ
-```scala
-trait HttpClient:
-  def get(url: String): HttpResponse
-class SimpleHttpClient extends HttpClient:
-  def get(url: String): HttpResponse = HttpResponse(200, s"Response from $url")
-// ログ付きクライアント
-class LoggingHttpClient(client: HttpClient)(implicit log: LogCollector) extends HttpClient:
-  def get(url: String): HttpResponse =
-    log.add(s"[HTTP] GET $url")
-    val response = client.get(url)
-    log.add(s"[HTTP] Response: ${response.status}")
-    response
-// キャッシュ付きクライアント
-class CachingHttpClient(client: HttpClient) extends HttpClient:
-  private val cache = mutable.Map.empty[String, HttpResponse]
-  def get(url: String): HttpResponse = cache.getOrElseUpdate(url, client.get(url))
-// デコレータの組み合わせ
-val client = new LoggingHttpClient(
-  new CachingHttpClient(
-    new SimpleHttpClient
-  )
-)
-```
-## 7. FunctionBuilder - ビルダースタイル
-```scala
-class FunctionBuilder[A, B](f: A => B):
-  private var current: A => B = f
-  def withLogging(name: String)(implicit log: LogCollector): FunctionBuilder[A, B] =
-    current = FunctionDecorators.withLogging(current, name)
-    this
-  def withCache(): FunctionBuilder[A, B] =
-    current = FunctionDecorators.withCache(current)
-    this
-  def withValidation(validator: A => Boolean, errorMsg: String): FunctionBuilder[A, B] =
-    current = FunctionDecorators.withValidation(current)(validator, errorMsg)
-    this
-  def build: A => B = current
-// 使用例
-val fn = FunctionBuilder[Int, Int](_ * 2)
-  .withLogging("double")
-  .withCache()
-  .withValidation(_ > 0, "Must be positive")
-  .build
-```
-## 8. パターンの利点
-1. **単一責任の原則**: 各デコレータは一つの機能のみを追加
-2. **開放/閉鎖の原則**: 既存コードを変更せずに機能を追加
-3. **柔軟な組み合わせ**: 必要な機能だけを選択して組み合わせ可能
-4. **実行時の決定**: どのデコレータを適用するか実行時に決定可能
-## Clojure との比較
-| 概念 | Clojure | Scala |
-|------|---------|-------|
-| 高階関数 | `(defn with-logging [f] ...)` | `def withLogging[A,B](f: A => B): A => B` |
-| クロージャ | `(let [cache (atom {})] ...)` | `val cache = mutable.Map.empty` |
-| 合成 | `(comp decorator1 decorator2)` | `compose(f, decorators)` |
-| 状態 | `atom` | `var` or mutable collection |
-## まとめ
-本章では、Decorator パターンについて学びました：
-1. **JournaledShape**: 形状操作の履歴を記録するデコレータ
-2. **関数デコレータ**: ログ、リトライ、キャッシュなどの横断的関心事
-3. **AuditedList**: 操作履歴付きコレクション
-4. **HTTPクライアント**: クラスベースのデコレータ
-5. **FunctionBuilder**: ビルダースタイルのデコレータ適用
-Decorator パターンは、既存のコードを変更せずに機能を拡張する強力なパターンです。
-## 参考コード
-本章のコード例は以下のファイルで確認できます：
-- ソースコード: `apps/scala/part3/src/main/scala/DecoratorPattern.scala`
-- テストコード: `apps/scala/part3/src/test/scala/DecoratorPatternSpec.scala`
-## 次章予告
-次章では、**Adapter パターン**について学びます。異なるインターフェース間の変換とレガシーシステムとの統合を探ります。