BAEL-2041 Introduction To Scala

core-scala/pom.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-scala</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>${scala.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <sourceDirectory>src/main/scala</sourceDirectory>
+        <testSourceDirectory>src/test/scala</testSourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>net.alchim31.maven</groupId>
+                <artifactId>scala-maven-plugin</artifactId>
+                <version>3.3.2</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>compile</goal>
+                            <goal>testCompile</goal>
+                        </goals>
+                        <configuration>
+                            <args>
+                                <arg>-dependencyfile</arg>
+                                <arg>${project.build.directory}/.scala_dependencies</arg>
+                            </args>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <scala.version>2.11.8</scala.version>
+    </properties>
+</project>
+

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

@@ -0,0 +1,10 @@
+package com.baeldung.scala
+
+class Employee(val name: String, var salary: Int, annualIncrement: Int = 20) extends AnyRef {
+
+    def incrementSalary(): Unit = {
+        salary += annualIncrement
+    }
+
+    override def toString = s"Employee(name=$name, salary=$salary)"
+}

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

@@ -0,0 +1,6 @@
+package com.baeldung.scala
+
+object HelloWorld extends App {
+    println("Hello World!")
+    args foreach println
+}

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

@@ -0,0 +1,14 @@
+
+
+package com.baeldung.scala
+
+object HigherOrderFunctions {
+
+    def mapReduce(r: (Int, Int) => Int, i: Int, m: Int => Int, a: Int, b: Int) = {
+        def iter(a: Int, result: Int): Int = {
+            if (a > b) result
+            else iter(a + 1, r(m(a), result))
+        }
+        iter(a, i)
+    }
+}

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

@@ -0,0 +1,66 @@
+package com.baeldung.scala
+
+object Utils {
+    def average(x: Double, y: Double) = (x + y) / 2
+
+    def gcd(x: Int, y: Int): Int = {
+        if (y == 0) x else gcd(y, x % y)
+    }
+
+    def gcdIter(x: Int, y: Int): Int = {
+        var a = x
+        var b = y
+        while (b > 0) {
+            a = a % b
+            val t = a
+            a = b
+            b = t
+        }
+        return a
+    }
+
+    def rangeSum(a: Int, b: Int) = {
+        var sum = 0;
+        for (i <- a to b) {
+            sum += i
+        }
+        sum
+    }
+
+    def factorial(a: Int): Int = {
+        var result = 1;
+        var i = a;
+        do {
+            result *= i
+            i = i - 1
+        } while (i > 0)
+        result
+    }
+
+    def randomLessThan(d: Double) = {
+        var random = 0d
+        do {
+            random = Math.random()
+        } while (random >= d)
+        random
+    }
+
+    def whileLoop(condition: => Boolean)(body: => Unit): Unit =
+        if (condition) {
+            body
+            whileLoop(condition)(body)
+        }
+
+    def power(x: Int, y: Int): Int = {
+        def powNested(i: Int, accumulator: Int): Int = {
+            if (i <= 0) accumulator
+            else powNested(i - 1, x * accumulator)
+        }
+        powNested(y, 1)
+    }
+
+    def fibonacci(n: Int): Int = n match {
+        case 0 | 1      => 1
+        case x if x > 1 => fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.baeldung.scala
+
+import org.junit.Test
+import org.junit.Assert._
+
+class EmployeeUnitTest {
+
+    @Test
+    def whenEmployeeSalaryIncremented_thenCorrectSalary() = {
+        val employee = new Employee("John Doe", 1000);
+        employee.incrementSalary();
+        assertEquals(1020, employee.salary);
+    }
+
+    @Test
+    def givenEmployee_whenToStringCalled_thenCorrectStringReturned() = {
+        val employee = new Employee("John Doe", 1000);
+        assertEquals("Employee(name=John Doe, salary=1000)", employee.toString);
+    }
+}
+
+

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

@@ -0,0 +1,44 @@
+package com.baeldung.scala
+
+import org.junit.Test
+import org.junit.Assert._
+import HigherOrderFunctions._
+
+class HigherOrderFunctionsUnitTest {
+
+    @Test
+    def whenCalledWithSumAndSquareFunctions_thenCorrectValueReturned = {
+        def square(x: Int) = x * x
+
+        def sum(x: Int, y: Int) = x + y
+
+        def sumSquares(a: Int, b: Int) =
+            mapReduce(sum, 0, square, a, b)
+
+        val n = 10
+        val expected = n * (n + 1) * (2 * n + 1) / 6
+        assertEquals(expected, sumSquares(1, n));
+    }
+
+    @Test
+    def whenComputingSumOfSquaresWithAnonymousFunctions_thenCorrectValueReturned = {
+        def sumSquares(a: Int, b: Int) =
+            mapReduce((x, y) => x + y, 0, x => x * x, a, b)
+
+        val n = 10
+        val expected = n * (n + 1) * (2 * n + 1) / 6
+        assertEquals(expected, sumSquares(1, n));
+    }
+
+    @Test
+    def givenCurriedFunctions_whenInvoked_thenCorrectValueReturned = {
+        def sum(f: Int => Int)(a: Int, b: Int): Int =
+            if (a > b) 0 else f(a) + sum(f)(a + 1, b)
+
+        def mod(n: Int)(x: Int) = x % n
+
+        def sumMod5 = sum(mod(5)) _
+        
+        assertEquals(10, sumMod5(6,10));
+    }
+}

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

@@ -0,0 +1,50 @@
+package com.baeldung.scala
+
+import org.junit.Test
+import Utils._
+import org.junit.Assert._
+
+class UtilsUnitTest {
+
+    @Test
+    def whenAverageCalled_thenCorrectValueReturned() = {
+        val average = Utils.average(10, 20)
+        assertEquals(15.0, average, 1e-5)
+    }
+
+    @Test
+    def givenTwoIntegers_whenGcdCalled_thenCorrectValueReturned = {
+        assertEquals(3, Utils.gcd(15, 27))
+    }
+
+    @Test
+    def givenTwoIntegers_whenGcdIterCalled_thenCorrectValueReturned = {
+        assertEquals(3, Utils.gcdIter(15, 27))
+    }
+
+    @Test
+    def givenTwoIntegers_whenRangeSumcalled_thenCorrectValueReturned = {
+        assertEquals(55, Utils.rangeSum(1, 10))
+    }
+
+    @Test
+    def givenPositiveInteger_whenFactorialInvoked_thenCorrectValueReturned = {
+        assertEquals(720, Utils.factorial(6))
+    }
+
+    @Test
+    def whenRandomLessThanInvokedWithANumber_thenARandomLessThanItReturned = {
+        val d = 0.1
+        assertTrue(Utils.randomLessThan(d) < d)
+    }
+
+    @Test
+    def whenPowerInvokedWith2And3_then8Returned = {
+        assertEquals(8, power(2, 3))
+    }
+
+    @Test
+    def whenFibonacciCalled_thenCorrectValueReturned = {
+        assertEquals(34, fibonacci(8))
+    }
+}

pom.xml

@@ -377,6 +377,7 @@
 				<module>guava-modules/guava-21</module>
 				<module>guice</module>
 				<module>disruptor</module>
+				<module>core-scala</module>
 				<module>spring-static-resources</module>
 				<module>hazelcast</module>
 				<module>hbase</module>