Note

You can visit Scala's official home page here:https://www.scala-lang.org/

package com.packt.coursewareimport scala.io.StdInobject Chatbot1{   def main(args: Array[String]):Unit =  {     // do something   }}

If you look at the preceding code, the first line is a package name. In our case, this iscom.packt.courseware.

All compilation units are organized into packages. Packages can be nested, forming hierarchical namespaces for code objects.

When a compilation unit has no package declaration, it belongs to a so-called 'default' package. Modules from a default package can't be imported from another package.

Usually, the source directory in a Scala project is organized in the same way as packages. This is not mandatory, but becomes a rule of thumb. Some tools (such as IDEs) use these conventions for default project settings.

Now we will look atimport statements.

         package com.packt.couserware    object X  { def f() = { … } }

Themain method is an essential part of any Scala program. The execution of a program first starts from themain method.

Let's look inside themain method:

def main(args: Array[String]): Unit = {val name = StdIn.readLine("Hi! What is your name?")println(s" $name, tell me something interesting, say 'bye' to end the talk")var timeToBye = false  while (!timeToBye)timeToBye = StdIn.readLine(">") match {case "bye" => println("ok, bye")                             truecase  _      => println("interesting...")false}}

Here, we define an immutable value with the namename, which keeps the user's input fromstdin. Scala is a statically typed language, and so the value is of typeString.

As we can see, the type of the value is not explicitly written, but automatically inferred from its context.

At the next line, the value is printed using the "string interpolation" operator: In a string with a prefix ofs, all occurrences of expressions inside${} brackets in strings are replaced with values of these expressions, casted to strings. For simple identifiers, we canomit {} brackets, for example, in a string interpolation ofs"x=$y", the value of y will be substituted instead with$y.

var timeToBye is a mutable variable with aBoolean type. Unlike values, mutable variables can be assigned more than once.

Looking forward at the loop, we can see that the program is trying to be a good listener and answerinteresting to any message, exceptbye.

The result of the case statement is assigned totimeToBye, and is checked in thewhile loop condition

Scala, as a multiparadigm language, has both mutable and immutable variables. For nearly any task, we can choose more than one way of implementing this.

If guidelines exist, where should we use mutable variables and where should we use immutable variables?

Generally, reasoning about immutable variables is simpler. The usual heuristic is to use immutable values as much as possible, leaving mutable variables for performance-critical sections and state-check language constructs (such as while loops).

In our small example, we can eliminate the mutable flag by putting an expression for the loop exit condition insidewhile. The resulting code is smaller and better to read, but adding new functionality becomes harder. Yet there is one possibility—use therecursive function instead of the loop language construction.

Now let's add some functionality to ourchatbot: when the user asks for thetime, thechatbot should report the current time.

To do this, we must retrieve the current time using the Java API and display the output of the time using string interpolators.

For example, use thenow method ofjava.time.LocalTime.

The code used to display this will beprintln("time is ${java.time.LocalTime.now()}").

The following is the code for this functionality, but we will actually implement this after setting up the working environment we will be playing with:

package com.packt.coursewarepackage com.packt.coursewareimport scala.io.StdInobject Chatbot1 {  def main(args: Array[String]): Unit = {    val name = StdIn.readLine("Hi! What is your name?")    println(s" $name, tell me something interesting, say 'bye' to end the talk")    var timeToBye = false    while (!timeToBye)       timeToBye = StdIn.readLine(">") match {         case "bye" => println("ok, bye")         true         case "time" => println(s"time is ${java.time.LocalTime.now()}")         true         case _ => println("interesting...")         false       }}}

organization := "com.packt.courseware"name := "chatbot1"version := "0.1-SNAPSHOT"scalaVersion := "2.12.4"

rssh3:1-project rssh$ sbt run[info] Loading global plugins from /Users/rssh/.sbt/0.13/plugins[info] Set current project to chatbot1 (in build file:/Users/rssh/work/packt/professional-scala/Lesson 1/1-project/)[info] Running com.packt.courseware.Chatbot1Hi! What is your name? Jon  Jon, tell me something interesting, say 'bye' to end the talk

>qqqinteresting..>dddinteresting...>byeok, bye [success] Total time: 19 s, completed Dec 1, 2017 7:18:42 AM

1. Install sbt on your computer, if not installed beforehand.
2. Start thesbt console by typingsbt console in the root directory of the1-project(wherebuild.sbt is situated).
3. Compile the code by typing thecompile command into thesbt console.
4. Run the program by typing thesbt run command into thesbt console.
5. When running this, saybye to the bot and return to the console.
6. Package the program by typingpackage into thesbt console.

1. Importourproject:
   • Go toFile ->Import -> navigate tobuild.sbt
2. Open the program in IDE:
   • Start IDEA
   • PressOpen
   • Selectday1-lesson1/1-project/build.sbt
3. In the dialog window, which asks whether toopen it as a file or as a project, selectproject.
4. On the left part of the project's structure, unfoldsrc entry.
5. Click onmain.
6. Ensure that you can seemain, as specified in the code.
7. Ensure that project can be compiled and run via thesbt console.

1. SelectRun/Edit Configuration.
2. SelectApplication.
3. Set the application's name. In our case, useChatbot1.
4. Set the name of theMain class. In our case, it must becom.packt.courseware.Chatbot1.
5. Actually run the application: select Run, then Chatbot1 from the dropdown menu.

1. Open thesbt tool.
2. OpenREPL by typing the following command:

   sbt console

3. Type the following expressions and pressEnter:
   • 2 + 2
   • "2" + 2
   • 2 + "2"
   • (1 to 8).sum
   • java.time.LocalTime.now()

1. Check fortime to match the statement:

   case "time" =>

2. Retrieve the current time using the Java API. Use thenow method ofjava.time.LocalTime:

        java.time.LocalTime.now()

3. Display the output of the time using string interpolators, as follows:

   println("time is ${java.time.LocalTime.now()}")

def main(args: Array[String]): Unit = {val name = StdIn.readLine("Hi! What is your name?")println(s" $name, tell me something interesting, say 'bay' to end the talk")var timeToBye = falsewhile (!timeToBye)timeToBye = StdIn.readLine(">") match {case "bye" => println("ok, bye")truecase "time" => println(s"time is ${java.time.LocalTime.now()}")truecase _ => println("interesting...")false}}

• Preparing a fat jar (which includes all dependencies). Ansbt plugin for this exists, which can be found at the following link:https://github.com/sbt/sbt-assembly.
• Preparing a native system package (which includes jars, dependencies, custom layouts, and so on). There is also ansbt plugin to create native system packages, which can be found at the following link:https://github.com/sbt/sbt-native-packager.

Note

For a formal, detailed description, refer to the SLS: Scala Language Specification here:http://scala-lang.org/files/archive/spec/2.12/.

> class X {  def f():Int = 1 }> Class X defined  // answer in REPL

> def f():Int = 1

> val x = 1

> var y = 2

>  object O {  def f():Int =1  }>  trait O {  def f():Int =1  }


1. Open REPLby typing the following command insbt:

   sbt console

2. Type in the following commands in REPL:

   >  object ZeroPoint {>     val x:Int = 0>     val y:Int = 0> }

• Primitive expression: Constant or value/variable name.
• Function calls: These can be:
  • Usual function callsf(x, y).
  • Operator call syntax:
  • binary:x + y.

  Note

  Any method with an argument can be used as a binary operator. A set of predefined binary operators are similar to Java:

• unary:!x
• Constructors:new x creates an instance of class x.
• Assignments to mutable variables:
  • y = 3: Assigns a value of3 toy.
  • x = 3: This is a compiler error, and a value can't be assigned.
• Block:

  { A; B }

  The valueof a block expression is the last expression. Note that; can be omitted ifA andB are situated on different lines. The syntax for this is shown as follows:

  {   A   B}

• Control structures
  • if statement:

           >  if (1 == 1)  "A"  else "B"       - let's eval one in REPL

  • match/case expressions:

        >  x match {         case "Jon"  =>  doSomethingSpecialForJon()         case "Joe" =>   doSomethingSpecialForJoe()         case   _   => doForAll()      }

  • Loops:
  • while/do

         var i=0      var s=0      while(i < 10) {          s = s+i          i = i +1      }

  • Do/while
  • Foreach,for

1. You should have already openedproject1. If you haven't, import it into the IDE.
2. Insert the new method inside the object definition.
3. Insert call at themain method.

  object Chatbot1 {def printHello():Unit = {println("Hello")}def main(args: Array[String]): Unit = {printHello() … // unchanged code here     }}

• Add test dependencies tobuild.sbt
• Write tests in the source test directory

libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.4" % "test"

1. In the command-line environment, navigate to the root of the project and select the following test:

     Lesson 1/2-project

2. If you are using a Unix/Linux machine and your code is situated incourses/pactscala of your homedirectory, then run the following command:

    > cd  ~/courses/packscala/Lesson 1/2-project

3. Run the following command:

       > sbt test

4. You willget the expected output, which will include the following strings:

   [info] ExampleSpec:[info] - example test should pass[info] StepTest:[info] - step of unparded word must be interesting

1. Open the project in the IDE.
2. Navigate toRun/Edit Configurations:
   
3. Choose sbt test as the configuration.
   • Check the checkboxUse sbt:
   
4. SelectRun sbt-test.

package com.packt.courseware.l1import org.scalatest.FunSuiteclass ExampleSpec extends FunSuite {  test("example test  should pass") {     assert(1==1)  }}

sbt test

1. Add one more test to the same file:src/test/scala/com/packt/courseware/l1/ExampleSpec.scala in 2-project
2. We write onetrivial test, which asserts thefalse expression:

         test("trivial")  {            assert(false)       }

3. Run the test and look at error reporting.
4. Invert theexpression in assert so that the test passes:

         test("trivial")  {            assert(true)       }

5. Run thesbt test again to ensure that all of the tests pass.

package com.packt.courseware.l1import java.time.LocalTimeimport java.time.format.DateTimeFormatterimport scala.io.StdIncase class LineProcessResult(answer:String,timeToBye:Boolean)object Chatbot2 {  def main(args: Array[String]): Unit = {    val name = StdIn.readLine("Hi! What is your name? ")    println(s" $name, tell me something interesting, say 'bye' to end the talk")    var c = LineProcessResult("",false)    while(!c.timeToBye){      c = step(StdIn.readLine(">"))      println(c.answer)    }  }  def step(input:String): LineProcessResult = {    input match {      case "bye" => LineProcessResult("ok, bye", true)      case "time" => LineProcessResult(LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")),false)      case _ => LineProcessResult("interesting...", false)    }  }}

package com.packt.courseware.l1import org.scalatest.FunSuiteclass StepTestSpec extends FunSuite {  test("step of unparded word must be interesting") {    val r = Chatbot2.step("qqqq")    assert(! r.timeToBye)    assert(r.answer == "interesting...")  }}

1. Add a second test to theStepTestSpec class in our project:

   test("after bye, timeToBye should be set to true"){}

2. In this test:
   • Call the step function withbye as a parameter:

     val r = Chatbot2.step("bye")

   • Check that after this call thattimeToQuit in the returned class is set totrue:

     assert(! r.timeToBye)

3. The whole code should be as follows:

   test("after bye, timeToBye should be set to true") {  val r = Chatbot2.step("bye")assert(! r.timeToBye)

4. Runsbt test.

test("local time must be parser") {val r = Chatbot2.step("time")val formatter = DateTimeFormatter.ofPattern("HH:mm:ss")val t = LocalTime.parse(r.answer,formatter)// assertion is not necessary}

1. Add the following code to the match statement so that it checks for thedate command, which should output the local date inDD:MM:YYYY format:

     case "date" => LineProcessResult(LocalDate.now().format(DateTimeFormatter.ofPattern("dd:YYYY-MM")),false)

2. Add a test case for this function.
3. The resulting code will be as follows:

   test("local date must be parser") {val r = Chatbot2.step("date")val formatter = DateTimeFormatter.ofPattern("dd:MM-YYYY")val t = LocalDate.parse(r.answer,formatter)// assertion is not necessary}