{"id":534,"date":"2011-09-26T08:19:00","date_gmt":"2011-09-26T08:19:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-scala-repl-expressions-variables-basic-types-simple-functions-saving-and-running-programs-comments.html"},"modified":"2012-10-21T20:11:29","modified_gmt":"2012-10-21T20:11:29","slug":"scala-tutorial-scala-repl-expressions","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/09\/scala-tutorial-scala-repl-expressions.html","title":{"rendered":"Scala Tutorial – Scala REPL, expressions, variables, basic types, simple functions, saving and running programs, comments"},"content":{"rendered":"
\n

Preface<\/h2>\n

The is the first of several Scala tutorials I\u2019m creating for my Fall 2011 graduate Introduction to Computational Linguistics course<\/a> at UT Austin, loosely based on similar tutorials that Katrin Erk<\/a> created for teaching Python in a similar course<\/a>. These tutorials assume no previous programming background, an assumption which is unfortunately still quite rare in the help-folks-learn-Scala universe, and which more or less necessitates the creation of these tutorials. The one exception I\u2019m aware of is SimplyScala<\/a>.<\/p>\n

Note<\/strong>: if you already know a programming language, this tutorial will probably not be very useful for you. (Though perhaps some of the later ones on functional programming and such that I intend to do will be, so check back.) In the meantime, check out existing Scala learning materials I\u2019ve listed in the links page for the course.<\/a><\/p>\n

This tutorial assumes you have Scala installed and that you are using some form of Unix (if you use Windows, you\u2019ll want to look into Cygwin). If you are having problems with this, you might try the examples by evaluating them in the code box on SimplyScala.<\/p>\n

A (partial) starter tour of Scala expressions, variables, and basic types<\/h2>\n

We\u2019ll use the Scala REPL for entering Scala expressions and seeing what the result of evaluating them is. REPL stands for read-eval(uate)-print-loop, which means it is a program that (1) reads the expressions you type in, (2) evaluates them using the Scala compiler, (3) prints out the result of the evaluation, and then (4) waits for you to enter further expressions.<\/p>\n

Note<\/strong>: it is very important that you actually type the commands given below into the REPL. If you just read them over, it will in many cases look quite obvious (and it is), but someone who is new to programming will generally find many gaps in their understanding by actually trying things out. In particular, programming languages are very exact, so they\u2019ll do exactly what you tell them to do \u2014 and you\u2019ll almost surely mess a few things up, and learn from that.<\/p>\n

In a Unix shell, type:<\/p>\n

$ scala\r\n<\/pre>\n
You should see something like the following:<\/p>\n
Welcome to Scala version 2.9.0.1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_26).\r\nType in expressions to have them evaluated.\r\nType :help for more information.\r\n \r\nscala>\r\n<\/pre>\n
The scala><\/strong> line is the prompt that the REPL is waiting for you to enter expressions. Let\u2019s enter some.<\/p>\n
scala> \"Hello world\"\r\nres0: java.lang.String = Hello world\r\n \r\nscala> 2\r\nres1: Int = 2\r\n<\/pre>\n
The REPL tells us that the first is a String<\/em> which contains the characters Hello world<\/em>, that the second is an Int<\/em> whose value is the integer 2<\/em>. Strings and Ints are types<\/strong> \u2014 this is an easy but important distinction that sometimes takes beginning programmers a while to get used to. This allows Scala to know what to do when you want to use the numerical value<\/strong> 2 (an Int) or the character<\/strong> representing 2 (a String). For example, here is the latter.<\/p>\n
scala> \"2\"\r\nres3: java.lang.String = 2\r\n<\/pre>\n
Scala knows that different actions are afforded by different types. For example, Ints can be added to each other.<\/p>\n
scala> 2+3\r\nres4: Int = 5\r\n<\/pre>\n
Scala evaluates the result and prints the result to the screen. No surprise, the result is what you think it should be. With Strings, addition doesn\u2019t make sense, but the + operator instead indicates concatenation of the strings.<\/p>\n
scala> \"Portis\" + \"head\"\r\nres5: java.lang.String = Portishead\r\n<\/pre>\n
So, if you consider the String \u201c2? and the String \u201c3?, and use the + operator on them, you don\u2019t get \u201c5? \u2014 instead you get \u201c23?.<\/p>\n
scala> \"2\" + \"3\"\r\nres6: java.lang.String = 23\r\n<\/pre>\n
We can ask Scala to display the result of evaluating a given expression by using the print<\/strong> command.<\/p>\n
scala> print (\"Hello world\")\r\nHello world\r\nscala> print (2)\r\n2\r\nscala> print (2 + 3)\r\n5\r\n<\/pre>\n
Note that the result is the action of printing, not a value with a type. For the last item, what happens is:<\/p>\n
    \n
  1. Scala evaluates 2 + 3, which is 5.<\/li>\n
  2. Scala passes that value to the command print<\/strong>.<\/li>\n
  3. print<\/strong> outputs \u201c5?<\/li>\n<\/ol>\n
    You can think of the print<\/strong> command as a verb, and its parameter (e.g. Hello world<\/em> or 2<\/em>) as its object.<\/p>\n
    We often need to store the result of evaluating an expression to a variable for later use (in fact, programming doesn\u2019t get done with out doing this). Let\u2019s do this trivially to start with, breaking down the print statement above into two steps.<\/p>\n
    scala> val x = 2 + 3\r\nx: Int = 5\r\n \r\nscala> print (x)\r\n5\r\n<\/pre>\n
    Here, x<\/em> is a variable, which we\u2019ve indicate by prefacing it with val<\/strong>, which indicates it is a fixed variable whose value cannot change.<\/p>\n
    You can choose the names for variables, but they must follow some rules.<\/p>\n