scala

either.scala

object Main {
  def main(args: Array[String]): Unit = {
    val v1: Either[String, Int] = Right(123)
    val v2: Either[String, Int] = Left("abc")

    v1 match {
      case Right(i) => println(i)
      case Left(s) => println(s)
    } // 123

    sealed trait LoginError

    case object InvalidPassword extends LoginError
    case object UserNotFound extends LoginError
    case object PasswordLocked extends LoginError

    case class User(id: Long, name: String, password: String)

    object LoginService {
      def login(name: String, password: String): Either[LoginError, User] = ???
    }

    LoginService.login("test", "pass") match {
      case Right(user) => println(s"id: ${user.id}")
      case Left(InvalidPassword) => println("invalid password")
      case Left(UserNotFound) => println("not found user")
      case Left(PasswordLocked) => println("password locked")
      case _ => println("error")
    }
    
    val vr: Either[String, Int] = Right(123)
    println(vr.map(_ * 2)) // Right(246)

    val vl: Either[String, Int] = Left("a")
    println(vl.map(_ * 2)) // Left(a)
  }

implicit.scala

object Main {
  def main(args: Array[String]): Unit = {
    trait Calc[A] {
      def plus(a: A, b: A): A
      def zero: A
    }

    object StringCalc extends Calc[String] {
      def plus(a: String, b: String): String = a + b
      def zero: String = ""
    }

    object IntCalc extends Calc[Int] {
      def plus(a: Int, b: Int): Int = a + b
      def zero: Int = 0
    }

    def sum[A](lst: List[A])(c: Calc[A]) = {
      lst.foldLeft(c.zero)((x, y) => c.plus(x, y))
    }

    sum(List(1, 2, 3))(IntCalc)
    sum(List("A", "B", "C"))(StringCalc)
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    trait Calc[A] {
      def plus(a: A, b: A): A
      def zero: A
    }

    implicit object StringCalc extends Calc[String] {
      def plus(a: String, b: String): String = a + b
      def zero: String = ""
    }

    implicit object IntCalc extends Calc[Int] {
      def plus(a: Int, b: Int): Int = a + b
      def zero: Int = 0
    }

    def sum[A](lst: List[A])(implicit c: Calc[A]) = {
      lst.foldLeft(c.zero)((x, y) => c.plus(x, y))
    }

    sum(List(1, 2, 3))
    sum(List("A", "B", "C"))
  }
}

option.scala

object Main {
  def main(args: Array[String]): Unit = {
    val v1: Option[Int] = Some(3)
    val v2: Option[Int] = Some(5)
    println(v1.map(v1 => v2.map(v2 => v1 * v2))) // Some(Some(15))
    println(v1.map(v1 => v2.map(v2 => v1 * v2)).flatten) // Some(15)
    println(v1.flatMap(v1 => v2.map(v2 => v1 * v2))) // Some(15)

    val v3: Option[Int] = Some(10)
    val v4: Option[Int] = Some(15)
    val v5: Option[Int] = Some(20)
    val ans = v1.flatMap { i1 =>
      v2.flatMap { i2 =>
        v3.flatMap { i3 =>
          v4.flatMap { i4 =>
            v5.map { i5 => i1 * i2 * i3 * i4 * i5 }
          }
        }
      }
    }
    println(ans)
    println(v1.flatMap(i1 => v2.flatMap(i2 => v3.map(i3 => i1 * i2 * i3))))

    for { i1 <- v1
          i2 <- v2
          i3 <- v3
          i4 <- v4
          i5 <- v5 } yield i1 * i2 * i3 * i4 * i5

  }
}

pattern.scala

sealed abstract class Animal

case class Lion(name: String, voice: Option[String]) extends Animal
case class Cat(name: String, voice: Option[String]) extends Animal
case class Dog(name: String, voice: Option[String]) extends Animal
case class ???(name: String, voice: Option[String]) extends Animal

object Main extends App {

  def simple(expr: Animal): Unit = expr match {
    case Lion(n, v) => println(s"$n=$v")
    case _ =>
  }

  simple(Lion("Name", Some("Voice"))) // Name=Some(Voice)
  simple(Lion("Name", None)) // Name=None

  def simple2(target: Animal): Unit = target match {
    case l: Lion => println("lion")
    case c: Cat => println("cat")
    case d: Dog => println("d")
    case _ =>
  }

  simple2(Lion("a", None)) // lion
  simple2(Cat("a", None)) // cat

