@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokkingfp/rust/part-6.md

@@ -0,0 +1,508 @@
+# Rust で学ぶ関数型プログラミング Part VI: 実践的アプリケーション構築
+
+## はじめに
+
+Part V では並行処理（Arc、Mutex、チャネル）を学びました。Part VI では、これまで学んだ FP の概念を総動員して**実践的なアプリケーション**を構築します。
+
+Scala では trait による抽象化、Resource によるリソース管理、そしてテスト戦略を学びますが、Rust でも同様のパターンを async-trait、RAII パターン、proptest を使って実現します。
+
+## 第12章: 実践的なアプリケーション構築
+
+### 12.1 ドメインモデルの定義
+
+実際のアプリケーション開発では、ドメインモデルを適切に定義することが重要です。TravelGuide アプリケーションを例に見ていきます。
+
+```rust
+/// Newtype パターンで型安全な ID を定義
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct LocationId(pub String);
+
+impl LocationId {
+    pub fn new(id: &str) -> Self {
+        Self(id.to_string())
+    }
+}
+
+/// ロケーション
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Location {
+    pub id: LocationId,
+    pub name: String,
+    pub population: i32,
+}
+
+/// アトラクション（観光地）
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Attraction {
+    pub name: String,
+    pub description: Option<String>,
+    pub location: Location,
+}
+
+/// 旅行ガイド - 最終的な出力モデル
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TravelGuide {
+    pub attraction: Attraction,
+    pub subjects: Vec<String>,       // 関連するアーティストや映画
+    pub search_report: SearchReport, // 検索メタデータ
+}
+```
+
+Scala と比較すると：
+
+| Scala | Rust |
+|-------|------|
+| `case class LocationId(value: String)` | `struct LocationId(pub String)` |
+| `Option[String]` | `Option<String>` |
+| `List[String]` | `Vec<String>` |
+
+### 12.2 DataAccess トレイト - 依存性の抽象化
+
+外部データソースへのアクセスをトレイトで抽象化します。これにより、テスト時にスタブ実装に差し替えることができます。
+
+```rust
+use async_trait::async_trait;
+
+/// データアクセス層のトレイト
+#[async_trait]
+pub trait DataAccess: Send + Sync {
+    /// アトラクションを検索
+    async fn find_attractions(
+        &self,
+        name: &str,
+        ordering: AttractionOrdering,
+        limit: usize,
+    ) -> Vec<Attraction>;
+
+    /// ロケーションからアーティストを検索
+    async fn find_artists_from_location(
+        &self,
+        location_id: &LocationId,
+        limit: usize,
+    ) -> Result<Vec<MusicArtist>, String>;
+
+    /// ロケーションに関する映画を検索
+    async fn find_movies_about_location(
+        &self,
+        location_id: &LocationId,
+        limit: usize,
+    ) -> Result<Vec<Movie>, String>;
+}
+```
+
+Scala の trait と比較：
+
+| Scala | Rust |
+|-------|------|
+| `trait DataAccess[F[_]]` | `#[async_trait] trait DataAccess` |
+| `def findAttractions(...): F[List[Attraction]]` | `async fn find_attractions(...) -> Vec<Attraction>` |
+| `F[Either[String, List[A]]]` | `Result<Vec<A>, String>` |
+
+### 12.3 テスト用スタブ実装
+
+Builder パターンを使って柔軟にテストデータを設定できるスタブ実装を作成します。
+
+```rust
+pub struct StubDataAccess {
+    attractions: Vec<Attraction>,
+    artists: HashMap<LocationId, Vec<MusicArtist>>,
+    movies: HashMap<LocationId, Vec<Movie>>,
+    artists_error: Option<String>,
+    movies_error: Option<String>,
+}
+
+impl StubDataAccess {
+    pub fn new() -> Self {
+        Self {
+            attractions: vec![],
+            artists: HashMap::new(),
+            movies: HashMap::new(),
+            artists_error: None,
+            movies_error: None,
+        }
+    }
+
+    // Builder パターンでメソッドチェーン
+    pub fn with_attractions(mut self, attractions: Vec<Attraction>) -> Self {
+        self.attractions = attractions;
+        self
+    }
+
+    pub fn with_artists(mut self, location_id: LocationId, artists: Vec<MusicArtist>) -> Self {
+        self.artists.insert(location_id, artists);
+        self
+    }
+
+    pub fn with_artists_error(mut self, error: &str) -> Self {
+        self.artists_error = Some(error.to_string());
+        self
+    }
+}
+```
+
+使用例：
+
+```rust
+#[tokio::test]
+async fn test_travel_guide_with_error() {
+    let data = Arc::new(
+        StubDataAccess::new()
+            .with_attractions(vec![create_test_attraction()])
+            .with_artists_error("Artist service unavailable")
+    );
+
+    let guide = travel_guide(data.as_ref(), "Test").await;
+
+    assert!(guide.is_some());
+    assert!(!guide.unwrap().search_report.errors.is_empty());
+}
+```
+
+### 12.4 キャッシュ付き DataAccess
+
+デコレーターパターンを使って、既存の DataAccess にキャッシュ機能を追加します。
+
+```rust
+pub struct CachedDataAccess<D: DataAccess> {
+    inner: Arc<D>,
+    attractions_cache: Arc<RwLock<HashMap<String, Vec<Attraction>>>>,
+}
+
+impl<D: DataAccess> CachedDataAccess<D> {
+    pub fn new(inner: Arc<D>) -> Self {
+        Self {
+            inner,
+            attractions_cache: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    fn cache_key(name: &str, ordering: AttractionOrdering, limit: usize) -> String {
+        format!("{}-{:?}-{}", name, ordering, limit)
+    }
+}
+
+#[async_trait]
+impl<D: DataAccess + 'static> DataAccess for CachedDataAccess<D> {
+    async fn find_attractions(
+        &self,
+        name: &str,
+        ordering: AttractionOrdering,
+        limit: usize,
+    ) -> Vec<Attraction> {
+        let key = Self::cache_key(name, ordering, limit);
+
+        // キャッシュを確認（読み取りロック）
+        {
+            let cache = self.attractions_cache.read().await;
+            if let Some(cached) = cache.get(&key) {
+                return cached.clone();
+            }
+        }
+
+        // キャッシュにない場合は取得
+        let result = self.inner.find_attractions(name, ordering, limit).await;
+
+        // キャッシュに保存（書き込みロック）
+        {
+            let mut cache = self.attractions_cache.write().await;
+            cache.insert(key, result.clone());
+        }
+
+        result
+    }
+
+    // 他のメソッドは inner に委譲
+}
+```
+
+### 12.5 TravelGuide アプリケーション
+
+トレイトを使った依存性注入により、ビジネスロジックをテスト可能な形で実装します。
+
+```rust
+/// 旅行ガイドを生成
+pub async fn travel_guide(
+    data: &dyn DataAccess,
+    attraction_name: &str,
+) -> Option<TravelGuide> {
+    // アトラクションを検索
+    let attractions = data
+        .find_attractions(attraction_name, AttractionOrdering::ByLocationPopulation, 1)
+        .await;
+
+    let attraction = attractions.into_iter().next()?;
+
+    // 関連情報を並行して取得
+    let artists_result = data
+        .find_artists_from_location(&attraction.location.id, 2)
+        .await;
+    let movies_result = data
+        .find_movies_about_location(&attraction.location.id, 2)
+        .await;
+
+    // エラーを収集（失敗しても継続）
+    let mut errors = Vec::new();
+    if let Err(e) = &artists_result {
+        errors.push(e.clone());
+    }
+    if let Err(e) = &movies_result {
+        errors.push(e.clone());
+    }
+
+    // 成功した結果を結合
+    let artists = artists_result.unwrap_or_default();
+    let movies = movies_result.unwrap_or_default();
+
+    let subjects: Vec<String> = artists
+        .into_iter()
+        .map(|a| a.name)
+        .chain(movies.into_iter().map(|m| m.name))
+        .collect();
+
+    Some(TravelGuide::new(
+        attraction,
+        subjects,
+        SearchReport::new(1, errors),
+    ))
+}
+```
+
+### 12.6 純粋関数ユーティリティ
+
+副作用のない純粋関数は、単体テストが容易で再利用性が高いです。
+
+```rust
+/// 人口でロケーションをフィルタリング
+pub fn filter_popular_locations(locations: Vec<Location>, min_population: i32) -> Vec<Location> {
+    locations
+        .into_iter()
+        .filter(|loc| loc.population >= min_population)
+        .collect()
+}
+
+/// 人口順でソート
+pub fn sort_by_population(mut locations: Vec<Location>) -> Vec<Location> {
+    locations.sort_by(|a, b| b.population.cmp(&a.population));
+    locations
+}
+
+/// 複数のサブジェクトを結合
+pub fn combine_subjects(subjects_list: Vec<Vec<String>>) -> Vec<String> {
+    subjects_list.into_iter().flatten().collect()
+}
+
+/// 複数の SearchReport を集約
+pub fn aggregate_reports(reports: Vec<SearchReport>) -> SearchReport {
+    let total_searched = reports.iter().map(|r| r.attractions_searched).sum();
+    let all_errors: Vec<String> = reports.into_iter().flat_map(|r| r.errors).collect();
+    SearchReport::new(total_searched, all_errors)
+}
+```
+
+### 12.7 リソース管理パターン
+
+Scala の Resource に相当する概念を Rust で実装します。
+
+```rust
+/// リソース管理のトレイト
+pub trait Resource {
+    type Item;
+
+    fn use_resource<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&Self::Item) -> R;
+}
+
+/// ファイルリソース
+pub struct FileResource {
+    path: String,
+}
+
+impl Resource for FileResource {
+    type Item = Result<String, std::io::Error>;
+
+    fn use_resource<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&Self::Item) -> R,
+    {
+        let content = std::fs::read_to_string(&self.path);
+        f(&content)
+    }
+}
+```
+
+Rust の強みは、RAII（Resource Acquisition Is Initialization）パターンにより、リソースの解放が自動的に行われることです。
+
+### 12.8 バリデーション
+
+独自のバリデーション型を定義して、型安全なバリデーションを実装します。
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Validation<T> {
+    Valid(T),
+    Invalid(Vec<String>),
+}
+
+impl<T> Validation<T> {
+    pub fn valid(value: T) -> Self {
+        Validation::Valid(value)
+    }
+
+    pub fn invalid(errors: Vec<String>) -> Self {
+        Validation::Invalid(errors)
+    }
+
+    pub fn is_valid(&self) -> bool {
+        matches!(self, Validation::Valid(_))
+    }
+
+    pub fn map<U, F>(self, f: F) -> Validation<U>
+    where
+        F: FnOnce(T) -> U,
+    {
+        match self {
+            Validation::Valid(v) => Validation::Valid(f(v)),
+            Validation::Invalid(e) => Validation::Invalid(e),
+        }
+    }
+
+    pub fn and_then<U, F>(self, f: F) -> Validation<U>
+    where
+        F: FnOnce(T) -> Validation<U>,
+    {
+        match self {
+            Validation::Valid(v) => f(v),
+            Validation::Invalid(e) => Validation::Invalid(e),
+        }
+    }
+}
+
+/// Location のバリデーション
+pub fn validate_location(location: Location) -> Validation<Location> {
+    let mut errors = Vec::new();
+
+    if location.name.trim().is_empty() {
+        errors.push("Name cannot be empty".to_string());
+    }
+    if location.population < 0 {
+        errors.push("Population cannot be negative".to_string());
+    }
+
+    if errors.is_empty() {
+        Validation::valid(location)
+    } else {
+        Validation::invalid(errors)
+    }
+}
+```
+
+### 12.9 プロパティベーステスト
+
+proptest を使って、ランダムな入力に対する不変条件をテストします。
+
+```rust
+use proptest::prelude::*;
+
+proptest! {
+    /// ソートは要素を保持する
+    #[test]
+    fn sort_by_population_preserves_elements(
+        populations in prop::collection::vec(0i32..10_000_000, 0..10)
+    ) {
+        let locations: Vec<Location> = populations
+            .iter()
+            .enumerate()
+            .map(|(i, &pop)| Location::new(
+                LocationId::new(&format!("loc{}", i)),
+                &format!("City{}", i),
+                pop,
+            ))
+            .collect();
+
+        let sorted = sort_by_population(locations.clone());
+
+        prop_assert_eq!(sorted.len(), locations.len());
+    }
+
+    /// ソート結果は降順
+    #[test]
+    fn sort_by_population_is_sorted(
+        populations in prop::collection::vec(0i32..10_000_000, 0..10)
+    ) {
+        let locations: Vec<Location> = populations
+            .iter()
+            .enumerate()
+            .map(|(i, &pop)| Location::new(
+                LocationId::new(&format!("loc{}", i)),
+                &format!("City{}", i),
+                pop,
+            ))
+            .collect();
+
+        let sorted = sort_by_population(locations);
+
+        for window in sorted.windows(2) {
+            prop_assert!(window[0].population >= window[1].population);
+        }
+    }
+
+    /// 空の名前は無効
+    #[test]
+    fn validate_location_empty_name_is_invalid(
+        population in 0i32..10_000_000
+    ) {
+        let location = Location::new(LocationId::new("test"), "", population);
+        let result = validate_location(location);
+        prop_assert!(!result.is_valid());
+    }
+
+    /// 負の人口は無効
+    #[test]
+    fn validate_location_negative_population_is_invalid(
+        name in "[a-zA-Z]+",
+        population in i32::MIN..-1i32
+    ) {
+        let location = Location::new(LocationId::new("test"), &name, population);
+        let result = validate_location(location);
+        prop_assert!(!result.is_valid());
+    }
+}
+```
+
+Scala の ScalaCheck と比較：
+
+| ScalaCheck | proptest |
+|------------|----------|
+| `forAll { (n: Int) => ... }` | `proptest! { fn test(n in any::<i32>()) { ... } }` |
+| `Gen.choose(0, 100)` | `0i32..100` |
+| `Gen.listOfN(10, gen)` | `prop::collection::vec(gen, 0..10)` |
+| `Prop.passed` | `prop_assert!(true)` |
+
+## まとめ
+
+Part VI で学んだ重要なポイント：
+
+1. **ドメインモデル**: Newtype パターンで型安全性を確保
+2. **トレイト抽象化**: `async_trait` で非同期メソッドを持つトレイトを定義
+3. **依存性注入**: トレイトオブジェクト (`&dyn DataAccess`) で実装を差し替え可能に
+4. **デコレーターパターン**: キャッシュなどの横断的関心事を分離
+5. **純粋関数**: テスタブルで再利用可能なユーティリティ
+6. **バリデーション**: 独自型でエラーを収集
+7. **プロパティベーステスト**: ランダム入力で不変条件を検証
+
+Scala と Rust の対応表：
+
+| 概念 | Scala | Rust |
+|------|-------|------|
+| 非同期トレイト | `trait DataAccess[F[_]]` | `#[async_trait] trait DataAccess` |
+| テストスタブ | `Stub extends DataAccess` | `impl DataAccess for StubDataAccess` |
+| リソース管理 | `Resource[IO, A]` | `trait Resource` / RAII |
+| バリデーション | `Validated[E, A]` | `enum Validation<T>` |
+| プロパティテスト | ScalaCheck | proptest |
+
+## 参考リンク
+
+- [async-trait crate](https://docs.rs/async-trait/)
+- [proptest crate](https://docs.rs/proptest/)
+- [Rust Design Patterns](https://rust-unofficial.github.io/patterns/)

package/lib/assets/docs/article/grokkingfp/scala/index.md

@@ -0,0 +1,171 @@
+# Grokking Functional Programming 日本語解説
+
+本シリーズは「Grokking Functional Programming」（Michał Płachta 著）の学習コンパニオンとして、関数型プログラミングの概念を日本語で解説します。
+
+---
+
+## 対象読者
+
+- Java や OOP の経験があり、関数型プログラミングに興味がある開発者
+- Scala を学びたいが、FP の概念から理解したい方
+- 実践的な FP の適用方法を知りたいエンジニア
+
+---
+
+## 記事一覧
+
+### [Part I: 関数型プログラミングの基礎](part-1.md)
+
+関数型プログラミングの基本概念を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第1章 | 命令型 vs 関数型、Scala 基本構文 |
+| 第2章 | 純粋関数、副作用の排除、テストの容易さ |
+
+**キーワード**: 純粋関数、参照透過性、副作用
+
+---
+
+### [Part II: 関数型スタイルのプログラミング](part-2.md)
+
+イミュータブルなデータ操作と高階関数を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第3章 | イミュータブルデータ、List 操作 |
+| 第4章 | 高階関数、map/filter/foldLeft |
+| 第5章 | flatMap、for 内包表記 |
+
+**キーワード**: イミュータブル、高階関数、flatMap、for 内包表記
+
+---
+
+### [Part III: エラーハンドリングと Option/Either](part-3.md)
+
+型安全なエラーハンドリングを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第6章 | Option 型、Some/None |
+| 第7章 | Either 型、ADT、パターンマッチング |
+
+**キーワード**: Option、Either、代数的データ型（ADT）
+
+---
+
+### [Part IV: IO と副作用の管理](part-4.md)
+
+IO モナドとストリーム処理を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第8章 | IO モナド、cats-effect |
+| 第9章 | fs2 Stream、無限ストリーム |
+
+**キーワード**: IO モナド、遅延評価、ストリーム処理
+
+---
+
+### [Part V: 並行処理](part-5.md)
+
+関数型プログラミングにおける並行処理を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第10章 | Ref、Fiber、parSequence |
+
+**キーワード**: 並行処理、Ref、Fiber、軽量スレッド
+
+---
+
+### [Part VI: 実践的なアプリケーション構築とテスト](part-6.md)
+
+実践的なアプリケーション構築とテスト戦略を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第11章 | TravelGuide アプリ、Resource、キャッシュ |
+| 第12章 | テスト戦略、プロパティベーステスト |
+
+**キーワード**: Resource、DataAccess 抽象化、ScalaCheck
+
+---
+
+## 学習パス
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "学習の流れ" {
+  card "Part I\n基礎" as p1
+  card "Part II\nイミュータブル操作" as p2
+  card "Part III\n型による安全性" as p3
+  card "Part IV\nIO/Stream" as p4
+  card "Part V\n並行処理" as p5
+  card "Part VI\n実践" as p6
+}
+
+p1 --> p2
+p2 --> p3
+p3 --> p4
+p4 --> p5
+p5 --> p6
+
+@enduml
+```
+
+---
+
+## 使用ライブラリ
+
+| ライブラリ | 用途 | 対応章 |
+|------------|------|--------|
+| Scala 3 | 言語 | 全章 |
+| cats-effect | IO モナド | Part IV-VI |
+| fs2 | ストリーム処理 | Part IV-V |
+| ScalaCheck | プロパティベーステスト | Part VI |
+
+---
+
+## リポジトリ構成
+
+```
+grokkingfp-examples/
+├── app/scala/src/main/scala/    # Scala のサンプルコード
+├── app/java/src/main/java/      # Java の比較用コード
+├── src/test/scala/              # テストコード
+├── docs/journal/                # 開発履歴
+└── docs/article/                # 解説記事（本ディレクトリ）
+    ├── index.md                 # この記事
+    ├── outline.md               # アウトライン
+    ├── part-1.md                # Part I
+    ├── part-2.md                # Part II
+    ├── part-3.md                # Part III
+    ├── part-4.md                # Part IV
+    ├── part-5.md                # Part V
+    └── part-6.md                # Part VI
+```
+
+---
+
+## 関数型プログラミングの利点
+
+本シリーズを通じて、以下の利点を実感できます:
+
+1. **予測可能性** - 純粋関数は同じ入力に対して常に同じ出力
+2. **テスト容易性** - 副作用がないためテストが簡単
+3. **合成可能性** - 小さな関数を組み合わせて複雑な処理を構築
+4. **並行安全性** - イミュータブルデータは競合状態を防ぐ
+5. **型安全性** - Option、Either で null や例外を型で表現
+
+---
+
+## 参考資料
+
+- [Grokking Functional Programming](https://www.manning.com/books/grokking-functional-programming) - 原著
+- [Scala 公式ドキュメント](https://docs.scala-lang.org/)
+- [cats-effect ドキュメント](https://typelevel.org/cats-effect/)
+- [fs2 ドキュメント](https://fs2.io/)