Concurrent Application Development using Scala

Concurrent Application
Development using Scala
Sergei Semenchuk
https://github.com/binjip978/ConcTalk

def withdrawMoney(user: String,
password: String, amount: Int): Money = {
// some logic
Money(amount)
}
def buyBook(name: String, cash: Money): Book = {
// some logic
Book("Functional Programming in Scala")
}
val cash = withdrawMoney("user1", "password2", 100)
val book = buyBook("Functional Programming in Scala", cash)
println(book)

trait Try[+T]
case class Success[+T](value: T) extends Try[T]
case class Failure(e: Throwable) extends Try[Nothing]
val success = Success(100)
success match {
case Success(v) => println(v)
case Failure(e) => println(s"Error: $e")
}

val v = Try {
if (scala.util.Random.nextBoolean() == true) 12
else 1 / 0
}
v match {
case Failure(e) => println("Error!")
}

def withdrawMoney(user: String,
password: String, amount: Int): Try[Money] = {
Try(Money(amount))
}
def buyBook(name: String, cash: Money): Try[Book] = {
Try(Book("Functional Programming in Scala"))
}
withdrawMoney("user1", "password2", 100) match {
case Success(cash) => {
buyBook("Functional Programming in Scala", cash) match {
case Success(book) => println(book)
case Failure(e) => println(s"Error occurred: $e")
}
}
case Failure(e) => println(s"Error occurred: $e")
}

case class Money(amount: Int)
case class Book(title: String)
def withdrawMoney(user: String, password:
String, amount: Int): Try[Money] = {
// some logic
Try(Money(amount))
}
// some logic
}
for {
cash <- withdrawMoney("user1", "password2", 100)
book <- buyBook("Functional Programming in Scala", cash)
} println(book)

case class Money(amount: Int)
case class Book(title: String)
def withdrawMoney(user: String, password:
String, amount: Int): Try[Money] = {
// some logic
Try(Money(amount))
}
// some logic
}
val book = withdrawMoney("user1", "password2", 100)
.flatMap(cash => buyBook("Functional Programming in Scala", cash))
book.foreach(b => println(b))
}

trait Option[+A]
case class Some[+A](v: A) extends Option[A]
case object None extends Option[Nothing]
def unit[A](v: A): Option[A] = {
Some(v)
}
def flatMap[A, B](op: Option[A])(f: A => Option[B]): Option[B]
= op match {
case Some(v) => f(v)
case None => None
}
def map[A, B](op: Option[A])(f: A => B): Option[B] = {
flatMap(op)(x => unit(f(x)))
}

The Four Essential Effects In Programming
One Many
Synchronous T/Try[T] Iterable[T]
Asynchronous Future[T] Observable[T]

Asynchronous Programming with
Futures
and Promises

//def apply[T](b: =>T)(implicit e: ExecutionContext): Future[T]
val f = Future { println("Hello World!") }
println(f.isCompleted)
Thread.sleep(1000)
println(f.isCompleted)

def getUrlSpec(): Future[List[String]] = Future {
val url = "http://www.w3.org/Addressing/URL/url-spec.txt"
val f = scala.io.Source.fromURL(url)
try {
f.getLines().toList
} finally {
f.close()
}
}
def find(lines: List[String], keyword: String):String = {
lines.zipWithIndex.collect {
case (line, n) if (line.contains(keyword)) => (n, line)
} mkString("n")
}
val f = getUrlSpec()
f.foreach { case (lines) => println(find(lines, “telnet")) }
Thread.sleep(5000)

val f: Future[Int] = Future { 1 / 0 }
f onComplete {
case Success(v) => println("Surprise!")
}
Thread.sleep(1000)

val f1: Future[Int] = Future { 1345 }
val comp1: Future[Int] = f1.flatMap(v1 => f2.flatMap(v2 =>
f3.map(v3 => v1 + v2 + v3)))
val comp2: Future[Int] = for {
v1 <- f1
v2 <- f2
v3 <- f3
} yield v1 + v2 + v3
//comp1 === comp2
comp1.onSuccess { case(x: Int) => println(x) }
comp2.onSuccess { case(x: Int) => println(x) }
Thread.sleep(1000)
}

val f1 = Future { 1 }
val f2 = Future { 1 / 0 }
val f3 = Future { 2 }
val c = for {
v1 <- f1
v2 <- f2
v3 <- f3
} yield v1 + v2 + v3
c onComplete {
case Failure(e) => println(s"error $e")
}
Thread.sleep(1000)

def getRandonName = Future { "John" }
def getIdByName(name: String) = Future { 12 }
def getDepotIdById(id: Int) = Future { 34 }
def getDepotName(id: Int) = Future { "A depot" }
val f = for {
name <- getRandonName
userId <- getIdByName(name)
depotId <- getDepotIdById(userId)
depotName <- getDepotName(userId)
} yield s"$name from $depotName"
f.onSuccess {
case (v) => println(v)
}
Thread.sleep(1000)

def getUSDQuote = Future { 1.2 }
def getEURQuote = Future { 0.8 }
val p = for {
usd <- getUSDQuote
eur <- getEURQuote
if (eur > usd)
} yield usd
p onFailure { case (e) => println("Error: " + e) }
Thread.sleep(1000)

val f1: Future[Int] = Future { 1 / 0 }
val f2: Future[Any] = f1.recover {
case (exp) => s"error happend: $exp"
}
f2.onComplete {
case Success(v) => println(s"if success: $v")
case Failure(e) => println(s"if failure: $e")
}
Thread.sleep(1000)

val p = Promise[String]
val q = Promise[String]
p.future foreach { case x => println(x)}
q.future.failed foreach { case e => println(s"error: " + e)}
p.complete(Success("Promise complete"))
q.complete(Failure(new Exception))
val z = Promise[Int]
z.future onComplete {
}
z.complete(Try(1 / 0))

def first[T](xs: List[Future[T]]): Future[T] = {
val p = Promise[T]
for {
x <- xs
} p.tryCompleteWith(x)
p.future
}
val f = first(List(Future{ Thread.sleep(2000);
12 }, Future { new Exception }))
f.foreach { case x => println(x) }

val urlSpecSize = Future {
val url = "http://www.scala-lang.org"
scala.io.Source.fromURL(url).size
}
// how much we should wait until exception
val size = Await.result(urlSpecSize, 10 seconds)
println(size)

Concurrent Programming with
Reactive Extensions

val observable: Observable[String] = Observable.items("A", "B", "C")
observable.subscribe(str => println(str.toLowerCase))
observable.subscribe(str => println(str * 7))

val o: Observable[Long] = Observable.timer(2 second)
o.subscribe(x => println(x))
o.subscribe(x => println(x + 1000))

val ex = new RuntimeException
val observable: Observable[Int] = Observable.items(0, 1, 2) ++
Observable.error(ex) ++
Observable.items(3, 4)
observable.subscribe(
value => println(value),
error => println(s"an error occurred: $error")
)

val countries = List("Germany", "US", "Japan")
val observable = Observable.from(countries)
observable.subscribe(new Observer[String] {
override def onNext(c: String) = println(s"Nice to live in $c”)
override def onError(e: Throwable) = println(“error!!!")
override def onCompleted() = println("That all list!")
})

// def create(f: Observer[T] => Subscription): Observable[T]
val vms = Observable.apply[String] { obs =>
obs.onNext("JVM")
obs.onNext("LLVM")
obs.onNext("Dalvik")
obs.onCompleted()
Subscription
}
vms.subscribe(str => println(str))
}

val f = Future("Future")
val observable = Observable.apply[String] { obs =>
f onComplete {
case Success(v) => {
obs.onNext(v)
obs.onCompleted()
}
case Failure(e) => {
obs.onError(e)
}
}
Subscription
}
observable.subscribe(str => println(str))

def coldObserver(directory: String): Observable[String] = {
Observable.apply[String] { obs =>
val fileMonitor = new FileAlterationMonitor(1000)
val fileObs = new FileAlterationObserver(directory)
val fileListener = new FileAlterationListenerAdaptor {
override def onFileChange(file: java.io.File): Unit = {
obs.onNext(file.getName)
}
}
fileObs.addListener(fileListener)
fileMonitor.addObserver(fileObs)
fileMonitor.start()
Subscription {
fileMonitor.stop()
}
}
}

def hotObserver(directory: String): Observable[String] = {
val fileMonitor = new FileAlterationMonitor(1000)
val fileObs = new FileAlterationObserver(directory)
fileMonitor.addObserver(fileObs)
Observable.apply[String] { obs =>
val fileListener = new FileAlterationListenerAdaptor {
override def onFileChange(file: java.io.File): Unit = {
obs.onNext(file.getName)
}
}
fileObs.addListener(fileListener)
Subscription { fileObs.removeListener(
fileListener) }
}
}

val odds = Observable.interval(0.5 seconds)
.filter(x => x % 2 == 1)
.map(x => s"num $x")
.take(5)
odds.subscribe(str => println(str))

def fetchQuote(): Future[String] = Future {
blocking {
val url = “http://www.iheartquotes.com/api/v1/random?" + "show_permalink=false&show_source=false"
Source.fromURL(url).getLines().mkString
}
}
def fetchQuoteObservable(): Observable[String] = {
Observable.from(fetchQuote())
}
def quotes(): Observable[Observable[String]] = {
Observable.interval(1 second).take(5).map {
n => fetchQuoteObservable().map(txt => s"$n) $txt")
}
}
val concat: Observable[String] = quotes().concat
concat.subscribe(q => println(q)) /
val flatten: Observable[String] = quotes().flatten //
val qs: Observable[String] = for {
n <- Observable.interval(1 second).take(5)
txt <- fetchQuoteObservable()
} yield s"$n) $txt"
qs.subscribe(q => println(q))

def randomQuote() = Observable.apply[String] {
obs =>
val url = "http://www.iheartquotes.com/api/v1/random?" +
"show_permalink=false&show_source=false"
obs.onNext(Source.fromURL(url).getLines.mkString)
obs.onCompleted()
Subscription
}
import Observable._
def errorMessage = items("Retrying...") ++ error(new Exception)
def quoteMessage(): Observable[String] = for {
text <- randomQuote()
message <- if (text.size < 50) items(text)
else errorMessage
} yield message
quoteMessage().retry(5).subscribe(str => println(str))

val status = Observable.items("1", "2") ++ Observable.error(new Exception)
val fixedStatus = status.onErrorReturn(e => "exception")
fixedStatus.subscribe(str => println(str))
val continuedStatus = status.onErrorResumeNext(e =>
Observable.items("4", "5"))
continuedStatus.subscribe(str => println(str))

Concurrent Application Development using Scala

Concurrent Application Development using Scala

More Related Content

What's hot (20)

Similar to Concurrent Application Development using Scala (20)

Recently uploaded (20)

Concurrent Application Development using Scala