@k2works/claude-code-booster 4.9.0 → 4.11.0

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

@@ -1,675 +1,675 @@
-# 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` を使った安全なプログラミング手法を紹介します。
+# 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` を使った安全なプログラミング手法を紹介します。