Merge branch 'master' of github.com:baeldung/scala-tutorials into SCALA-24

Author: ramkumarvenkat

core-scala/src/main/scala/com/baeldung/scala/LazyVal.scala

@@ -0,0 +1,62 @@
+package com.baeldung.scala
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent._
+import scala.concurrent.duration._
+
+class LazyVal {
+
+  var age = 27
+
+  lazy val getMemberNo = {
+    age = age + 1
+    8
+  }
+}
+
+object FirstObj {
+  lazy val initialState = 42
+  lazy val start = SecondObj.initialState
+}
+
+object SecondObj {
+  lazy val initialState = FirstObj.initialState
+}
+
+object Deadlock extends App {
+  def run = {
+    val result = Future.sequence(Seq(
+      Future {
+        FirstObj.start
+      },
+      Future {
+        SecondObj.initialState
+      }))
+    Await.result(result, 10.second)
+  }
+
+  run
+}
+
+object LazyValStore {
+
+  lazy val squareOf5 = square(5)
+  lazy val squareOf6 = square(6)
+
+  def square(n: Int): Int = n * n
+}
+
+object SequentialLazyVals extends App {
+  def run = {
+    val futures = Future.sequence(Seq(
+      Future {
+        LazyValStore.squareOf5
+      },
+      Future {
+        LazyValStore.squareOf6
+      }))
+    Await.result(futures, 5.second)
+  }
+
+  run.foreach(println)
+}

core-scala/src/main/scala/com/baeldung/scala/User.scala

@@ -0,0 +1,26 @@
+package com.baeldung.scala
+
+class User(val name: String, val age: Int)
+
+object User {
+  def apply(name: String, age: Int) = new User(name, age)
+
+  def apply(name: String) = new User(name, 0)
+
+  def unapply(u: User): Option[(String, Int)] = Some(u.name, u.age)
+}
+
+object UserMainApp extends App {
+  val user1: User = new User("John", 25)
+  val user2: User = User.apply("John", 25)
+  val user3: User = User("John", 25)
+
+  val userArgs: Option[(String, Int)] = User.unapply(user1)
+
+  user1 match {
+    case User(_, age) if age < 18 =>
+      println("You are not allowed to get a driver license.")
+    case User(_, age) if age >= 18 =>
+      println("You are allowed to get a driver's license.")
+  }
+}

core-scala/src/main/scala/com/baeldung/scala/partialfunctions/SquareRoot.scala

@@ -0,0 +1,12 @@
+package com.baeldung.scala.partialfunctions
+
+object SquareRoot {
+  val squareRoot = new PartialFunction[Double, Double] {
+    def apply(x: Double) = Math.sqrt(x)
+    def isDefinedAt(x: Double) = x >= 0
+  }
+
+  val squareRootImplicit: PartialFunction[Double, Double] = {
+    case x if x >= 0 => Math.sqrt(x)
+  }
+}

core-scala/src/main/scala/com/baeldung/scala/partialfunctions/SwapIntegerSign.scala

@@ -0,0 +1,20 @@
+package com.baeldung.scala.partialfunctions
+
+object SwapIntegerSign {
+
+  private val negativeOrZeroToPositive: PartialFunction[Int, Int] = {
+    case x if x <= 0 => Math.abs(x)
+  }
+
+  private val positiveToNegative: PartialFunction[Int, Int] = {
+    case x if x > 0 => -1 * x
+  }
+
+  val swapSign: PartialFunction[Int, Int] = {
+    positiveToNegative orElse negativeOrZeroToPositive
+  }
+
+  val printIfPositive: PartialFunction[Int, Unit] = {
+    case x if x > 0 => println(s"$x is positive!")
+  }
+}

core-scala/src/test/scala/com/baeldung/scala/LazyValUnitTest.scala