  List(1, 2, 3, 4) match { // 2 List(1, 2, 3, 4)
    case Seq(x) => println(s"1 $x")
    case Seq(x @ _*) => println(s"2 $x")
  }
}

refactor.scala

object Main {

  object Before {

    case class Address(id: Int, name: String, postalCode: Option[String])

    case class User(id: Int, name: String, addressId: Option[Int])

    val userDatabase: Map[Int, User] = Map(
      1 -> User(1, "太郎", Some(1)),
      2 -> User(2, "次郎", Some(2)),
      3 -> User(3, "プー太郎", None)
    )

    val addressDatabase: Map[Int, Address] = Map(
      1 -> Address(1, "渋谷", Some("150-0002")),
      2 -> Address(2, "国際宇宙ステーション", None)
    )

    sealed abstract class PostalCodeResult

    case class Success(postalCode: String) extends PostalCodeResult

    sealed abstract class Failure extends PostalCodeResult

    case object UserNotFound extends Failure

    case object UserNotHasAddress extends Failure

    case object AddressNotFound extends Failure

    case object AddressNotHasPostalCode extends Failure

    // Super nest code for where is error.
    def getPostalCodeResult(userId: Int): PostalCodeResult = {
      findUser(userId) match {
        case Some(user) =>
          user.addressId match {
            case Some(addressId) =>
              findAddress(addressId) match {
                case Some(address) =>
                  address.postalCode match {
                    case Some(postalCode) => Success(postalCode)
                    case None => AddressNotHasPostalCode
                  }
                case None => AddressNotFound
              }
            case None => UserNotHasAddress
          }
        case None => UserNotFound
      }
    }

    def findUser(userId: Int): Option[User] = {
      userDatabase.get(userId)
    }

    def findAddress(addressId: Int): Option[Address] = {
      addressDatabase.get(addressId)
    }
  }

  object After {

    case class Address(id: Int, name: String, postalCode: Option[String])

    case class User(id: Int, name: String, addressId: Option[Int])

    val userDatabase: Map[Int, User] = Map(
      1 -> User(1, "太郎", Some(1)),
      2 -> User(2, "次郎", Some(2)),
      3 -> User(3, "プー太郎", None)
    )

    val addressDatabase: Map[Int, Address] = Map(
      1 -> Address(1, "渋谷", Some("150-0002")),
      2 -> Address(2, "国際宇宙ステーション", None)
    )

    sealed abstract class PostalCodeResult

    case class Success(postalCode: String) extends PostalCodeResult

    sealed abstract class Failure extends PostalCodeResult

    case object UserNotFound extends Failure

    case object UserNotHasAddress extends Failure

    case object AddressNotFound extends Failure

    case object AddressNotHasPostalCode extends Failure

    def getPostalCodeResult(userId: Int): PostalCodeResult = {
      (for {
        user <- findUser(userId)
        address <- findAddress(user)
        postalCode <- findPostalCode(address)
      } yield Success(postalCode)).merge
    }

    def findUser(userId: Int): Either[Failure, User] = {
      userDatabase.get(userId).toRight(UserNotFound)
    }

    def findAddress(user: User): Either[Failure, Address] = {
      for {
        addressId <- user.addressId.toRight(UserNotHasAddress)
        address <- addressDatabase.get(addressId).toRight(AddressNotFound)
      } yield address
    }

    def findPostalCode(address: Address): Either[Failure, String] = {
      address.postalCode.toRight(AddressNotFound)
    }
  }

  def main(args: Array[String]): Unit = {
    println(Before.getPostalCodeResult(1)) // Success(150-0002)
    println(Before.getPostalCodeResult(2)) // AddressNotHasPostalCode
    println(Before.getPostalCodeResult(3)) // UserNotHasAddress
    println(Before.getPostalCodeResult(4)) // UserNotFound

    println("-----------")

    println(After.getPostalCodeResult(1)) // Success(150-0002)
    println(After.getPostalCodeResult(2)) // AddressNotHasPostalCode
    println(After.getPostalCodeResult(3)) // UserNotHasAddress
    println(After.getPostalCodeResult(4)) // UserNotFound
  }
}

try.scala

import scala.util.Try
import scala.util.control.NonFatal

object Main {
  def main(args: Array[String]): Unit = {
    val v: Try[Int] = Try(throw new RuntimeException("whats up"))
    println(v) // Failure(java.lang.RuntimeException: whats up)

    val v1 = Try(3)
    println(v1) // Success(3)

    try {
      ???
    } catch {
      case NonFatal(e) => println(e) // scala.NotImplementedError: an implementation is missing
    }
  }
}