aded new examples

Author: TofigBakhshiyev

.gitignore

@@ -1,5 +1,5 @@
-idea/
+.idea
 
-target/
+target
 
-project/
+project

src/main/scala/FuturesAndPromises/ExampleFoldLeft.scala

@@ -0,0 +1,47 @@
+package FuturesAndPromises
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.util.{Failure, Success}
+
+/**
+ * The foldLeft on your future operations will be run asynchronously from left to right.
+ * */
+object ExampleFoldLeft {
+  def checkIsBig(input: Int): Future[Option[Int]] = {
+    Future(
+      if (input > 0) {
+        Some(20)
+      } else {
+        None
+      }
+    )
+  }
+
+  def main(args: Array[String]): Unit = {
+    val futures = List(
+      checkIsBig(1),
+      checkIsBig(-1),
+      checkIsBig(8),
+      checkIsBig(9),
+      checkIsBig(11),
+      checkIsBig(7)
+    )
+
+    // Future.foldLeft to fold over futures results from left to right
+    // pass a valid quantity or a default value of zero to the accumulator
+    val futureFoldLeft = Future.foldLeft(futures)(0) {
+      case (accumulator, some) =>
+        accumulator + some.getOrElse(0)
+    }
+
+    futureFoldLeft onComplete {
+      case Success(results) =>
+        println(s"Aggregate result: $results")
+      case Failure(e) =>
+        println(s"Error processing future operations, error = ${e.getMessage}")
+    }
+
+    Thread.sleep(100)
+  }
+}

src/main/scala/FuturesAndPromises/ExampleReduceLeft.scala

@@ -0,0 +1,48 @@
+package FuturesAndPromises
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
+import scala.util.{Failure, Success}
+
+/**
+ * Scala also provides a Future.reduceLeft() function which has a similar behaviour.
+ * Unlike foldLeft(), however, reduceLeft() does not allow you to provide a default value
+ * */
+object ExampleReduceLeft {
+  def checkIsBig(input: Int): Future[Option[Int]] = {
+    Future(
+      if (input > 0) {
+        Some(20)
+      } else {
+        None
+      }
+    )
+  }
+
+  def main(args: Array[String]): Unit = {
+    val futures = List(
+      checkIsBig(1),
+      checkIsBig(-1),
+      checkIsBig(8),
+      checkIsBig(9),
+      checkIsBig(11),
+      checkIsBig(7)
+    )
+
+    // Call Future.reduceLeft to fold over futures results from left to right
+    // we cannot provide a default value and hence the accumulator is of type Option[Int]
+    val futureFoldLeft = Future.reduceLeft(futures) {
+      case (accumulator, some) =>
+        accumulator.map(result => result + some.getOrElse(0))
+    }
+
+    futureFoldLeft onComplete {
+      case Success(results) =>
+        println(s"Aggregate result: $results")
+      case Failure(e) =>
+        println(s"Error processing future operations, error = ${e.getMessage}")
+    }
+
+    Thread.sleep(100)
+  }
+}