Either、Option、Tryをソースレベルで理解

差異

Either

結果の2つの可能性を表し、1つはRight、1つはLeft

Option

選択可能な値を表し、1つはSome(値を表す)、1つはNone(値が空).結果がnullの場合によく用いられる.

Try

演算の結果、2つのケースがあり、1つは正常に動作している、すなわちSuccess、1つは運転エラー、異常放出、すなわちFailureであり、そのうちFailureには異常の情報が含まれている.
共通点
3つとも2つの可能性の値がある.いずれも結果の上でmap・flatMapなどの操作が可能である.

Either

RightとLeftは、Eitherから継承された2つcaseクラスである.

    //Left
    final case class Left[+A, +B](@deprecatedName('a, "2.12.0") value: A) extends Either[A, B]
    
    //Right
    final case class Right[+A, +B](@deprecatedName('b, "2.12.0") value: B) extends Either[A, B]

Eihter1つの結果の2つの可能性を表し、1つはRight、1つはLeft;

    import scala.io.StdIn._
    val in = readLine("Type Either a string or an Int: ")
    val result: Either[String,Int] =
      try Right(in.toInt)
      catch {
        case e: NumberFormatException => Left(in)
      }
    result match {
      case Right(x) => s"You passed me the Int: $x, which I will increment. $x + 1 = ${x+1}"
      case Left(x)  => s"You passed me the String: $x"
    }

Either偏っているRight値の場合、Either使用map・flatMap等の操作の場合、Eitherの結果Rightの場合のみ、操作がトリガーされる.習慣的にLeft値は悪い結果(失敗した結果)、Right良い結果(成功した結果)を表す.

    def doubled(i: Int) = i * 2
    Right(42).map(doubled) // Right(84)
    Left(42).map(doubled)  // Left(42)

Either定義したflatMapとmapのため、Eitherに対して使用可能for comprehensions;

    val right1 = Right(1)   : Right[Double, Int] //  right1   
    val right2 = Right(2)
    val right3 = Right(3)
    val left23 = Left(23.0) : Left[Double, Int]  //  left23   
    val left42 = Left(42.0)
    for {
      x 

ただし、ガード式の使用はサポートされていません.

    for {
      i  0
    } yield i
    // error: value withFilter is not a member of Right[Double,Int]

同様に、以下もサポートされていません

    for (x: Int 

for comprehensions使用mapおよびflatMapのため、パラメータのタイプを導出しなければならず、このタイプはEitherでなければならない.特に、Either偏向Rightのため、Eitherに対する値はLeftそのタイプを指定しなければならないが、そうでなければ、その位置のデフォルトタイプはNothingである.

    for {
      x 

Option

SomeとNoneは、Optionから継承された2つcaseクラスである.

    //Some
    final case class Some[+A](@deprecatedName('x, "2.12.0") value: A) extends Option[A]
    
    //None
    case object None extends Option[Nothing]

対Optionの慣用としては集合とするかmonad、通過map・flatMap・filter・・とforeach:

    //   
    val name: Option[String] = request getParameter "name"
    val upper = name map { _.trim } filter { _.length != 0 } map { _.toUpperCase }
    println(upper getOrElse "")
    
    //         
    val upper = for {
      name 

もう一つの習慣的な使い方は(あまりお勧めしません)パターンマッチングです.

    val nameMaybe = request getParameter "name"
    nameMaybe match {
      case Some(name) =>
        println(name.trim.toUppercase)
      case None =>
        println("No name value")
    }

Try

FailureとSuccessは、Tryから継承された2つcaseクラスである.

    //Failure
    final case class Failure[+T](exception: Throwable) extends Try[T]
    
    //Success
    final case class Success[+T](value: T) extends Try[T]

Try異常がある場合によく用いられ、Try発生する可能性のある異常を不確定に処理する.

    import scala.io.StdIn
    import scala.util.{Try, Success, Failure}
    def divide: Try[Int] = {
      val dividend = Try(StdIn.readLine("Enter an Int that you'd like to divide:
").toInt)
      val divisor = Try(StdIn.readLine("Enter an Int that you'd like to divide by:
").toInt)
      val problem = dividend.flatMap(x => divisor.map(y => x/y))
      problem match {
        case Success(v) =>
          println("Result of " + dividend.get + "/"+ divisor.get +" is: " + v)
          Success(v)
        case Failure(e) =>
          println("You must've divided by zero or entered something that's not an Int. Try again!")
          println("Info from the exception: " + e.getMessage)
          divide
      }
    }

以上の例では、Tryの重要な特性の一つとして、Try配管機能を有すること、flatMapおよびmapそれらの成功した操作の結果をSuccessに包装し、それらの異常をFailureに包装し、recoverおよびrecoverWithに対しては、デフォルト対Failure結果がトリガーされることが分かる.