study-note

8. FP（関数型プログラミング）

目次

• モナド（Monad）
• Option型
  • Optionの活用
  • Optionの合成
• Either
  • Eitherの合成
• Future（非同期処理）

モナド（Monad）

値を安全にラップして、操作をつなげられる型のこと

1. Option
2. Either
3. Future

Option型

• 「値があるかもしれないし、ないかもしれない」を表現するコンテナ型
• Javaや他の言語ではnullが多用され、その扱いでバグが多発する
• Scalaはnullの代わりにOption型を使い、安全に値の有無を表現する

• Some("")
  • 「値がある」ことを表す
  • カッコ内の文字列""が「実際の値」
  • 例：Some("hello")は「値が’hello’で存在する」ことを表す
• None
  • 「値がない」ことを表す
  • 値を持たないため、()は付けない

• 基本例

  def findName(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }
  
  val nameOpt = findName(2)
  
  nameOpt match {
    case Some(name) => println(s"Name found: $name")
    case None       => println("No name found")
  }
  

• 使い方例1

  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }
  
  val user1 = findUser(1) // Some("Alice")
  val user2 = findUser(2) // None
  

• 使い方例2

  def findName(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }
  
  val nameOpt = findName(2)
  
  nameOpt match {
    case Some(name) => println(s"Name found: $name")
    case None       => println("No name found")
  }
  

参照：サンプルコード

Scala標準ライブラリ（Option)

• .map：値があるときだけ関数を適用

  val nameOpt = Some("Alice")
  val upper = nameOpt.map(n => n.toUpperCase)  // Some("ALICE")
  

  Noneだった場合はスルーされ、結果もNoneのまま

• .getOrElse(default)：値がないときのデフォルトを指定

  val result = nameOpt.getOrElse("No name")  // "Alice"
  val noneOpt: Option[String] = None
  val fallback = noneOpt.getOrElse("No name")  // "No name"
  

• .flatmap
• fold

参照：サンプルコード

Optionの合成

複数のOptionを連続的に使いたいとき、ネストせずに読みやすく書くことができる

def getUser(id: Int): Option[String] = Some("ユーザー")
def getEmail(name: String): Option[String] = Some(s"$name@example.com")

val result: Option[String] = for {
  name  <- getUser(1)
  email <- getEmail(name)
} yield s"Send to: $email"

println(result.getOrElse("No email found"))

• Noneが1つでもあれば全体がNoneになる
• Someならばその中身を抽出して順に使える
• yieldの中が最終結果になる

参照：サンプルコード

Either

val result: Either[String, Int] = Right(42)
val error: Either[String, Int] = Left("Error occurred")

• Right：成功（正常系）
• Left：失敗（異常系）

活用例

val res: Either[String, Int] = Right(42)

res match {
  case Right(v) => println(s"Success: $v")
  case Left(e)  => println(s"Error: $e")
}

参照：サンプルコード

Scala標準ライブラリ（Either)

• left/right投影
• map
• flatMap
• fold

Eitherの合成

複数のEitherを連続的に使いたいときに、ネストせずに読みやすく書くことができる

def getUser(id: Int): Either[String, String] = Right("ユーザー")
def getEmail(name: String): Either[String, String] = Right(s"$name@example.com")

val result: Either[String, String] = for {
  name  <- getUser(1)
  email <- getEmail(name)
} yield s"Send to: $email"

println(result) // Right(Send to: ユーザー@example.com)

• Leftが1つでも出たらその時点で打ち切られる（早期return）
• Right同士ならば、合成されて最終的にRight（結果）になる

参照：サンプルコード

Future（非同期処理）

• 将来のある時点で値を返す約束（非同期計算の結果）
• ブロックの処理を待たずに次の処理へ進める
• 完了後にコールバックやマップで処理を続けられる

import scala.concurrent._
import ExecutionContext.Implicits.global
import scala.util.{Success, Failure}

val f: Future[Int] = Future {
  // 重い計算やI/O処理を非同期に実行
  Thread.sleep(1000)
  42
}

f.onComplete {
  case Success(value) => println(s"Got the result: $value")
  case Failure(e) => println(s"Failed with $e")
}

• Future { ... }ブロック内の処理は別スレッドで非同期実行
• onCompleteで成功・失敗をハンドル

• import ExecutionContext.Implicits.globalでスレッドプールの設定が必要
• Await.resultで同期的に結果を待てるが、多用は避ける

参照：サンプルコード

Scala標準ライブラリ（Future)

• onComplete：結果に応じた処理を登録
• map/flatMap：非同期チェーン処理
• recover/recoverWith：エラーを補正