Basic Expressions

The most basic building block of software engineering is the expression. An expression, in both computer science and mathematics, is the combination of symbols that when evaluated will produce a fixed result. In Scala, everything can be distilled down to a series of expressions. Understanding this will become incredibly valuable in the future as you learn to test and debug your code because you will be able to isolate individual expressions from the overall program for separate evaluation and assessment. Let’s program a few basic expressions in Scala to help further demonstrate what they are and why they are useful.

In order to do that, it’s imperative to understand your Scala environment and its behavior. To help you understand, we will first walk through a couple of examples that produce expected results and how best for you to interpret those results. After that, we will walk through a few unexpected results so that you can learn how to get around road blocks with basic expressions before moving on to more complex expressions.

After typing in 2 + 2 and hitting enter, the interpreter will evaluate the expression and return to you the answer 4, much like a calculator. Any syntactically valid expression will follow this same pattern within the Scala REPL. Unlike a calculator, you’ll notice a couple of extra things in the “Print” step of the interpreter.

First, there is the symbol res0. The res symbol stands for “result” and the 0 is an ordered unique identifier (also known as an index) that denotes that this is the first result in the REPL session. A session is an individual Scala REPL that is open for a unit of time. Subsequent results in the session will increment that number by one for each interpreted expression. When you close your terminal or quit the Scala REPL (by typing in :quit), that will end your session and the number will start back over at 0 for future sessions. You might wonder, if it’s the first result, then why is the unique identifier a zero and not a one? Influenced by binary among other things, most incremental counting indexes in computer science start at zero.

Second, there is the symbol Int which stands for Integer. If you remember from your mathematics education, an integer is any whole number. The symbol is just the interpreter telling you that it has inferred the type of the evaluated expression result and that type is an integer. We will cover more on the different types in later chapters, but for now you can be content to understand that Scala is inferring types for you.

You’ll notice that the interpreter has printed out three lines of response as a result of the input expression. The first line provides an error message in an attempt to help us understand why we did not get the result we expected and how we might go about debugging it. Because we haven’t covered members or types, you should not be expected to understand the meaning of the error message at this point. The second line reprints your original expression so that the third line can point out where the interpreter encountered the error (as denoted by the caret ^ symbol). The caret and the error message seem to be pointing us to the x in the expression. Intuition would suggest that it seems to be implying that we have a syntax error. As we covered in the previous chapter, if a sentence or code block is combined in the wrong order or with the wrong punctuation, the underlying meaning might change or have no meaning at all. Computers cannot interpret code unless it is written exactly as specified by the syntax rules of the language.

You might look at the second example and question whether or not it is indeed proper syntax given the answer. After all, 4 / 5 on a standard calculator evaluates to 0.8. This is the quintessential example of the difference between a syntax error and a semantic error in computer science. The syntax is absolutely correct – it has two operands separated by a symbol that represents an appropriate operator. Yet, we did not get the result we wanted. When the meaning of your expression and therefor the result is not what you intended, there is sure to be a semantic error somewhere. It just so happens that with semantic errors, Scala does not return any error results back to you in the terminal window because it assumes that, since what you typed in as input was a syntactically valid expression, it is exactly what you meant to type.

You’ll notice that although 4.0 and 5.0 are, in fact, whole number since they do not have any remainders in the decimal position, by adding the decimal and the zero, it helps the Scala interpreter know that you intended for the type of these operands to be decimals that can accept remainders. The type of the result of these expressions is a Double, which we will cover in more detail in later chapters. For now, all you need to know is that a Double type can accept partial decimals where integers cannot.

Now that you’ve seen a few examples of basic expressions with different outcomes, we can move on to more advanced expressions to demonstrate the broader set of syntax rules surrounding Scala expressions.

Advanced Expressions

In order to best represent advanced expressions in Scala, I have found it useful to use popular mathematical formulas that most people are familiar with. The formulas that will be used for the remainder of this chapter in the examples and exercises will be the basic linear equation, Einstein’s theory of relativity, and the Pythagorean Theorem. If you are not familiar with these equations, it might be useful for you to go look them up, but we will cover their definitions briefly as well.

Perhaps the easiest expression to start with syntactically would be the standard linear equation, which is y = mx + b. This equation is used to determine the coordinates of a point on a line that exists on a two-dimensional graph given the slope of the line and the point at which the line crosses the vertical axis, known as the Y intercept. The point is represented as (x,y) which corresponds to the variables of the same label within the equation. The slope of the line is represented by the variable m, and the Y intercept is represented by the variable b. Figure 4-1 shows a representation of this equation.

