A Scala program is a tree of nested definitions. A definition may start with a keyword, definition's name, a classifier, and if it's a concrete definition, then also an entity to which that definition is bound. So the syntax is regular, just like any other programming language has keyword/name/classifier/bound-entity. Let's take an example. We'll use Scala REPL to see how a simple Scala program is built. For that, let's import a Scala package named universe:

scala> import scala.reflect.runtime.universe._ 
import scala.reflect.runtime.universe._ 

This import clause brings all the definitions within the universe package in scope. It means that the required functions we are going to use are in scope, and available for us to use. Then we'll use a reify method, which returns an Expr to construct tree...

While writing our Scala programs, we can define our member fields using either val or var keywords. When we use a val keyword to assign a value to any attribute, it becomes a value. We're not allowed to change that value in the course of our program. So a val declaration is used to allow only immutable data binding to an attribute. Let's take an example:

scala> val a = 10
a: Int = 10

Here, we have used a val keyword with an attribute named a, and assigned it a value 10. Furthermore, if we try to change that value, the Scala compiler will give an error saying: reassignment to val:

scala> a = 12
<console>:12: error: reassignment to val
    a = 12

Scala recommends use of val as much as possible to support immutability. But if an attribute's value is going to change in the course of our program, we can use the var declaration:

scala> var b...

In the previous discussion, we've seen a String literal and an Integer too. Here, we'll discuss all available literals, and how to define them in Scala. If you're coming from a Java background, then quite a few will be the same for you: Integer, Floating point, Boolean, Character, and String are similar. Along with those, the Tuple and Function literals can be treated as something new to learn. All the literals are listed as follows:

• Integer literals
• Floating point literals
• Boolean literals
• Character literals
• String literals
• Symbol literals
• Tuple literals
• Function literals

We'll discuss them one by one. Let's start with Integer literals.

Numeric literals can be expressed...

We have just covered literals in Scala, and with that, we've almost covered the introduction to all the data types existing as well. We discussed how to define Int, Long, Short, and Byte data types. Along with these, we also covered Float and Double type. Together, all these are called numeric data types. The Byte, Short, and Char are called sub-range types. We also talked about Boolean, character, and strings:

In Java, these numeric types are called Primitive Types, and then there are user-defined types as well. But in Scala, these somewhat similar types to primitives, are called value types. Objects of these value types are not represented by an object in the underlying runtime system. Thus, arithmetic operations performed are in the form of methods defined for Int, and other numeric value types. Think about it, it means that we can...

We can call type inference a built-in Scala feature that permits us to omit type information while writing code. This means we don't have to specify the type while declaring any variables; Scala compiler can do it for us:

scala> val treatMeAString = "Invisible"
treatMeAString: String = Invisible

We did not specify our val, to be of String type, but seeing the value of Invisible, Scala compiler was able to infer its type. Also with some constraints, we can also omit the method's return types:

defcheckMeImaString(x: Boolean) = if(x) "True"else "False"

Here we did not give the return type, as Scala compiler was able to infer its type. But for recursive methods, this doesn't work. The famous factorial method expects you to specify the return type if implementation is recursive:

def recursiveFactorial(n: Int) = if(n...

Based on the way we use them, the Scala operators can be classified into three types:

• Infix operators
• Prefix operators
• Postfix operators

We use operators to perform some operation on operands, which is obvious, and the way we implement makes them infix, prefix, or postfix. A basic example of an infix operator is addition +:

scala> val x = 1 + 10
x: Int = 11

We have two operands (1 and 10) on which this addition operation is being performed. We've already discussed that operators are methods. It means that somehow the operation is being performed as 1.+(10), and 1 + 10 is just syntactic sugar of how we can write this. This is possible because the method + is defined for the given types. Here, in our case, the addition (+) method is defined for Int. Along with this, there are several versions of overloaded methods that support other numeric value...

In Scala, we can create our own universe, apart from the native methods provided, we can add our own implementations, which we call Rich Wrapper classes. This is possible because of Implicit Conversions. First, we'll list out some Wrappers available already:

To see how it happens, let's see an example:

scala> val x = 10
x: Int = 10

scala> x.isValidByte
res1: Boolean = true

The preceding expression tries to check if the value of x can be converted into a Byte, and suffices range of a Byte, and finds it to be true:

scala> val x = 260
x: Int = 260

scala> x.isValidByte
res2: Boolean = false

scala> val x = 127
x: Int = 127

scala> x.isValidByte
res3: Boolean = true

As you know, range for a Byte is -128 to 127. If you try to assign it to a value that's out of range of a Byte and expect it to behave like a Byte, it won...