@@ -0,0 +1,43 @@
+package com.baeldung.scala
+
+import org.scalatest.FunSuite
+import org.scalatest.Matchers._
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+import scala.concurrent.{Future, _}
+import com.baeldung.scala
+
+class LazyValUnitTest extends FunSuite {
+
+  test("lazy val is computed only once") {
+    //given
+    val lazyVal = new LazyVal
+    lazyVal.getMemberNo //initialize the lazy val
+    lazyVal.age shouldBe 28
+
+    //when
+    lazyVal.getMemberNo
+
+    //then
+    lazyVal.age shouldBe 28
+  }
+
+  test("lazy vals should execute sequentially in an instance ") {
+    //given
+    val futures = Future.sequence(Seq(
+      Future {
+        scala.LazyValStore.squareOf5
+      },
+      Future {
+        scala.LazyValStore.squareOf6
+      }))
+
+    //when
+    val result = Await.result(futures, 5.second)
+
+    //then
+    result should contain(25)
+    result should contain(36)
+  }
+}

core-scala/src/test/scala/com/baeldung/scala/currying/CurryingUnitTest.scala

@@ -0,0 +1,110 @@
+package com.baeldung.scala.currying
+
+import org.junit.Test
+import org.scalatest.Matchers
+
+class CurryingUnitTest extends Matchers {
+
+  @Test
+  def givenMultipleArgumentsFunction_whenCurried_thenReturnCurriedFunction() {
+    val sum: (Int, Int) => Int = (x, y) => x + y
+    val curriedSum: Int => Int => Int = sum.curried
+
+    sum(1, 2) shouldBe 3
+    curriedSum(1)(2) shouldBe 3
+  }
+
+  @Test
+  def givenMultipleArgumentsMethod_whenCurried_thenReturnCurriedFunction() {
+    def sum(x: Int, y: Int): Int = x + y
+
+    val curriedSum: Int => Int => Int = (sum _).curried
+
+    sum(1, 2) shouldBe 3
+    curriedSum(1)(2) shouldBe 3
+  }
+
+  @Test
+  def givenMultipleArgumentListsMethod_whenCurried_thenReturnCurriedFunction() {
+    def sum(x: Int)(y: Int): Int = x + y
+
+    val curriedSum: Int => Int => Int = sum
+
+    sum(1)(2) shouldBe 3
+    curriedSum(1)(2) shouldBe 3
+  }
+
+  @Test
+  def givenCurriedFunction_whenPartialApplied_thenReturnLowerArityFunction() {
+    val sum: Int => Int => Int = x => y => x + y
+    val increment: Int => Int = sum(1)
+
+    increment(1) shouldBe 2
+  }
+
+  @Test
+  def givenMultipleArgumentListsMethod_whenPartialApplied_thenReturnLowerArityMethod() {
+    def sum(x: Int)(y: Int): Int = x + y
+
+    val increment: Int => Int = sum(1)
+
+    increment(1) shouldBe 2
+  }
+
+  @Test
+  def givenMultipleArgumentsFindMethod_whenCalled_thenPredicateFunctionNeedsExplicitType() {
+    def find[A](xs: List[A], predicate: A => Boolean): Option[A] = {
+      xs match {
+        case Nil => None
+        case head :: tail =>
+          if (predicate(head)) Some(head) else find(tail, predicate)
+      }
+    }
+
+    find(List(1, 2, 3), (x: Int) => x % 2 == 0) shouldBe Some(2)
+  }
+
+  @Test
+  def givenMultipleArgumentListFindMethod_whenCalled_thenPredicateFunctionDoesNotNeedExplicitType() {
+    def find[A](xs: List[A])(predicate: A => Boolean): Option[A] = {
+      xs match {
+        case Nil => None
+        case head :: tail =>
+          if (predicate(head)) Some(head) else find(tail)(predicate)
+      }
+    }
+
+    find(List(1, 2, 3))(x => x % 2 == 0) shouldBe Some(2)
+  }
+
+  @Test
+  def givenGenericMultipleArgumentListSumMethod_whenPartialApplied_thenReturnSimpleMethods() {
+    def sumF(f: Int => Int)(x: Int, y: Int): Int = f(x) + f(y)
+    val sum: (Int, Int) => Int = sumF(identity)
+    val sumSquare: (Int, Int) => Int = sumF(x => x * x)
+    val increment: Int => Int = sum.curried(1)
+    val decrement: Int => Int = sum.curried(-1)
+
+    sum(1, 2) shouldBe 3
+    sumSquare(1, 2) shouldBe 5
+    increment(2) shouldBe 3
+    decrement(2) shouldBe 1
+  }
+
+  @Test
+  def givenMultipleArgumentsFunction_whenUseItAsOneArgumentFunction_thenNeedsExplicitArgumentPassing() {
+    val sum: (Int, Int) => Int = (x, y) => x + y
+    val numbers: List[Int] = List(1, 2, 3)
+
+    numbers.map(n => sum(1, n)) shouldBe List(2, 3, 4)
+  }
+
+  @Test
+  def givenCurriedFunction_whenUseItAsOneArgumentFunction_thenDoesNotNeedExplicitArgumentPassing() {
+    val curriedSum: Int => Int => Int = x => y => x + y
+    val numbers: List[Int] = List(1, 2, 3)
+
+    numbers.map(curriedSum(1)) shouldBe List(2, 3, 4)
+  }
+
+}

