Last active
November 28, 2018 07:40
-
-
Save pei0804/9f3a476edf344cf16c267171b7d240a2 to your computer and use it in GitHub Desktop.
scala
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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) | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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")) | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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") | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment