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

Similar to Concurrent Application Development using Scala

Recently uploaded

Concurrent Application Development using Scala