@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/grokkingfp/scala/part-3.md

@@ -0,0 +1,917 @@
+# Part III: エラーハンドリングと Option/Either
+
+本章では、関数型プログラミングにおける安全なエラーハンドリングを学びます。`null` や例外に頼らず、`Option` と `Either` を使って型安全にエラーを扱う方法を習得します。
+
+---
+
+## 第6章: Option 型による安全なエラーハンドリング
+
+### 6.1 なぜ Option が必要か
+
+従来のエラーハンドリングには問題があります。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "従来のエラーハンドリング" {
+  rectangle "null を返す" as null_ret {
+    card "NullPointerException の危険"
+    card "コンパイル時に検出できない"
+  }
+
+  rectangle "例外をスローする" as exception {
+    card "制御フローが複雑化"
+    card "純粋関数ではなくなる"
+  }
+}
+
+rectangle "Option による解決" as option {
+  card "型で「値がないかもしれない」を表現"
+  card "コンパイル時にチェック"
+  card "純粋関数のまま"
+}
+
+null_ret --> option : 置き換え
+exception --> option : 置き換え
+
+@enduml
+```
+
+### 6.2 Option の基本
+
+`Option[A]` は「`A` 型の値があるか、ないか」を表す型です。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Option[A]" as option {
+  rectangle "Some(value)" as some {
+    card "値が存在する"
+    card "value: A を保持"
+  }
+
+  rectangle "None" as none {
+    card "値が存在しない"
+    card "null の代わり"
+  }
+}
+
+@enduml
+```
+
+**ソースファイル**: `app/scala/src/main/scala/ch06_TvShows.scala`
+
+### 6.3 TV番組のパース例
+
+TV番組の文字列をパースする例で Option の使い方を学びます。
+
+```scala
+case class TvShow(title: String, start: Int, end: Int)
+
+// 入力例: "Breaking Bad (2008-2013)"
+// 期待する出力: TvShow("Breaking Bad", 2008, 2013)
+```
+
+#### 例外を使う方法（問題あり）
+
+```scala
+def parseShow(rawShow: String): TvShow = {
+  val bracketOpen  = rawShow.indexOf('(')
+  val bracketClose = rawShow.indexOf(')')
+  val dash         = rawShow.indexOf('-')
+
+  val name      = rawShow.substring(0, bracketOpen).trim
+  val yearStart = rawShow.substring(bracketOpen + 1, dash).toInt
+  val yearEnd   = rawShow.substring(dash + 1, bracketClose).toInt
+
+  TvShow(name, yearStart, yearEnd)
+}
+
+// 正常ケース
+parseShow("Breaking Bad (2008-2013)")  // TvShow("Breaking Bad", 2008, 2013)
+
+// 異常ケース → 例外がスローされる!
+parseShow("Chernobyl (2019)")           // StringIndexOutOfBoundsException
+parseShow("The Wire 2002-2008")         // StringIndexOutOfBoundsException
+```
+
+#### Option を使う方法
+
+```scala
+def parseShow(rawShow: String): Option[TvShow] = {
+  for {
+    name      <- extractName(rawShow)
+    yearStart <- extractYearStart(rawShow)
+    yearEnd   <- extractYearEnd(rawShow)
+  } yield TvShow(name, yearStart, yearEnd)
+}
+
+// 正常ケース
+parseShow("Breaking Bad (2008-2013)")  // Some(TvShow("Breaking Bad", 2008, 2013))
+
+// 異常ケース → None が返される（例外なし）
+parseShow("The Wire 2002-2008")         // None
+```
+
+### 6.4 小さな関数から組み立てる
+
+複雑なパース処理を小さな関数に分解します。
+
+```scala
+// 名前を抽出
+def extractName(rawShow: String): Option[String] = {
+  val bracketOpen = rawShow.indexOf('(')
+  if (bracketOpen > 0) Some(rawShow.substring(0, bracketOpen).trim)
+  else None
+}
+
+// 開始年を抽出
+def extractYearStart(rawShow: String): Option[Int] = {
+  val bracketOpen = rawShow.indexOf('(')
+  val dash        = rawShow.indexOf('-')
+  for {
+    yearStr <- if (bracketOpen != -1 && dash > bracketOpen + 1)
+                 Some(rawShow.substring(bracketOpen + 1, dash))
+               else None
+    year    <- yearStr.toIntOption
+  } yield year
+}
+
+// 終了年を抽出
+def extractYearEnd(rawShow: String): Option[Int] = {
+  val dash         = rawShow.indexOf('-')
+  val bracketClose = rawShow.indexOf(')')
+  for {
+    yearStr <- if (dash != -1 && bracketClose > dash + 1)
+                 Some(rawShow.substring(dash + 1, bracketClose))
+               else None
+    year    <- yearStr.toIntOption
+  } yield year
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "パース処理の分解" {
+  card "\"Breaking Bad (2008-2013)\"" as input
+
+  rectangle "小さな関数" as funcs {
+    card "extractName" as name
+    card "extractYearStart" as start
+    card "extractYearEnd" as end
+  }
+
+  card "TvShow" as output
+
+  input --> funcs
+  funcs --> output : for 内包表記で合成
+}
+
+@enduml
+```
+
+### 6.5 orElse によるフォールバック
+
+`orElse` を使って、最初の Option が `None` の場合に代替を試すことができます。
+
+```scala
+val seven: Option[Int] = Some(7)
+val eight: Option[Int] = Some(8)
+val none: Option[Int]  = None
+
+seven.orElse(eight)  // Some(7) - 最初が Some なのでそのまま
+none.orElse(eight)   // Some(8) - 最初が None なので代替を使用
+seven.orElse(none)   // Some(7)
+none.orElse(none)    // None
+```
+
+#### 単年の番組に対応する
+
+「Chernobyl (2019)」のような単年の番組をパースできるようにします。
+
+```scala
+def extractSingleYear(rawShow: String): Option[Int] = {
+  val dash         = rawShow.indexOf('-')
+  val bracketOpen  = rawShow.indexOf('(')
+  val bracketClose = rawShow.indexOf(')')
+  for {
+    yearStr <- if (dash == -1 && bracketOpen != -1 && bracketClose > bracketOpen + 1)
+                 Some(rawShow.substring(bracketOpen + 1, bracketClose))
+               else None
+    year    <- yearStr.toIntOption
+  } yield year
+}
+
+def parseShow(rawShow: String): Option[TvShow] = {
+  for {
+    name      <- extractName(rawShow)
+    yearStart <- extractYearStart(rawShow).orElse(extractSingleYear(rawShow))
+    yearEnd   <- extractYearEnd(rawShow).orElse(extractSingleYear(rawShow))
+  } yield TvShow(name, yearStart, yearEnd)
+}
+
+// これで単年の番組もパースできる
+parseShow("Chernobyl (2019)")  // Some(TvShow("Chernobyl", 2019, 2019))
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "orElse のフロー" {
+  card "extractYearStart(rawShow)" as first
+  card "extractSingleYear(rawShow)" as second
+  card "結果" as result
+
+  first --> result : Some の場合
+  first --> second : None の場合
+  second --> result
+}
+
+@enduml
+```
+
+### 6.6 Option の主要メソッド
+
+| メソッド | 説明 | 例 |
+|----------|------|-----|
+| `map` | 値があれば変換 | `Some(5).map(_ * 2)` → `Some(10)` |
+| `flatMap` | 値があれば Option を返す関数を適用 | `Some(5).flatMap(x => Some(x * 2))` → `Some(10)` |
+| `filter` | 条件を満たさなければ None | `Some(5).filter(_ > 10)` → `None` |
+| `orElse` | None なら代替を使用 | `None.orElse(Some(5))` → `Some(5)` |
+| `getOrElse` | None ならデフォルト値 | `None.getOrElse(0)` → `0` |
+| `toList` | List に変換 | `Some(5).toList` → `List(5)` |
+| `toRight` | Either に変換 | `Some(5).toRight("error")` → `Right(5)` |
+
+```scala
+val year: Option[Int]   = Some(996)
+val noYear: Option[Int] = None
+
+// map
+year.map(_ * 2)    // Some(1992)
+noYear.map(_ * 2)  // None
+
+// flatMap
+year.flatMap(y => Some(y * 2))    // Some(1992)
+noYear.flatMap(y => Some(y * 2))  // None
+
+// filter
+year.filter(_ < 2020)   // Some(996)
+year.filter(_ > 2020)   // None
+
+// orElse
+year.orElse(Some(2020))    // Some(996)
+noYear.orElse(Some(2020))  // Some(2020)
+```
+
+### 6.7 エラーハンドリング戦略
+
+複数の要素をパースする場合、2つの戦略があります。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "エラーハンドリング戦略" {
+  rectangle "Best-effort 戦略" as best {
+    card "パースできたものだけ返す"
+    card "エラーは無視"
+    card "List[TvShow] を返す"
+  }
+
+  rectangle "All-or-nothing 戦略" as all {
+    card "全部成功するか、全部失敗"
+    card "一つでも失敗したら None"
+    card "Option[List[TvShow]] を返す"
+  }
+}
+
+@enduml
+```
+
+#### Best-effort 戦略
+
+```scala
+def parseShows(rawShows: List[String]): List[TvShow] = {
+  rawShows
+    .map(parseShow)     // List[Option[TvShow]]
+    .map(_.toList)      // List[List[TvShow]]
+    .flatten            // List[TvShow]
+}
+
+val rawShows = List(
+  "Breaking Bad (2008-2013)",
+  "The Wire 2002 2008",        // 無効な形式
+  "Mad Men (2007-2015)"
+)
+
+parseShows(rawShows)
+// List(TvShow("Breaking Bad", 2008, 2013), TvShow("Mad Men", 2007, 2015))
+// 無効なものは無視される
+```
+
+#### All-or-nothing 戦略
+
+```scala
+def addOrResign(
+    parsedShows: Option[List[TvShow]],
+    newParsedShow: Option[TvShow]
+): Option[List[TvShow]] = {
+  for {
+    shows      <- parsedShows
+    parsedShow <- newParsedShow
+  } yield shows.appended(parsedShow)
+}
+
+def parseShows(rawShows: List[String]): Option[List[TvShow]] = {
+  val initialResult: Option[List[TvShow]] = Some(List.empty)
+  rawShows
+    .map(parseShow)
+    .foldLeft(initialResult)(addOrResign)
+}
+
+// 全部成功 → Some(List(...))
+parseShows(List("Breaking Bad (2008-2013)", "Mad Men (2007-2015)"))
+// Some(List(TvShow("Breaking Bad", 2008, 2013), TvShow("Mad Men", 2007, 2015)))
+
+// 一つでも失敗 → None
+parseShows(List("Breaking Bad (2008-2013)", "Invalid"))
+// None
+```
+
+---
+
+## 第7章: Either 型と複合的なエラー処理
+
+### 7.1 Option の限界
+
+`Option` は「値があるかないか」しか表現できません。**なぜ失敗したのか**を伝えられません。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Option vs Either" {
+  rectangle "Option[A]" as opt {
+    card "Some(value)" as some
+    card "None" as none
+    none -[hidden]-> some
+  }
+
+  rectangle "Either[E, A]" as either {
+    card "Right(value)" as right
+    card "Left(error)" as left
+    left -[hidden]-> right
+  }
+
+  opt --> either : 進化
+}
+
+note bottom of none
+  失敗理由が分からない
+end note
+
+note bottom of left
+  エラー情報を保持できる
+end note
+
+@enduml
+```
+
+### 7.2 Either の基本
+
+`Either[E, A]` は「`E` 型のエラーか、`A` 型の成功値か」を表す型です。
+
+- `Right(value)`: 成功（慣例的に「正しい」= right）
+- `Left(error)`: 失敗（エラー情報を保持）
+
+```scala
+def extractName(show: String): Either[String, String] = {
+  val bracketOpen = show.indexOf('(')
+  if (bracketOpen > 0) Right(show.substring(0, bracketOpen).trim)
+  else Left(s"Can't extract name from $show")
+}
+
+extractName("The Wire (2002-2008)")  // Right("The Wire")
+extractName("(2022)")                // Left("Can't extract name from (2022)")
+```
+
+### 7.3 Either を使ったパース
+
+**ソースファイル**: `app/scala/src/main/scala/ch06_TvShows.scala`
+
+```scala
+def extractYearStart(rawShow: String): Either[String, Int] = {
+  val bracketOpen = rawShow.indexOf('(')
+  val dash        = rawShow.indexOf('-')
+  for {
+    yearStr <- if (bracketOpen != -1 && dash > bracketOpen + 1)
+                 Right(rawShow.substring(bracketOpen + 1, dash))
+               else Left(s"Can't extract start year from $rawShow")
+    year    <- yearStr.toIntOption.toRight(s"Can't parse $yearStr")
+  } yield year
+}
+
+extractYearStart("The Wire (2002-2008)")  // Right(2002)
+extractYearStart("The Wire (-2008)")      // Left("Can't extract start year from The Wire (-2008)")
+extractYearStart("The Wire (oops-2008)")  // Left("Can't parse oops")
+```
+
+### 7.4 Option から Either への変換
+
+`toRight` メソッドで `Option` を `Either` に変換できます。
+
+```scala
+val year: Option[Int] = Some(996)
+val noYear: Option[Int] = None
+
+year.toRight("no year given")    // Right(996)
+noYear.toRight("no year given")  // Left("no year given")
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "toRight の動作" {
+  card "Some(value)" as some
+  card "None" as none
+
+  card "Right(value)" as right
+  card "Left(errorMsg)" as left
+
+  some --> right : toRight(errorMsg)
+  none --> left : toRight(errorMsg)
+}
+
+@enduml
+```
+
+### 7.5 Either による完全なパーサー
+
+```scala
+def parseShow(rawShow: String): Either[String, TvShow] = {
+  for {
+    name      <- extractName(rawShow)
+    yearStart <- extractYearStart(rawShow).orElse(extractSingleYear(rawShow))
+    yearEnd   <- extractYearEnd(rawShow).orElse(extractSingleYear(rawShow))
+  } yield TvShow(name, yearStart, yearEnd)
+}
+
+parseShow("The Wire (2002-2008)")  // Right(TvShow("The Wire", 2002, 2008))
+parseShow("Mad Men ()")            // Left("Can't extract single year from Mad Men ()")
+parseShow("The Wire (-)")          // Left("Can't extract single year from The Wire (-)")
+parseShow("(2002-2008)")           // Left("Can't extract name from (2002-2008)")
+```
+
+### 7.6 Either の主要メソッド
+
+| メソッド | 説明 | 例 |
+|----------|------|-----|
+| `map` | Right の値を変換 | `Right(5).map(_ * 2)` → `Right(10)` |
+| `flatMap` | Right なら Either を返す関数を適用 | `Right(5).flatMap(x => Right(x * 2))` → `Right(10)` |
+| `orElse` | Left なら代替を使用 | `Left("err").orElse(Right(5))` → `Right(5)` |
+| `toOption` | Option に変換 | `Right(5).toOption` → `Some(5)` |
+| `flatten` | ネストした Either を平坦化 | `Right(Right(5)).flatten` → `Right(5)` |
+
+```scala
+val year: Either[String, Int]   = Right(996)
+val noYear: Either[String, Int] = Left("no year")
+
+// map
+year.map(_ * 2)    // Right(1992)
+noYear.map(_ * 2)  // Left("no year")
+
+// flatMap
+year.flatMap(y => Right(y * 2))             // Right(1992)
+noYear.flatMap(y => Right(y * 2))           // Left("no year")
+year.flatMap(y => Left("can't progress"))   // Left("can't progress")
+
+// orElse
+year.orElse(Right(2020))           // Right(996)
+noYear.orElse(Right(2020))         // Right(2020)
+noYear.orElse(Left("can't recover")) // Left("can't recover")
+
+// toOption
+year.toOption    // Some(996)
+noYear.toOption  // None
+```
+
+### 7.7 音楽アーティスト検索の例
+
+**ソースファイル**: `app/scala/src/main/scala/ch07_MusicArtistsSearch.scala`
+
+より複雑な例として、音楽アーティストの検索機能を見てみましょう。
+
+#### 基本的なモデル（問題あり）
+
+```scala
+case class Artist(
+    name: String,
+    genre: String,
+    origin: String,
+    yearsActiveStart: Int,
+    isActive: Boolean,
+    yearsActiveEnd: Int  // アクティブな場合は 0 を入れる？
+)
+```
+
+この設計には問題があります:
+- `isActive` が `true` の場合、`yearsActiveEnd` は何を入れるべき？
+- 無効な状態（`isActive = true` かつ `yearsActiveEnd = 2020`）を作れてしまう
+
+#### Option を使った改善
+
+```scala
+case class Artist(
+    name: String,
+    genre: String,
+    origin: String,
+    yearsActiveStart: Int,
+    yearsActiveEnd: Option[Int]  // アクティブなら None
+)
+
+val metallica = Artist("Metallica", "Heavy Metal", "U.S.", 1981, None)
+val ledZeppelin = Artist("Led Zeppelin", "Hard Rock", "England", 1968, Some(1980))
+```
+
+### 7.8 代数的データ型（ADT）
+
+**enum**（列挙型）を使って、より表現力の高いモデルを作れます。
+
+#### 直積型（Product Type）
+
+複数のフィールドを**AND**で組み合わせる型です。
+
+```scala
+case class PeriodInYears(start: Int, end: Option[Int])
+
+case class Artist(
+    name: String,
+    genre: MusicGenre,
+    origin: Location,
+    yearsActive: PeriodInYears
+)
+```
+
+#### 直和型（Sum Type）
+
+複数の選択肢を**OR**で表す型です。
+
+```scala
+enum MusicGenre {
+  case HeavyMetal
+  case Pop
+  case HardRock
+}
+
+enum YearsActive {
+  case StillActive(since: Int)
+  case ActiveBetween(start: Int, end: Int)
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "代数的データ型（ADT）" {
+  rectangle "直積型（Product Type）" as product {
+    card "case class"
+    card "A AND B AND C"
+    card "フィールドの組み合わせ"
+  }
+
+  rectangle "直和型（Sum Type）" as sum {
+    card "enum / sealed trait"
+    card "A OR B OR C"
+    card "選択肢のいずれか"
+  }
+}
+
+note bottom of product
+  Artist = name AND genre AND origin AND yearsActive
+end note
+
+note bottom of sum
+  YearsActive = StillActive OR ActiveBetween
+end note
+
+@enduml
+```
+
+### 7.9 パターンマッチング
+
+直和型は**パターンマッチング**で処理します。
+
+```scala
+def wasArtistActive(artist: Artist, yearStart: Int, yearEnd: Int): Boolean = {
+  artist.yearsActive match {
+    case StillActive(since)        => since <= yearEnd
+    case ActiveBetween(start, end) => start <= yearEnd && end >= yearStart
+  }
+}
+
+def activeLength(artist: Artist, currentYear: Int): Int = {
+  artist.yearsActive match {
+    case StillActive(since)        => currentYear - since
+    case ActiveBetween(start, end) => end - start
+  }
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "パターンマッチング" {
+  card "artist.yearsActive" as input
+
+  rectangle "match" as match_block {
+    card "case StillActive(since) =>" as case1
+    card "case ActiveBetween(start, end) =>" as case2
+  }
+
+  card "結果" as result
+
+  input --> match_block
+  match_block --> result
+}
+
+note bottom
+  全てのケースを網羅する必要がある
+  （コンパイラがチェック）
+end note
+
+@enduml
+```
+
+### 7.10 検索条件のモデリング
+
+検索条件も ADT でモデリングできます。
+
+```scala
+enum SearchCondition {
+  case SearchByGenre(genres: List[MusicGenre])
+  case SearchByOrigin(locations: List[Location])
+  case SearchByActiveYears(start: Int, end: Int)
+}
+
+def searchArtists(
+    artists: List[Artist],
+    requiredConditions: List[SearchCondition]
+): List[Artist] = {
+  artists.filter(artist =>
+    requiredConditions.forall(condition =>
+      condition match {
+        case SearchByGenre(genres)           => genres.contains(artist.genre)
+        case SearchByOrigin(locations)       => locations.contains(artist.origin)
+        case SearchByActiveYears(start, end) => wasArtistActive(artist, start, end)
+      }
+    )
+  )
+}
+```
+
+### 7.11 forall と exists
+
+Option と List で条件判定をする際に便利なメソッドです。
+
+| メソッド | Option での動作 | List での動作 |
+|----------|-----------------|---------------|
+| `forall(p)` | None → true, Some(x) → p(x) | 全要素が p を満たす |
+| `exists(p)` | None → false, Some(x) → p(x) | いずれかの要素が p を満たす |
+| `contains(x)` | Some(x) と等しいか | x を含むか |
+
+```scala
+val year: Option[Int] = Some(996)
+val noYear: Option[Int] = None
+
+// forall - 「全て」または「存在しない」
+year.forall(_ < 2020)    // true (996 < 2020)
+noYear.forall(_ < 2020)  // true (値がないので「全て」が自明に真)
+year.forall(_ > 2020)    // false
+
+// exists - 「存在して条件を満たす」
+year.exists(_ < 2020)    // true
+noYear.exists(_ < 2020)  // false (値がないので存在しない)
+```
+
+---
+
+## まとめ
+
+### Part III で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part III: エラーハンドリング" {
+  rectangle "第6章" as ch6 {
+    card "Option[A]"
+    card "Some / None"
+    card "orElse"
+    card "for 内包表記"
+    card "エラーハンドリング戦略"
+  }
+
+  rectangle "第7章" as ch7 {
+    card "Either[E, A]"
+    card "Right / Left"
+    card "エラーメッセージの保持"
+    card "ADT（代数的データ型）"
+    card "パターンマッチング"
+  }
+}
+
+ch6 --> ch7
+
+@enduml
+```
+
+### Option vs Either の使い分け
+
+| 状況 | 使用する型 |
+|------|------------|
+| 値があるかないかだけが重要 | `Option[A]` |
+| 失敗理由を伝える必要がある | `Either[E, A]` |
+| 検索結果が見つからない | `Option[A]` |
+| バリデーションエラーを伝える | `Either[String, A]` |
+| 複数のエラー種別がある | `Either[ErrorType, A]` |
+
+### キーポイント
+
+1. **Option**: 値の有無を型で表現する
+2. **Either**: 成功/失敗とエラー情報を型で表現する
+3. **for 内包表記**: Option/Either を組み合わせて使う
+4. **orElse**: フォールバックを提供する
+5. **ADT**: 直積型と直和型でドメインを正確にモデリング
+6. **パターンマッチング**: 直和型を安全に処理する
+
+### 次のステップ
+
+Part IV では、以下のトピックを学びます:
+
+- IO モナドの導入
+- 副作用の管理
+- ストリーム処理
+
+---
+
+## 演習問題
+
+### 問題 1: Option の基本
+
+以下の関数を実装してください。
+
+```scala
+def safeDivide(a: Int, b: Int): Option[Int] = ???
+
+// 期待される動作
+assert(safeDivide(10, 2) == Some(5))
+assert(safeDivide(10, 0) == None)
+assert(safeDivide(7, 2) == Some(3))
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+def safeDivide(a: Int, b: Int): Option[Int] = {
+  if (b == 0) None
+  else Some(a / b)
+}
+```
+
+</details>
+
+### 問題 2: Option の合成
+
+以下の関数を実装してください。2つの数値文字列を受け取り、その合計を返します。
+
+```scala
+def addStrings(a: String, b: String): Option[Int] = ???
+
+// 期待される動作
+assert(addStrings("10", "20") == Some(30))
+assert(addStrings("10", "abc") == None)
+assert(addStrings("xyz", "20") == None)
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+def addStrings(a: String, b: String): Option[Int] = {
+  for {
+    x <- a.toIntOption
+    y <- b.toIntOption
+  } yield x + y
+}
+```
+
+</details>
+
+### 問題 3: Either によるバリデーション
+
+以下の関数を実装してください。年齢を検証し、エラーメッセージを返します。
+
+```scala
+def validateAge(age: Int): Either[String, Int] = ???
+
+// 期待される動作
+assert(validateAge(25) == Right(25))
+assert(validateAge(-5) == Left("Age cannot be negative"))
+assert(validateAge(200) == Left("Age cannot be greater than 150"))
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+def validateAge(age: Int): Either[String, Int] = {
+  if (age < 0) Left("Age cannot be negative")
+  else if (age > 150) Left("Age cannot be greater than 150")
+  else Right(age)
+}
+```
+
+</details>
+
+### 問題 4: パターンマッチング
+
+以下の enum とパターンマッチングを使った関数を実装してください。
+
+```scala
+enum PaymentMethod {
+  case CreditCard(number: String, expiry: String)
+  case BankTransfer(accountNumber: String)
+  case Cash
+}
+
+def describePayment(method: PaymentMethod): String = ???
+
+// 期待される動作
+assert(describePayment(CreditCard("1234", "12/25")) == "Credit card ending in 1234")
+assert(describePayment(BankTransfer("9876")) == "Bank transfer to account 9876")
+assert(describePayment(Cash) == "Cash payment")
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+import PaymentMethod._
+
+def describePayment(method: PaymentMethod): String = method match {
+  case CreditCard(number, _) => s"Credit card ending in $number"
+  case BankTransfer(account) => s"Bank transfer to account $account"
+  case Cash                  => "Cash payment"
+}
+```
+
+</details>
+
+### 問題 5: forall と exists
+
+以下の条件に合うユーザーを抽出する関数を実装してください。
+
+```scala
+case class User(name: String, email: Option[String], age: Int)
+
+val users = List(
+  User("Alice", Some("alice@example.com"), 25),
+  User("Bob", None, 30),
+  User("Charlie", Some("charlie@test.com"), 17)
+)
+
+// 1. メールアドレスが設定されていないか、example.com ドメインのユーザー
+def f1(users: List[User]): List[User] = ???
+
+// 2. メールアドレスが設定されていて、test.com ドメインのユーザー
+def f2(users: List[User]): List[User] = ???
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+// 1. メールアドレスが設定されていないか、example.com ドメイン
+def f1(users: List[User]): List[User] = {
+  users.filter(_.email.forall(_.endsWith("@example.com")))
+}
+// List(User("Alice", ...), User("Bob", None, 30))
+
+// 2. メールアドレスが設定されていて、test.com ドメイン
+def f2(users: List[User]): List[User] = {
+  users.filter(_.email.exists(_.endsWith("@test.com")))
+}
+// List(User("Charlie", ...))
+```
+
+</details>