@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokkingfp/java/part-2.md

@@ -0,0 +1,667 @@
+# Part II: 関数型スタイルのプログラミング
+
+本章では、関数型プログラミングの核心となるテクニックを学びます。イミュータブルなデータ操作、高階関数、そして `flatMap` による複雑なデータ変換を Vavr を使って習得します。
+
+---
+
+## 第3章: イミュータブルなデータ操作
+
+### 3.1 イミュータブルとは
+
+イミュータブル（不変）とは、一度作成されたデータが変更されないことを意味します。データを「変更」する代わりに、新しいデータを「作成」します。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "ミュータブル（可変）" as mut {
+  card "list = [A, B]" as m1
+  card "list.add(C)" as m2
+  card "list = [A, B, C]" as m3
+  m1 --> m2 : 変更
+  m2 --> m3 : 同じリストが変わる
+}
+
+rectangle "イミュータブル（不変）" as immut {
+  card "list1 = [A, B]" as i1
+  card "list2 = list1.append(C)" as i2
+  card "list1 = [A, B]\nlist2 = [A, B, C]" as i3
+  i1 --> i2 : 新規作成
+  i2 --> i3 : 両方が存在
+}
+
+@enduml
+```
+
+### 3.2 Vavr List の基本操作
+
+**ソースファイル**: `app/java/src/main/java/ch03/ImmutableList.java`
+
+#### append - 要素の追加
+
+```java
+List<String> appleBook = List.of("Apple", "Book");
+List<String> appleBookMango = appleBook.append("Mango");
+
+assert appleBook.size() == 2;       // 元のリストは変わらない
+assert appleBookMango.size() == 3;  // 新しいリストが作成される
+assert appleBookMango.equals(List.of("Apple", "Book", "Mango"));
+```
+
+#### take / drop - リストの切り出し
+
+```java
+public static List<String> firstTwo(List<String> list) {
+    return list.take(2);
+}
+
+public static List<String> lastTwo(List<String> list) {
+    return list.takeRight(2);
+}
+
+public static <T> List<T> slice(List<T> list, int start, int end) {
+    return list.drop(start).take(end - start);
+}
+
+// 使用例
+List<String> fruits = List.of("a", "b", "c", "d");
+assert firstTwo(fruits).equals(List.of("a", "b"));
+assert lastTwo(fruits).equals(List.of("c", "d"));
+assert slice(fruits, 1, 3).equals(List.of("b", "c"));
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "take / drop の動作" {
+  card "List(\"a\", \"b\", \"c\", \"d\")" as orig
+  card "drop(1).take(2)" as op
+  card "List(\"b\", \"c\")" as result
+
+  orig --> op
+  op --> result
+}
+
+note bottom of result
+  drop(1) で最初の1つを除去
+  take(2) で先頭から2つを取得
+end note
+
+@enduml
+```
+
+### 3.3 リストの変換例
+
+**ソースファイル**: `app/java/src/main/java/ch03/ImmutableList.java`
+
+```java
+// 最初の2要素を末尾に移動
+public static List<String> movedFirstTwoToTheEnd(List<String> list) {
+    List<String> firstTwo = list.take(2);
+    List<String> withoutFirstTwo = list.drop(2);
+    return withoutFirstTwo.appendAll(firstTwo);
+}
+
+assert movedFirstTwoToTheEnd(List.of("a", "b", "c")).equals(List.of("c", "a", "b"));
+
+// 最後の要素の前に挿入
+public static List<String> insertedBeforeLast(List<String> list, String element) {
+    List<String> withoutLast = list.dropRight(1);
+    List<String> last = list.takeRight(1);
+    return withoutLast.append(element).appendAll(last);
+}
+
+assert insertedBeforeLast(List.of("a", "b"), "c").equals(List.of("a", "c", "b"));
+```
+
+### 3.4 旅程の再計画
+
+**ソースファイル**: `app/java/src/main/java/ch03/Itinerary.java`
+
+旅行の計画変更をイミュータブルに行う例です。
+
+```java
+public static List<String> replan(List<String> plan, String newCity, String beforeCity) {
+    int beforeCityIndex = plan.indexOf(beforeCity);
+    List<String> citiesBefore = plan.take(beforeCityIndex);
+    List<String> citiesAfter = plan.drop(beforeCityIndex);
+    return citiesBefore.append(newCity).appendAll(citiesAfter);
+}
+
+List<String> planA = List.of("Paris", "Berlin", "Kraków");
+List<String> planB = replan(planA, "Vienna", "Kraków");
+
+assert planB.equals(List.of("Paris", "Berlin", "Vienna", "Kraków"));
+assert planA.equals(List.of("Paris", "Berlin", "Kraków"));  // 元の計画は変わらない!
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "旅程の再計画" {
+  card "Plan A:\nParis → Berlin → Kraków" as planA
+  card "replan(planA, \"Vienna\", \"Kraków\")" as op
+  card "Plan B:\nParis → Berlin → Vienna → Kraków" as planB
+
+  planA --> op
+  op --> planB
+}
+
+note right of planA
+  Plan A は変更されない
+  (イミュータブル)
+end note
+
+@enduml
+```
+
+---
+
+## 第4章: 関数を値として扱う
+
+### 4.1 高階関数とは
+
+高階関数（Higher-Order Function）とは、以下のいずれかを満たす関数です:
+
+1. 関数を引数として受け取る
+2. 関数を戻り値として返す
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "高階関数" {
+  rectangle "関数を引数に取る" as arg {
+    card "sortBy(keyExtractor)" as sortBy
+    card "map(transform)" as map
+    card "filter(predicate)" as filter
+  }
+
+  rectangle "関数を返す" as ret {
+    card "largerThan(n)" as larger
+    card "divisibleBy(n)" as divisible
+  }
+}
+
+@enduml
+```
+
+### 4.2 関数を引数として渡す
+
+**ソースファイル**: `app/java/src/main/java/ch04/HigherOrderFunctions.java`
+
+#### sortBy - ソート基準を関数で指定
+
+```java
+public static int score(String word) {
+    return word.replaceAll("a", "").length();
+}
+
+List<String> words = List.of("rust", "java");
+List<String> sortedWords = words.sortBy(HigherOrderFunctions::score);
+
+assert sortedWords.equals(List.of("java", "rust"));
+// java: 2文字 (j, v), rust: 4文字 (r, u, s, t)
+```
+
+#### map - 各要素を変換
+
+```java
+public static int len(String s) {
+    return s.length();
+}
+
+List<Integer> lengths = List.of("scala", "rust", "ada").map(HigherOrderFunctions::len);
+assert lengths.equals(List.of(5, 4, 3));
+
+public static int doubleValue(int i) {
+    return 2 * i;
+}
+
+List<Integer> doubles = List.of(5, 1, 2, 4, 0).map(HigherOrderFunctions::doubleValue);
+assert doubles.equals(List.of(10, 2, 4, 8, 0));
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "map の動作" {
+  card "[\"scala\", \"rust\", \"ada\"]" as input
+  card "len関数を各要素に適用" as op
+  card "[5, 4, 3]" as output
+
+  input --> op
+  op --> output
+}
+
+@enduml
+```
+
+#### filter - 条件に合う要素を抽出
+
+```java
+public static boolean isOdd(int i) {
+    return i % 2 == 1;
+}
+
+List<Integer> odds = List.of(5, 1, 2, 4, 0).filter(HigherOrderFunctions::isOdd);
+assert odds.equals(List.of(5, 1));
+
+public static boolean isLargerThan4(int i) {
+    return i > 4;
+}
+
+List<Integer> large = List.of(5, 1, 2, 4, 0).filter(HigherOrderFunctions::isLargerThan4);
+assert large.equals(List.of(5));
+```
+
+#### foldLeft - 畳み込み
+
+```java
+List<Integer> numbers = List.of(5, 1, 2, 4, 100);
+int sum = numbers.foldLeft(0, (acc, i) -> acc + i);
+assert sum == 112;
+
+int max = List.of(5, 1, 2, 4, 15).foldLeft(Integer.MIN_VALUE, (m, i) -> i > m ? i : m);
+assert max == 15;
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "foldLeft の動作" {
+  card "初期値: 0" as init
+  card "0 + 5 = 5" as s1
+  card "5 + 1 = 6" as s2
+  card "6 + 2 = 8" as s3
+  card "8 + 4 = 12" as s4
+  card "12 + 100 = 112" as s5
+
+  init --> s1
+  s1 --> s2
+  s2 --> s3
+  s3 --> s4
+  s4 --> s5
+}
+
+@enduml
+```
+
+### 4.3 record とメソッド参照
+
+**ソースファイル**: `app/java/src/main/java/ch04/ProgrammingLanguage.java`
+
+Java の record を使ったイミュータブルなデータクラスの例です。
+
+```java
+public record ProgrammingLanguage(String name, int year) {}
+
+ProgrammingLanguage java = new ProgrammingLanguage("Java", 1995);
+ProgrammingLanguage scala = new ProgrammingLanguage("Scala", 2004);
+
+List<ProgrammingLanguage> languages = List.of(java, scala);
+
+// フィールドにアクセス
+List<String> names = languages.map(ProgrammingLanguage::name);
+assert names.equals(List.of("Java", "Scala"));
+
+// 条件でフィルタ
+List<ProgrammingLanguage> young = languages.filter(lang -> lang.year() > 2000);
+assert young.equals(List.of(scala));
+```
+
+### 4.4 関数を返す関数
+
+**ソースファイル**: `app/java/src/main/java/ch04/HigherOrderFunctions.java`
+
+```java
+public static Predicate<Integer> largerThan(int n) {
+    return i -> i > n;
+}
+
+List<Integer> large = List.of(5, 1, 2, 4, 0).filter(largerThan(4));
+assert large.equals(List.of(5));
+
+List<Integer> medium = List.of(5, 1, 2, 4, 0).filter(largerThan(1));
+assert medium.equals(List.of(5, 2, 4));
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "関数を返す関数" {
+  card "largerThan(4)" as call
+  card "i -> i > 4" as fn
+  card "filter に渡す" as filter
+
+  call --> fn : 関数を生成
+  fn --> filter : 生成された関数を使用
+}
+
+note bottom
+  largerThan(4) は
+  「4より大きいか判定する関数」を返す
+end note
+
+@enduml
+```
+
+### 4.5 ワードスコアリングの例
+
+**ソースファイル**: `app/java/src/main/java/ch04/WordScoring.java`
+
+複数のスコアリングロジックを組み合わせる例です。
+
+```java
+public static int score(String word) {
+    return word.replaceAll("a", "").length();
+}
+
+public static int bonus(String word) {
+    return word.contains("c") ? 5 : 0;
+}
+
+public static int penalty(String word) {
+    return word.contains("s") ? 7 : 0;
+}
+
+List<String> words = List.of("ada", "haskell", "scala", "java", "rust");
+
+// 関数を引数として渡す
+public static List<String> rankedWords(Function<String, Integer> wordScore, List<String> words) {
+    return words.sortBy(wordScore).reverse();
+}
+
+// 基本スコアでランキング
+List<String> ranking1 = rankedWords(WordScoring::score, words);
+assert ranking1.equals(List.of("haskell", "rust", "scala", "java", "ada"));
+
+// ボーナス付きスコアでランキング
+List<String> ranking2 = rankedWords(w -> score(w) + bonus(w), words);
+assert ranking2.equals(List.of("scala", "haskell", "rust", "java", "ada"));
+
+// ボーナスとペナルティ付きスコアでランキング
+List<String> ranking3 = rankedWords(w -> score(w) + bonus(w) - penalty(w), words);
+// java が1位
+```
+
+---
+
+## 第5章: flatMap とネスト構造
+
+### 5.1 flatten と flatMap
+
+**ソースファイル**: `app/java/src/main/java/ch05/FlatMapExamples.java`
+
+#### flatten - ネストしたリストを平坦化
+
+```java
+List<List<Integer>> nested = List.of(
+    List.of(1, 2),
+    List.of(3, 4, 5),
+    List.of(6)
+);
+
+// flatMap で平坦化
+List<Integer> flat = nested.flatMap(x -> x);
+// List(1, 2, 3, 4, 5, 6)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "flatten の動作" {
+  card "[[1, 2], [3, 4, 5], [6]]" as nested
+  card "flatMap(x -> x)" as op
+  card "[1, 2, 3, 4, 5, 6]" as flat
+
+  nested --> op
+  op --> flat
+}
+
+@enduml
+```
+
+#### flatMap = map + flatten
+
+```java
+// 書籍と映画化の例
+public record Book(String title, List<String> authors) {}
+
+List<Book> books = List.of(
+    new Book("FP in Scala", List.of("Chiusano", "Bjarnason")),
+    new Book("The Hobbit", List.of("Tolkien"))
+);
+
+// map だけだとネストする
+List<List<String>> authorLists = books.map(Book::authors);
+// List(List("Chiusano", "Bjarnason"), List("Tolkien"))
+
+// flatMap で平坦化
+List<String> authors = books.flatMap(Book::authors);
+// List("Chiusano", "Bjarnason", "Tolkien")
+```
+
+### 5.2 flatMap によるリストサイズの変化
+
+```java
+// 要素数が増える
+List.of(1, 2, 3).flatMap(i -> List.of(i, i + 10));
+// List(1, 11, 2, 12, 3, 13) - 6要素
+
+// 要素数が同じ
+List.of(1, 2, 3).flatMap(i -> List.of(i * 2));
+// List(2, 4, 6) - 3要素
+
+// 要素数が減る（フィルタリング効果）
+List.of(1, 2, 3).flatMap(i -> i % 2 == 0 ? List.of(i) : List.empty());
+// List(2) - 1要素
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "flatMap とサイズの変化" {
+  rectangle "増加" as inc {
+    card "[1, 2, 3]" as i1
+    card "i -> [i, i+10]" as f1
+    card "[1, 11, 2, 12, 3, 13]" as r1
+    i1 --> f1
+    f1 --> r1
+  }
+
+  rectangle "減少（フィルタ）" as dec {
+    card "[1, 2, 3]" as i2
+    card "i -> if even [i] else []" as f2
+    card "[2]" as r2
+    i2 --> f2
+    f2 --> r2
+  }
+}
+
+@enduml
+```
+
+### 5.3 ネストした flatMap
+
+**ソースファイル**: `app/java/src/main/java/ch05/BookAdaptations.java`
+
+複数のリストを組み合わせる場合、flatMap をネストします。
+
+```java
+public record Book(String title, List<String> authors) {}
+public record Movie(String title) {}
+
+public static List<Movie> bookAdaptations(String author) {
+    if ("Tolkien".equals(author)) {
+        return List.of(
+            new Movie("An Unexpected Journey"),
+            new Movie("The Desolation of Smaug")
+        );
+    }
+    return List.empty();
+}
+
+List<Book> books = List.of(
+    new Book("FP in Scala", List.of("Chiusano", "Bjarnason")),
+    new Book("The Hobbit", List.of("Tolkien"))
+);
+
+// ネストした flatMap
+List<String> recommendations = books.flatMap(book ->
+    book.authors().flatMap(author ->
+        bookAdaptations(author).map(movie ->
+            String.format("You may like %s, because you liked %s's %s",
+                movie.title(), author, book.title())
+        )
+    )
+);
+
+// 結果:
+// List(
+//   "You may like An Unexpected Journey, because you liked Tolkien's The Hobbit",
+//   "You may like The Desolation of Smaug, because you liked Tolkien's The Hobbit"
+// )
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "ネストした flatMap のフロー" {
+  card "books" as books
+  card "book.authors()" as authors
+  card "bookAdaptations(author)" as movies
+  card "recommendation string" as result
+
+  books --> authors : flatMap
+  authors --> movies : flatMap
+  movies --> result : map
+}
+
+note bottom
+  最後だけ map
+  途中は flatMap
+end note
+
+@enduml
+```
+
+### 5.4 Java での for 内包表記の代替
+
+Scala の for 内包表記に相当する機能は、Java では flatMap のチェーンで表現します。
+
+```java
+// flatMap/map 版
+List<String> c1 = books.flatMap(book ->
+    book.authors().flatMap(author ->
+        bookAdaptations(author).map(movie ->
+            String.format("You may like %s, because you liked %s's %s",
+                movie.title(), author, book.title())
+        )
+    )
+);
+
+// Vavr の Iterator を使った版（同等）
+List<String> c2 = Iterator.ofAll(books)
+    .flatMap(book -> Iterator.ofAll(book.authors())
+        .flatMap(author -> Iterator.ofAll(bookAdaptations(author))
+            .map(movie -> String.format(
+                "You may like %s, because you liked %s's %s",
+                movie.title(), author, book.title()))))
+    .toList();
+```
+
+### 5.5 円内の点の判定
+
+**ソースファイル**: `app/java/src/main/java/ch05/PointsInsideCircles.java`
+
+flatMap を使った組み合わせ生成とフィルタリングの例です。
+
+```java
+public record Point(int x, int y) {}
+
+List<Point> points = List.of(new Point(5, 2), new Point(1, 1));
+List<Integer> radiuses = List.of(2, 1);
+
+public static boolean isInside(Point point, int radius) {
+    return radius * radius >= point.x() * point.x() + point.y() * point.y();
+}
+
+// 全組み合わせを生成
+List<String> allCombinations = radiuses.flatMap(r ->
+    points.map(point ->
+        String.format("%s is within radius %d: %s", point, r, isInside(point, r))
+    )
+);
+
+// 結果:
+// List(
+//   "(5, 2) is within radius 2: false",
+//   "(1, 1) is within radius 2: true",
+//   "(5, 2) is within radius 1: false",
+//   "(1, 1) is within radius 1: false"
+// )
+```
+
+#### ガード式相当のフィルタリング
+
+```java
+// 円内の点のみを取得（ガード式相当）
+List<String> inside = radiuses.flatMap(r ->
+    points.filter(point -> isInside(point, r))
+        .map(point -> String.format("%s is inside circle with radius %d", point, r))
+);
+```
+
+---
+
+## まとめ
+
+### 学んだこと
+
+1. **イミュータブルなデータ操作**
+   - Vavr の `List` は不変
+   - `take`, `drop`, `append`, `appendAll` で新しいリストを作成
+   - 元のデータは変更されない
+
+2. **高階関数**
+   - `map`: 各要素を変換
+   - `filter`: 条件に合う要素を抽出
+   - `foldLeft`: 畳み込み
+   - `sortBy`: ソート基準を関数で指定
+
+3. **関数を返す関数**
+   - `Predicate<T>` を返すことで再利用可能なフィルタを作成
+   - 部分適用のような効果を得られる
+
+4. **flatMap**
+   - ネストしたリストを平坦化
+   - `map` + `flatten` の組み合わせ
+   - リストサイズが増減する変換に対応
+
+### Scala との対応
+
+| Scala | Java + Vavr |
+|-------|-------------|
+| `List` | `io.vavr.collection.List` |
+| `slice(a, b)` | `drop(a).take(b - a)` |
+| `appended` | `append` |
+| `appendedAll` | `appendAll` |
+| `sortBy` | `sortBy` |
+| `map` | `map` |
+| `filter` | `filter` |
+| `foldLeft` | `foldLeft` |
+| `flatMap` | `flatMap` |
+| `for {...} yield` | `flatMap` のチェーン |
+
+### 次のパート
+
+Part III では、エラーハンドリングについて学びます。`Option` と `Either` を使った安全なプログラミング手法を紹介します。