{"id":592,"date":"2011-10-31T23:46:00","date_gmt":"2011-10-31T23:46:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-scripting-compiling-main-methods-return-values-of-functions.html"},"modified":"2012-10-21T20:22:05","modified_gmt":"2012-10-21T20:22:05","slug":"scala-tutorial-scripting-compiling-main","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/scala-tutorial-scripting-compiling-main.html","title":{"rendered":"Scala Tutorial – scripting, compiling, main methods, return values of functions"},"content":{"rendered":"
\n

Preface<\/h2>\n

This is part 10 of tutorials for first-time programmers getting into Scala. Other posts are on this blog, and you can get links to those and other resources on the links page of the Computational Linguistics course<\/a> I\u2019m creating these for. Additionally you can find this and other tutorial series on the JCG Java Tutorials page<\/a>.<\/p>\n

The tutorials up to this point have been based on working with the Scala REPL or running basic scripts that are run from the command line. The latter is called \u201cscripting\u201d and usually is done for fairly simple, self-contained coding tasks. For more involved tasks that require a number of different modules and accessing libraries produced by others, it is necessary to work with a build system that brings together your code, others\u2019 code, allows you to compile it, test it, and package it so that you can use it as an application.<\/p>\n

This tutorial takes you from running Scala scripts to compiling Scala programs to create byte code that can be shared by different applications. This will act as a bridge to set you up for the next step of using a build system. Along the way, some points will be made about objects, extending on some of the ideas from the previous tutorial about object-oriented programming. At a high level, the relevance of objects to a larger, modularized code base should be pretty clear: objects encapsulate data and functions that can be used by other objects, and we need to be able to organize them so that objects know how to find other objects and class definitions. Build systems, which we\u2019ll look at in the next tutorial, will make this straightforward.<\/p>\n

Running Scala scripts<\/h2>\n

In the beginning, you started with the REPL.<\/p>\n

scala> println(\"Hello, World!\")\r\nHello, World!\r\n<\/pre>\n
Of course, the REPL is just a (very useful) playground for trying out snippets of Scala code, not for doing real work. So, you saw that you could put code like println(\u201cHello, World!\u201d)<\/strong> into a file called Hello.scala<\/strong> and run it from the command line.<\/p>\n
$ scala Hello.scala\r\nHello, World!\r\n<\/pre>\n
The homeworks and tutorials done so far have worked in this way, though they are a bit more complex. We can even include class definitions and objects created from a class. For example, using the Person<\/strong> class from the previous tutorial<\/a>, we can put all the code into a file called People.scala<\/strong> (btw, this name doesn\u2019t matter \u2014 could as well be Blurglecruncheon.scala<\/strong>).<\/p>\n
class Person (\r\n  val firstName: String,\r\n  val lastName: String,\r\n  val age: Int,\r\n  val occupation: String\r\n) {\r\n \r\n  def fullName: String = firstName + \" \" + lastName\r\n \r\n  def greet (formal: Boolean): String = {\r\n    if (formal)\r\n      \"Hello, my name is \" + fullName + \". I'm a \" + occupation + \".\"\r\n    else\r\n      \"Hi, I'm \" + firstName + \"!\"\r\n  }\r\n \r\n}\r\n \r\nval johnSmith = new Person(\"John\", \"Smith\", 37, \"linguist\")\r\nval janeDoe = new Person(\"Jane\", \"Doe\", 34, \"computer scientist\")\r\nval johnDoe = new Person(\"John\", \"Doe\", 43, \"philosopher\")\r\nval johnBrown = new Person(\"John\", \"Brown\", 28, \"mathematician\")\r\n \r\nval people = List(johnSmith, janeDoe, johnDoe, johnBrown)\r\npeople.foreach(person => println(person.greet(true)))\r\n<\/pre>\n
This can now be run from the command line, producing the expected result.<\/p>\n
$ scala People.scala\r\nHello, my name is John Smith. I'm a linguist.\r\nHello, my name is Jane Doe. I'm a computer scientist.\r\nHello, my name is John Doe. I'm a philosopher.\r\nHello, my name is John Brown. I'm a mathematician.\r\n<\/pre>\n
However, suppose you wanted to use the Person<\/strong> class from a different application (e.g. that is defined in a different file). You might think you could save the following in the file Radiohead.scala<\/strong>, and then run it with Scala.<\/p>\n
val thomYorke = new Person(\"Thom\", \"Yorke\", 43, \"musician\")\r\nval johnnyGreenwood = new Person(\"Johnny\", \"Greenwood\", 39, \"musician\")\r\nval colinGreenwood = new Person(\"Colin\", \"Greenwood\", 41, \"musician\")\r\nval edObrien = new Person(\"Ed\", \"O'Brien\", 42, \"musician\")\r\nval philSelway = new Person(\"Phil\", \"Selway\", 44, \"musician\")\r\nval radiohead = List(thomYorke, johnnyGreenwood, colinGreenwood, edObrien, philSelway)\r\nradiohead.foreach(bandmember => println(bandmember.greet(false)))\r\n<\/pre>\n
However, if you do \u201cscala Radiohead.scala<\/strong>\u201d you\u2019ll see five errors, each one complaining that the type Person<\/strong> wasn\u2019t found. How could Radiohead.scala<\/strong> know about the Person class and where to find its definition? I\u2019m not aware of a way to do this with scripting-style Scala programming, and even though I suspect there may be a way to do something this simple, I don\u2019t even care to know it. Let\u2019s just get straight to compiling.<\/p>\n
  Compiling<\/h2>\n
The usual thing we do with Scala is to compile our programs to byte code. We won\u2019t go into the details of that, but it basically means that Scala turns the text of a Scala program into a compiled set of machine instructions that can be interpreted by your operating system. (It actually compiles to Java byte code, which is one reason it is pretty straightforward to use Java code when coding in Scala.)<\/p>\n
So, what does compilation look like? We need to start by changing the code we did above a bit. Make a directory that has nothing in it, say \/tmp\/tutorial<\/strong>. Then save the following as PersonApp.scala<\/strong> in that directory.<\/p>\n
class Person (\r\n  val firstName: String,\r\n  val lastName: String,\r\n  val age: Int,\r\n  val occupation: String\r\n) {\r\n \r\n  def fullName: String = firstName + \" \" + lastName\r\n \r\n  def greet (formal: Boolean): String = {\r\n    if (formal)\r\n      \"Hello, my name is \" + fullName + \". I'm a \" + occupation + \".\"\r\n    else\r\n      \"Hi, I'm \" + firstName + \"!\"\r\n  }\r\n \r\n}\r\n \r\nobject PersonApp {\r\n \r\n  def main (args: Array[String]) {\r\n    val johnSmith = new Person(\"John\", \"Smith\", 37, \"linguist\")\r\n    val janeDoe = new Person(\"Jane\", \"Doe\", 34, \"computer scientist\")\r\n    val johnDoe = new Person(\"John\", \"Doe\", 43, \"philosopher\")\r\n    val johnBrown = new Person(\"John\", \"Brown\", 28, \"mathematician\")\r\n \r\n    val people = List(johnSmith, janeDoe, johnDoe, johnBrown)\r\n    people.foreach(person => println(person.greet(true)))\r\n  }\r\n \r\n}\r\n<\/pre>\n
Notice that the code looks pretty similar to the script above, but now we have a PersonApp<\/strong> object with a main<\/strong> method. The main<\/strong> method contains all the stuff that the original script had after the Person<\/strong> definition. Notice also that there is an args<\/strong> argument to the main<\/strong> method, which should look familiar now. What you are seeing is that a Scala script is basically just a simplified view of an object with a main<\/strong> method. Such scripts use the convention that the Array[String]<\/strong> provided to the method is called args<\/strong>.
 
<\/div> <\/div><\/p>\n
Okay, so now consider what happens if you run \u201cscala PersonApp.scala<\/strong>\u201d \u2014 nothing at all. That\u2019s because there is no executable code available outside of the object and class definitions. Instead, we need to compile the code and then run the main<\/strong> method of specific objects. The next step is to run scalac<\/strong> (N.B. \u201cscalac<\/strong>\u201d with a \u201cc\u201d, not \u201cscala\u201d) on PersonApp.scala<\/strong>. The name scalac is short for Scala c<\/span>ompiler. Do the following steps in the \/tmp\/tutorial<\/strong> directory.<\/p>\n
$ scalac PersonApp.scala\r\n$ ls\r\nPerson.class                    PersonApp.class\r\nPersonApp$$anonfun$main$1.class PersonApp.scala\r\nPersonApp$.class\r\n<\/pre>\n
Notice that a number of *.class<\/strong> files have been generated. These are byte code files that the scala application is able to run. A nice thing here is that it all the compilation is done: when in the past you ran \u201cscala\u201d on your programs (scripts), it had to first compile the instructions and then run the program. Now we are separating these steps into a compilation phase and a running phase.<\/p>\n
Having generated the class files, we can run any object that has a main method, like PersonApp<\/strong>.<\/p>\n
$ scala PersonApp\r\nHello, my name is John Smith. I'm a linguist.\r\nHello, my name is Jane Doe. I'm a computer scientist.\r\nHello, my name is John Doe. I'm a philosopher.\r\nHello, my name is John Brown. I'm a mathematician.\r\n<\/pre>\n
Try running \u201cscala Person<\/strong>\u201d to see the error message it gives you.<\/p>\n
Next, move the Radiohead.scala<\/strong> script that you saved earlier into this directory and run it.<\/p>\n
$ scala Radiohead.scala\r\nHi, I'm Thom!\r\nHi, I'm Johnny!\r\nHi, I'm Colin!\r\nHi, I'm Ed!\r\nHi, I'm Phil!\r\n<\/pre>\n
This is the same script, but now it is in a directory that contains the Person.class<\/strong> file, which tells Scala everything that Radiohead.scala<\/strong> needs to construct objects of the Person<\/strong> class. Scala makes available any class file that is defined in the CLASSPATH<\/em>, an environment variable that by default includes the current working directory.<\/p>\n
Despite this success, we\u2019re going away from script land with this post, so change the contents of Radiohead.scala<\/strong> to be the following.<\/p>\n
object RadioheadGreeting {\r\n \r\n  def main (args: Array[String]) {\r\n    val thomYorke = new Person(\"Thom\", \"Yorke\", 43, \"musician\")\r\n    val johnnyGreenwood = new Person(\"Johnny\", \"Greenwood\", 39, \"musician\")\r\n    val colinGreenwood = new Person(\"Colin\", \"Greenwood\", 41, \"musician\")\r\n    val edObrien = new Person(\"Ed\", \"O'Brien\", 42, \"musician\")\r\n    val philSelway = new Person(\"Phil\", \"Selway\", 44, \"musician\")\r\n    val radiohead = List(thomYorke, johnnyGreenwood, colinGreenwood, edObrien, philSelway)\r\n    radiohead.foreach(bandmember => println(bandmember.greet(false)))\r\n  }\r\n \r\n}\r\n<\/pre>\n
Then run scalac on all of the *.scala<\/strong> files in the directory. There are now more class files, corresponding to the RadioheadGreeting<\/strong> object we defined.<\/p>\n
$ scalac *.scala\r\n$ ls\r\nPerson.class                            Radiohead.scala\r\nPersonApp$$anonfun$main$1.class         RadioheadGreeting$$anonfun$main$1.class\r\nPersonApp$.class                        RadioheadGreeting$.class\r\nPersonApp.class                         RadioheadGreeting.class\r\nPersonApp.scala\r\n<\/pre>\n
You can now run \u201cscala RadioheadGreeting<\/strong>\u201d to get the greeting from the band members. Notice that the file RadioheadGreeting<\/strong> was saved in was called Radiohead.scala<\/strong> and that no class files were generated called Radiohead.class<\/strong>, etc. Again, the file name could have been named something entirely different, like Turlingdrome.scala<\/strong>. (Embrace your inner Vogon.<\/a>)<\/p>\n
  Multiple objects in the same file<\/h2>\n
There is no problem having multiple objects with main<\/strong> methods in the same file. When you compile the file with scalac<\/strong>, each object generates its own set of class files, and you call scala<\/strong> on whichever class file contains the definition for the main<\/strong> method you want to run. As an example, save the following as Greetings.scala<\/strong>.<\/p>\n
object Hello {\r\n  def main (args: Array[String]) {\r\n    println(\"Hello, world!\")\r\n  }\r\n}\r\n \r\nobject Goodbye {\r\n  def main (args: Array[String]) {\r\n    println(\"Goodbye, world!\")\r\n  }\r\n}\r\n \r\nobject SayIt {\r\n  def main (args: Array[String]) {\r\n    args.foreach(println)\r\n  }\r\n}\r\n<\/pre>\n
Next compile the file and then you can run any of the generated class files (since they all have main<\/strong> methods).<\/p>\n
$ scalac Greetings.scala\r\n$ scala Hello\r\nHello, world!\r\n$ scala Goodbye\r\nGoodbye, world!\r\n$ scala Goodbye many useless arguments\r\nGoodbye, world!\r\n$ scala SayIt \"Oh freddled gruntbuggly\" \"thy micturations are to me\" \"As plurdled gabbleblotchits on a lurgid bee.\"\r\nOh freddled gruntbuggly\r\nthy micturations are to me\r\nAs plurdled gabbleblotchits on a lurgid bee.\r\n<\/pre>\n
In case you missed it earlier, the args<\/strong> array is where the command line arguments go and you can thus make use of them (or not, as in the case of the Hello<\/strong> and Goodbye<\/strong> objects).<\/p>\n
  Functions with return values versus those without<\/h2>\n
Some functions return a value while others do not. As a simple example, consider the following pairs of functions.<\/p>\n
scala> def plusOne (x: Int) = x+1\r\nplusOne: (x: Int)Int\r\n \r\nscala> def printPlusOne (x: Int) = println(x+1)\r\nprintPlusOne: (x: Int)Unit\r\n<\/pre>\n
The first takes an Int<\/strong> argument and returns an Int<\/strong>, which is a value. The other takes an Int<\/strong> and returns Unit<\/strong>, which is to say it doesn\u2019t return a value. Notice the difference in behavior between the two following uses of the functions.<\/p>\n
scala> val foo = plusOne(2)\r\nfoo: Int = 3\r\n \r\nscala> val bar = printPlusOne(2)\r\n3\r\nbar: Unit = ()\r\n<\/pre>\n
Scala uses a slightly subtle distinction in function definitions that can distinguish functions that return values versus those that return Unit<\/strong> (no value): If you don\u2019t use an equals sign in the definition, it means that the function returns Unit<\/strong>.<\/p>\n
scala> def plusOneNoEquals (x: Int) { x+1 }\r\nplusOneNoEquals: (x: Int)Unit\r\n \r\nscala> def printPlusOneNoEquals (x: Int) { println(x+1) }\r\nprintPlusOneNoEquals: (x: Int)Unit\r\n<\/pre>\n
Notice that the above definition of plusOneNoEquals<\/strong> returns Unit<\/strong>, even though it looks almost identical to plusOne<\/strong> defined earlier. Check it out.<\/p>\n
scala> val foo = plusOneNoEquals(2)\r\nfoo: Unit = ()\r\n<\/pre>\n
Now look back at the main<\/strong> methods given earlier. No equals. Yep, they don\u2019t have a return value. They are the entry point into your code, and any effects of running the code must be output to the console (e.g. with println<\/strong> or via a GUI) or written to the file system (or the internet somewhere). The outputs of such functions (ones which do not return a value) are called side-effects. You need them for the main methods. However, in many styles of programming, a great deal of work is done with side-effects. I\u2019ve been trying to gently lead the readers of this tutorial to adopt a more functional approach that tries to avoid them. I\u2019ve found it a more effective style myself in my own coding, so I\u2019m hoping it will serve you all better to start from that point. (Note that Scala supports many styles of programming, which is nice because you have choice and can go with what you find most suitable.)<\/p>\n
  Cleaning up<\/h2>\n
You may have noticed that the directory you are working in as you run scalac<\/strong> on your scala files becomes quite littered with class files. For example, here\u2019s what the state of the code directory worked with in this tutorial looks like after compiling all files.<\/p>\n
$ ls\r\nGoodbye$.class                          PersonApp.scala\r\nGoodbye.class                           Radiohead.scala\r\nGreetings.scala                         RadioheadGreeting$$anonfun$main$1.class\r\nHello$.class                            RadioheadGreeting$.class\r\nHello.class                             RadioheadGreeting.class\r\nPerson.class                            SayIt$$anonfun$main$1.class\r\nPersonApp$$anonfun$main$1.class         SayIt$.class\r\nPersonApp$.class                        SayIt.class\r\nPersonApp.class\r\n<\/pre>\n
A mess, right? Generally, one would rarely develop a Scala application by compiling it directly in this way. Instead a build system is used to manage the compilation process, organize the files, and allow one to easily access software libraries created by other developers. The next tutorial will cover this, using SBT <\/a>(the Simple Build Tool).<\/p>\n
Reference: <\/i><\/strong>First steps in Scala for beginning programmers, Part 10<\/a> from our JCG partner<\/a> Jason Baldridge at the Bcomposes<\/a> blog.<\/p>\n
Related Articles :<\/i><\/strong><\/p>\n