So, what we’ve discovered as a result of this expression is that on this particular line, when the X coordinate is 8, the Y coordinate is 7. In this example, you can see that the result type is a Double since we used a fractional operand in the expression. You might also notice that for this particular expression there are multiple operators and they are evaluated from left to right. You can imagine an even more advanced scenario where you might need to chain several more operations together in this manner. We’ll start to see such examples later on in the chapter, but for now just ensure that you understand how to use the information gained to solve a simple linear equation.

In this expression, the answer is shown in scientific notation. You might very well be used to seeing scientific notation expressed in terms of 8.9875517873681766 x 10¹⁷ joules. All you need to know in Scala is that the “x 10” part is replaced with an “E” and even though the 17 does not appear to look like it is an exponent, you can safely assume that it is. Knowing how scientific notation is expressed in the Scala REPL is important, but more important than that is the demonstration of exponent syntax in this example. In this exponent expression, the speed of light constant is the operand and the operators are Math.pow (which tells Scala you want to raise your operand to a certain power), the parentheses, the comma, and the 2, which is the power you want to raise your operand to. If you wanted to raise an operand to the power of 3, you would simply use something like Math.pow(2,3) which is the equivalent of 2³ and would yield an answer of 8.0.

Keeping this refresher in mind, let’s move on to the Pythagorean Theorem. This expression uses the lengths of two sides of a right triangle to determine the length of the third side. The theorem provides that the two sides that form the right angle of the triangle, a and b, are equal to the third side c, known as the hypotenuse, if their lengths are all squared. Figure 4-2 shows an example of the premise of this equation.

Notice the new syntax to denote the square root in a similar fashion to the exponent syntax, Math.sqrt. It will simply take the square root of anything inside its parentheses. An imperative observation to note here is that expressions can contain other expressions just as in mathematics. This notion allows for ever-increasing complexity of expressions. It’s also a useful concept to grasp when attempting to debug an expression. If the answer you received seemed less than intuitive, you could simple pull the individual expressions out of the larger expression and evaluate them independently to ensure everything is operating as you would have expected. In evaluating this expression, given the order of operations rules, the exponents of 4² and 6² are evaluated first, then the terms inside the square root parentheses are simplified by adding them together, and finally the square root is taken from the result giving us the answer of approximately 7.211.

Now that you have seen a few examples of complex expressions, the next step is to gain a better understanding of the rest of the Scala operators that are possible. These can be grouped into three categories including arithmetic operators, comparison operators, and logical operators. After you have absorbed the universe of operators, you will be introduced to variables which will further expound upon the vast capabilities of expressiveness that is available in the Scala language.

Variables

Just like in your early math classes, programming has a concept of a variable that allows for storing a dynamic result or value in a symbol. Many math students tend to be intimidated by the variety of symbols that get introduced to their arithmetic tool set and mentally check out as soon as they see a letter in an equation. However, variables actually make programming much easier as their existence prevents expressions from infinitely chaining together.

Scala has two variable types that you will need to be familiar with. The first is denoted by the keyword val and the second is denoted by the keyword var. The difference between the two has to do with a term known as mutability. Mutability is the concept that determines whether a variable can be changed once it has been assigned. The val variable cannot be changed once it has been assigned and is therefore said to be immutable. Conversely, the var variable can be reassigned and is therefore considered mutable. Why there are two variable types and which one you should use is a topic that will be discussed later on in the book. For now, I want you to keep your focus on the usefulness that variables bring to expressions.

As you can see, not only is there the added benefit of extracting expressions for simplification and readability, but you can also see the results of the sub-expression as they are assigned. As stated before, this will be incredibly useful for you in the future as you begin to break up complex problems into smaller pieces for debugging purposes.

Summary

In this chapter, you were introduced to the Scala REPL and you were able to do some actual coding, albeit mostly mathematical. You were introduced to the concept of expressions, both mathematical and their Scala equivalent, and you got to know some of the basic Scala syntax surrounding operators and operands. These concepts were reinforced by applying them to a basic linear equation, Einstein’s mass-energy equivalence formula, and the Pythagorean Theorem. Finally, you were shown how these expressions can be stored in a computer’s short-term memory for later reuse using variable assignment.

In the next chapter, we’ll move away from all the numbers and do some interesting things with text and groups of data. You’ll also be introduced to different basic data types and learn a few reasons why they are important. As usual, make sure that you can do all of the basic concepts in this chapter in your sleep before moving on.