AF [SCALA-16] - For loops in Scala

Author: Andrey Filyanin

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

@@ -0,0 +1,91 @@
+package com.baeldung.scala.forcomprehension
+
+trait ForLoop {
+  // We are defining a println in a separate function in order to be able to test our iterations
+  def sideEffectFunction(arg: Any) = println(arg)
+
+  // Iterating an exclusive Range
+  def iterateRangeTo (rangeTo: Range): Unit = {
+    for (num <- rangeTo) {
+      sideEffectFunction(num)
+    }
+  }
+
+  // Iterating an inclusive Range
+  def iterateRangeUntil (rangeUntil: Range): Unit = {
+    for (num <- rangeUntil) {
+      sideEffectFunction(num)
+    }
+  }
+
+  // Iterating the Ranges as multiple generators
+  def multipleGenerators (rangeTo: Range, rangeUntil: Range): Unit = {
+    for {
+      i <- rangeTo
+      j <- rangeUntil
+    } {
+      sideEffectFunction(s"$i, $j")
+    }
+  }
+
+  // Iterating a Sequence of Strings
+  def iterateCollection (colors: Seq[String]): Unit = {
+    for (color <- colors) {
+      sideEffectFunction(color)
+    }
+  }
+
+  // Iterating a Sequences of Strings, with multiple generators
+  def iterateCollectionWithMultipleGenerators (colors: Seq[String]): Unit = {
+    for (c1 <- colors; c2 <- colors; c3 <- colors) {
+      sideEffectFunction(s"$c1$c2$c3 ")
+    }
+  }
+
+  // Iterating a Sequences of Strings, with multiple generators and guards
+  def iterateCollectionsWithGuards(colors: Seq[String]): Unit = {
+    for {
+      c1 <- colors
+      c2 <- colors
+      if c2 != c1
+      c3 <- colors
+      if c3 != c2 && c3 != c1
+    } {
+      sideEffectFunction(s"$c1$c2$c3 ")
+    }
+  }
+
+  def iterateMap  (map: Map[String, String]): Unit = {
+    for ((key,value) <- map) {
+      sideEffectFunction(s"""$key is for $value""")
+    }
+  }
+
+  def iterateMapMultipleGenerators (deck: Map[String, List[String]]): Unit = {
+    for {
+      (suit, cards) <- deck
+      card <- cards
+    } {
+      sideEffectFunction(s"""$card of $suit""")
+    }
+  }
+
+  def pureIteration (numbers: List[Int]): List[String] = {
+    for (number <- numbers) yield {
+      s"""$number + $number = ${number + number}"""
+    }
+  }
+
+  def forComprehensionWithOptionals (someIntValue: Option[Int], someStringValue: Option[String]): Option[String] = {
+    for {
+      intValue <- someIntValue
+      stringValue <- someStringValue
+    } yield {
+      s"""$intValue is $stringValue"""
+    }
+  }
+
+  def mapOptionals (someIntValue: Option[Int], someStringValue: Option[String]): Option[String] = {
+    someIntValue.flatMap(intValue => someStringValue.map(stringValue => s"""$intValue is $stringValue"""))
+  }
+}

core-scala/src/test/scala/com/baeldung/scala/forcomprehension/ForLoopTest.scala

@@ -0,0 +1,109 @@
+package com.baeldung.scala.forcomprehension
+
+import org.junit.Assert.assertEquals
+import org.junit.{Before, Test}
+
+class ForLoopImplementation extends ForLoop {
+  var sideEffectResult: Seq[Any] = Nil
+  override def sideEffectFunction (arg: Any): Unit = {
+    sideEffectResult = sideEffectResult :+ arg
+  }
+
+  def clean(): Unit = {
+    sideEffectResult = Nil;
+  }
+}
+
+class ForLoopTest {
+  val forLoopTest = new ForLoopImplementation
+  val rangeTo: Range = 1 to 3
+  val rangeUntil: Range = 1 until 3
+  val colors = Seq("R", "G", "B")
+  val map = Map("R" -> "Red", "G" -> "Green", "B" -> "Blue")
+  val deck = Map("♣" -> List("A", "K", "Q"),
+                 "♦" -> List("J", "10"),
+                 "♥" -> List("9", "8", "7"),
+                 "♠" -> List("A", "K", "J", "6"))
+  val numbers = List(1, 2, 3)
+  val someIntValue: Option[Int] = Some(10)
+  val someStringValue: Option[String] = Some("Ten")
+  
+  @Before
+  def init(): Unit = {
+    forLoopTest.clean()
+  }
+
+  @Test
+  def iterateRangeToTest (): Unit = {
+    forLoopTest.iterateRangeTo(rangeTo)
+    val expected = Seq(1, 2, 3)
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateRangeUntilTest (): Unit = {
+    forLoopTest.iterateRangeUntil(rangeUntil)
+    val expected = Seq(1, 2)
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def multipleGeneratorsTest (): Unit = {
+    forLoopTest.multipleGenerators(rangeTo, rangeUntil)
+    val expected = Seq("1, 1", "1, 2", "2, 1", "2, 2", "3, 1", "3, 2")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateCollectionTest (): Unit = {
+    forLoopTest.iterateCollection(colors)
+    val expected = Seq("R", "G", "B")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateCollectionWithMultipleGeneratorsTest (): Unit = {
+    forLoopTest.iterateCollectionWithMultipleGenerators(colors)
+    val expected = List("RRR ", "RRG ", "RRB ", "RGR ", "RGG ", "RGB ", "RBR ", "RBG ", "RBB ", "GRR ", "GRG ", "GRB ", "GGR ", "GGG ", "GGB ", "GBR ", "GBG ", "GBB ", "BRR ", "BRG ", "BRB ", "BGR ", "BGG ", "BGB ", "BBR ", "BBG ", "BBB ")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateCollectionsWithGuardsTest (): Unit = {
+    forLoopTest.iterateCollectionsWithGuards(colors)
+    val expected = List("RGB ", "RBG ", "GRB ", "GBR ", "BRG ", "BGR ")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateMapTest (): Unit = {
+    forLoopTest.iterateMap(map)
+    val expected = List("R is for Red", "G is for Green", "B is for Blue")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def iterateMapMultipleGeneratorsTest (): Unit = {
+    forLoopTest.iterateMapMultipleGenerators(deck)
+    val expected = List("A of ♣", "K of ♣", "Q of ♣", "J of ♦", "10 of ♦", "9 of ♥", "8 of ♥", "7 of ♥", "A of ♠", "K of ♠", "J of ♠", "6 of ♠")
+    assertEquals(expected, forLoopTest.sideEffectResult)
+  }
+
+  @Test
+  def pureIterationTest (): Unit = {
+    val result = forLoopTest.pureIteration(numbers)
+    val expected = List("1 + 1 = 2", "2 + 2 = 4", "3 + 3 = 6")
+    assertEquals(expected, result)
+  }
+
+  @Test
+  def forComprehensionWithOptionalsTest (): Unit = {
+
+    val resultFor = forLoopTest.forComprehensionWithOptionals(someIntValue, someStringValue)
+    val resultMap = forLoopTest.mapOptionals(someIntValue, someStringValue)
+    val expected = Some("10 is Ten")
+    assertEquals(expected, resultFor)
+    assertEquals(expected, resultMap)
+    assertEquals(resultFor, resultMap)
+  }
+}