added new examples

Author: TofigBakhshiyev

README.md

@@ -0,0 +1,2 @@
+## Scala Concurrent Learn
+Learn about scala futures and promises, concurrent programming

src/main/scala/FuturesAndPromises/ExampleExecutionContext.scala

@@ -0,0 +1,29 @@
+package FuturesAndPromises
+
+import java.util.concurrent.Executors
+import scala.concurrent.Future
+import scala.util.{Failure, Success}
+
+/**
+ * Example for creating single thread
+ * */
+object ExampleExecutionContext {
+  def main(args: Array[String]): Unit = {
+    // defining single thread
+    val executor = Executors.newSingleThreadExecutor()
+
+    implicit val ec = scala.concurrent.ExecutionContext.fromExecutorService(executor)
+
+    def simpleFuture(): Future[Int] =
+      Future.successful(10)
+
+    simpleFuture onComplete {
+      case Success(result) =>
+        println(s"Result: ${result}")
+      case Failure(e) =>
+        println(s"error: ${e}")
+    }
+
+    Thread.sleep(100)
+  }
+}

src/main/scala/FuturesAndPromises/ExampleFutureRecover.scala

@@ -0,0 +1,39 @@
+package FuturesAndPromises
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.util.{Failure, Success}
+
+/**
+ * Recovering error message
+ * */
+object ExampleFutureRecover {
+  def main(args: Array[String]): Unit = {
+    def checkIsBig(number: Int): Future[Int] =
+      if (number > 0) Future.successful(10) else throw new IllegalStateException("number is negative")
+
+    checkIsBig(-1)
+      .recover{ case error: IllegalStateException if error.getMessage == "number is negative" => 0 }
+      .onComplete {
+        case Success(result) =>
+          println(s"Result: $result")
+        case Failure(e) =>
+          println(s"error: ${e}")
+      }
+
+    // recoverWith,
+    // Call Future.recoverWith to recover from a known exception
+    checkIsBig(-1)
+      .recoverWith{
+        case error: IllegalStateException if error.getMessage == "number is negative" =>
+          Future.successful(0)
+      }
+      .onComplete{
+        case Success(result) =>
+          println(s"Result: $result")
+        case Failure(e) =>
+          println(s"error: ${e}")
+      }
+    Thread.sleep(100)
+  }
+}

src/main/scala/FuturesAndPromises/ExampleFutureThen.scala

@@ -0,0 +1,25 @@
+package FuturesAndPromises
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+
+/**
+ *  andThen() is used,
+ *  whenever you have a need to apply a side-effect function on the result returned by the future
+ * */
+object ExampleFutureThen {
+  def main(args: Array[String]): Unit = {
+    def check(item: String): Future[Int] =
+      if (item.length > 0) Future.successful(item.length) else Future.successful(0)
+
+    val futureThen = check("key")
+
+    // Call Future.andThen with a PartialFunction
+    futureThen.andThen {
+      case result =>
+        println(s"Result: ${result}")
+    }
+
+    Thread.sleep(100)
+  }
+}

src/main/scala/FuturesAndPromises/ExampleFutureZip.scala

@@ -0,0 +1,46 @@
+package FuturesAndPromises
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.util.{Failure, Success}
+
+/**
+ * The Future.zip will create a new future,
+ * whose return type will be a tuple holding the return types of the two futures
+ * */
+object ExampleFutureZip {
+  def main(args: Array[String]): Unit = {
+    def item(): Future[String] = Future.successful("apple")
+    def price(): Future[Double] = Future.successful(9.99)
+
+    // zip item with price
+    val zippedFuture = item zip price
+
+    zippedFuture onComplete {
+      case Success(result) =>
+        println(s"Result: ${result}")
+      case Failure(e) =>
+        println(s"Error: ${e}")
+    }
+
+    // zipWith, difference is that,
+    // the zipWith() method allows you to pass-through a function which can be applied to the results
+    def itemWith(i: String): Future[Option[String]] = {
+      Future(
+        Some(i)
+      )
+    }
+
+    val future: (Option[String], Double) => (String, Double) = (some, price) => (some.getOrElse(""), price)
+    val futureZipWith = itemWith("apple-1").zipWith(price())(future)
+
+    futureZipWith onComplete {
+      case Success(result) =>
+        println(s"Result: ${result}")
+      case Failure(e) =>
+        println(s"Error: ${e}")
+    }
+
+    Thread.sleep(100)
+  }
+}

src/main/scala/FuturesAndPromises/ScalaFuture.scala

@@ -39,5 +39,11 @@ object ScalaFuture {
       println("Handling Future with map")
       println(s"Sum: ${answer}")
     }
+
+    // print with foreach
+    add(7, 10).foreach{ answer =>
+      println("Handling Future with foreach")
+      println(s"Sum: ${answer}")
+    }
   }
 }