Scala - Basic Syntax

object HelloWorld {
   /* This is my first java program.  
   * This will print  Hello World  as the output
   */
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

Save the file as − HelloWorld.scala.

Open the command prompt window and go to the directory where the program file is saved. The ‘scalac’ command is used to compile the Scala program and it will generate a few class files in the current directory. One of them will be called HelloWorld.class. This is a bytecode which will run on Java Virtual Machine (JVM) using ‘scala’ command.

Use the following command to compile and execute your Scala program.

> scalac HelloWorld.scala
> scala HelloWorld

Output

Hello, World!

Basic Syntax

The following are the basic syntaxes and coding conventions in Scala programming.

Case Sensitivity − Scala is case-sensitive, which means identifier Hello and hello would have different meaning in Scala.

Class Names − For all class names, the first letter should be in Upper Case. If several words are used to form a name of the class, each inner word s first letter should be in Upper Case.

Example − class MyFirstScalaClass.

Method Names − All method names should start with a Lower Case letter. If multiple words are used to form the name of the method, then each inner word s first letter should be in Upper Case.

Example − def myMethodName()

Program File Name − Name of the program file should exactly match the object name. When saving the file you should save it using the object name (Remember Scala is case-sensitive) and append ‘.scala’ to the end of the name. (If the file name and the object name do not match your program will not compile).

Example − Assume HelloWorld is the object name. Then the file should be saved as HelloWorld.scala .

def main(args: Array[String]) − Scala program processing starts from the main() method which is a mandatory part of every Scala Program.

Scala Identifiers

All Scala components require names. Names used for objects, classes, variables and methods are called identifiers. A keyword cannot be used as an identifier and identifiers are case-sensitive. Scala supports four types of identifiers.

Alphanumeric Identifiers

An alphanumeric identifier starts with a letter or an underscore, which can be followed by further letters, digits, or underscores. The $ character is a reserved keyword in Scala and should not be used in identifiers.

Following are legal alphanumeric identifiers −

age, salary, _value,  __1_value

Following are illegal identifiers −

$salary, 123abc, -salary

Operator Identifiers

An operator identifier consists of one or more operator characters. Operator characters are printable ASCII characters such as +, :, ?, ~ or #.

Following are legal operator identifiers −

&plus; &plus;&plus; ::: <?> :>

The Scala compiler will internally "mangle" operator identifiers to turn them into legal Java identifiers with embedded $ characters. For instance, the identifier :-> would be represented internally as $colon$minus$greater.

Mixed Identifiers

A mixed identifier consists of an alphanumeric identifier, which is followed by an underscore and an operator identifier.

Following are legal mixed identifiers −

unary_+,  myvar_=

Here, unary_+ used as a method name defines a unary + operator and myvar_= used as method name defines an assignment operator (operator overloading).

Literal Identifiers

A pteral identifier is an arbitrary string enclosed in back ticks (` . . . `).

Following are legal pteral identifiers −

`x` `<cpnit>` `yield`

Scala Keywords

The following pst shows the reserved words in Scala. These reserved words may not be used as constant or variable or any other identifier names.

Comments in Scala

Scala supports single-pne and multi-pne comments very similar to Java. Multi-pne comments may be nested, but are required to be properly nested. All characters available inside any comment are ignored by Scala compiler.

object HelloWorld {
   /* This is my first java program.  
    * This will print  Hello World  as the output
    * This is an example of multi-pne comments.
    */
   def main(args: Array[String]) {
      // Prints Hello World
      // This is also an example of single pne comment.
      println("Hello, world!") 
   }
}

Blank Lines and Whitespace

A pne containing only whitespace, possibly with a comment, is known as a blank pne, and Scala totally ignores it. Tokens may be separated by whitespace characters and/or comments.

Newpne Characters

Scala is a pne-oriented language where statements may be terminated by semicolons (;) or newpnes. A semicolon at the end of a statement is usually optional. You can type one if you want but you don t have to if the statement appears by itself on a single pne. On the other hand, a semicolon is required if you write multiple statements on a single pne. Below syntax is the usage of multiple statements.

val s = "hello"; println(s)

Scala Packages

A package is a named module of code. For example, the Lift utipty package is net.pftweb.util. The package declaration is the first non-comment pne in the source file as follows −

package com.pftcode.stuff

Scala packages can be imported so that they can be referenced in the current compilation scope. The following statement imports the contents of the scala.xml package −

import scala.xml._

You can import a single class and object, for example, HashMap from the scala.collection.mutable package −

import scala.collection.mutable.HashMap

You can import more than one class or object from a single package, for example, TreeMap and TreeSet from the scala.collection.immutable package −

import scala.collection.immutable.{TreeMap, TreeSet}

Apply Dynamic

A marker trait that enables dynamic invocations. Instances x of this trait allow method invocations x.meth(args) for arbitrary method names meth and argument psts args as well as field accesses x.field for arbitrary field namesfield. This feature is introduced in Scala-2.10.

If a call is not natively supported by x (i.e. if type checking fails), it is rewritten according to the following rules −

foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)