SCALA-46 A Comprehensive Guide to For-comprehension in Scala

core-scala/src/main/java/com/baedung/scala/forcomprehension/ForComprehension.java

@@ -0,0 +1,57 @@
+package com.baedung.scala.forcomprehension;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ForComprehension {
+    public static void main(String[] args) {
+        final List<TestResult> results =
+                Arrays.asList(
+                        new TestResult("test 1",10, 10),
+                        new TestResult("test 2",2, 6)
+                );
+        int totalPassedAssertsInSucceededTests = 0;
+        for (int i = 0; i < results.size(); i++) {
+            final TestResult result = results.get(i);
+            if (result.isSucceeded()) {
+                totalPassedAssertsInSucceededTests += result.getSuccessfulAsserts();
+            }
+        }
+
+        final long totalPassedAssertsInSucceededTests1 =
+                results.stream()
+                        .filter(TestResult::isSucceeded)
+                        .mapToInt(TestResult::getSuccessfulAsserts)
+                        .sum();
+    }
+
+    private static class TestResult {
+        private String id;
+        private boolean succeeded;
+        private int successfulAsserts;
+        private int totalAsserts;
+
+        public TestResult(String id, int successfulAsserts, int totalAsserts) {
+            this.id = id;
+            this.succeeded = successfulAsserts == totalAsserts;
+            this.successfulAsserts = successfulAsserts;
+            this.totalAsserts = totalAsserts;
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        public boolean isSucceeded() {
+            return succeeded;
+        }
+
+        public int getSuccessfulAsserts() {
+            return successfulAsserts;
+        }
+
+        public int getTotalAsserts() {
+            return totalAsserts;
+        }
+    }
+}

core-scala/src/main/scala/com/baeldung/scala/forcomprehension/ForComprehension.scala

@@ -0,0 +1,62 @@
+package com.baeldung.scala.forcomprehension
+
+object ForComprehension {
+
+  val results = List(TestResult("test 1", 10, 10), TestResult("test 2", 2, 6))
+  val executionTimeList = List(("test 1", 100), ("test 2", 230))
+  val listOfPassedAssertsInSucceededTests: List[Int] =
+    for {
+      result <- results
+      if result.succeeded
+    } yield result.successfulAsserts
+  val passedAssertsInSucceededTests: Int = listOfPassedAssertsInSucceededTests.sum
+
+  val numberOfAssertsWithExecutionTime: List[(String, Int, Int)] =
+    for {
+      result <- results
+      (id, time) <- executionTimeList
+      if result.id == id
+    } yield (id, result.totalAsserts, time)
+
+  val hugeNumberOfAssertsForATest: Int = 10
+  val resultsWithAHugeAmountOfAsserts: List[TestResult] =
+    for {
+      result <- results
+      if result.totalAsserts >= hugeNumberOfAssertsForATest
+    } yield result
+
+  case class TestResult(id: String, successfulAsserts: Int, totalAsserts: Int) {
+    def succeeded: Boolean = successfulAsserts == totalAsserts
+  }
+
+  val result: Result[Int] = Result(42)
+  for {
+    res <- result
+  } println(s"The result is $res")
+
+  val magic: Int = 42
+  for {
+    res <- result
+  } yield res * magic
+
+  val anotherResult: Result[Int] = Result(10)
+  result
+    .flatMap(res =>
+      anotherResult
+        .map(another => res + another)
+    )
+
+  for {
+    res <- result
+    if res == 10
+  } yield res
+
+  case class Result[A](result: A) {
+    def foreach(f: A => Unit): Unit = f(result)
+    def map[B](f: A => B): Result[B] = Result(f(result))
+    def flatMap[B](f: A => Result[B]): Result[B] = f(result)
+    def withFilter(f: A => Boolean): Result[_] = if (f(result)) this else EmptyResult
+  }
+
+  object EmptyResult extends Result[Null](null)
+}