core-scala/src/test/scala/com/baeldung/scala/partialfunctions/SquareRootUnitTest.scala

@@ -0,0 +1,24 @@
+package com.baeldung.scala.partialfunctions
+
+import org.scalatest.FlatSpec
+
+class SquareRootUnitTest extends FlatSpec {
+
+  "SquareRoot" should "return the correct value for positive double" in {
+    assert(SquareRoot.squareRoot(4.0) == 2.0)
+  }
+
+  it should "return NaN for a negative double" in {
+    assert(SquareRoot.squareRoot(-4.0).equals(Double.NaN))
+  }
+
+  "SquareRootImplicit" should "return the correct value for a positive double" in {
+    assert(SquareRoot.squareRootImplicit(4.0) == 2.0)
+  }
+
+  it should "throw a 'scala.MatchError' exception" in {
+    assertThrows[scala.MatchError] {
+      SquareRoot.squareRootImplicit(-4.0)
+    }
+  }
+}

core-scala/src/test/scala/com/baeldung/scala/partialfunctions/SwapIntegerSignUnitTest.scala

@@ -0,0 +1,38 @@
+package com.baeldung.scala.partialfunctions
+
+import org.scalatest.FlatSpec
+
+class SwapIntegerSignUnitTest extends FlatSpec {
+
+  "swapSign" should "return a positive number when a negative is given" in {
+    assert(SwapIntegerSign.swapSign(-3) == 3)
+  }
+
+  it should "return a negative number when a positive is given" in {
+    assert(SwapIntegerSign.swapSign(3) == -3)
+  }
+
+  "printIfPositive" should "print a positive number" in {
+    assert(SwapIntegerSign.printIfPositive(3).getClass == classOf[Unit])
+  }
+
+  it should "throw a 'scala.MatchError' exception given a negative number" in {
+    assertThrows[scala.MatchError] {
+      SwapIntegerSign.printIfPositive(-3)
+    }
+  }
+
+  "swapSign andThen printIfPositive" should "chain and print a positive number" in {
+    assert(
+      (SwapIntegerSign.swapSign andThen SwapIntegerSign.printIfPositive)(-1).getClass == classOf[
+        Unit
+      ]
+    )
+  }
+
+  it should "chain and throw a 'scala.MatchError' exception given a negative number" in {
+    assertThrows[scala.MatchError] {
+      (SwapIntegerSign.swapSign andThen SwapIntegerSign.printIfPositive)(1)
+    }
+  }
+}