# 14 Expressions

In this chapter you will learn about R expressions which is a technical concept that appears everywhere in all R programming structures (e.g. functions, conditionals, loops). This chapter, by the way, is the shortest of the book. But its implications are fundamental to get a solid understanding of programming structures in R.

## 14.1 R Expressions

Before moving on with more programming structures we must first talk about R expressions.

### 14.1.1 Simple Expressions

So far you’ve been writing several lines of code in R, most of which have been simple expressions such as:

``````deposit = 1000
rate = 0.02
year = 3``````

The expression `deposit = 1000` is an assignment statement because we assign the number `1000` to the name `deposit`. It is also a simple expression. The same can be said about the expressions for `rate` and `year`.

Simple expressions are fairly common but they are not the only ones. It turns out that there is another class of expressions known as compound expressions.

### 14.1.2 Compound Expressions

R programs are made up of expressions which can be either simple expressions or compound expressions. Compound expressions consist of simple expressions separated by semicolons or newlines, and grouped within braces.

``````# structure of a compound expression
# with simple expressions separated by semicolons
{expression_1; expression_2; ...; expression_n}

# structure of a compound expression
# with simple expressions separated by newlines
{
expression_1
expression_2
expression_n
}``````

Here’s a less abstract example:

``````# simple expressions separated by semicolons
{"first"; 1; 2; 3; "last"}
>  "last"

# simple expressions separated by newlines
{
"first"
1
2
3
"last"
}
>  "last"``````

Writing compound expressions like those in the previous example is not something common among R users. Although the expressions are perfectly valid, these examples are very dummy (just for illustration purposes). By the way, I strongly discourage you from grouping multiple expressions with semicolons because it makes it difficult to inspect things.

What does R do with a compound expression? When R encounters a compound expression, it handles everything inside of it as a single unit or a single block of code.

What is the purpose of a compound expression? This kind of expression plays an important role but it is typically used together with other programming structures (e.g. functions, conditionals, loops).

### 14.1.3 Every expression has a value

A fundamental notion about expressions is that every expression in R has a value.

Consider this simple expression:

``a <- 5``

If I ask you: What is the value of `a`?, you should have no trouble answering this question. You know that `a` has the value 5.

``b <- 1:5``

What is the value of `b`? You know as well that the value of `b` is the numeric sequence given by `1 2 3 4 5`.

Now, let’s consider the following compound expression:

``x <- {5; 10}``

Note that the entire expression is assigned to `x`. Let me ask you the same question. What is the value of `x`? Is it:

• 5?
• 10?
• 5, 10?

Let’s find out the answer by taking a look at `x`:

``````x
>  10``````

Mmmm, this is interesting. As you can tell, `x` has a single value, and it’s not `5` but `10`. Out of curiosity, let’s also consider this other compound expression for `y` and examine its value:

``````y <- {
15
10
5
}

y
>  5``````

Same thing, `y` has a single value, the number `5`, which happens to be the last statement inside the expression that was evaluated. This is precisely the essence of an R expression. Every R expression has a value, the value of the last statement that gets evaluated.

To make sure you don’t forget it, repeat this mantra:

• Every expression in R has a value: the value of the last evaluated statement.

• Every expression in R has a value: the value of the last evaluated statement.

• Every expression in R has a value: the value of the last evaluated statement.

### 14.1.4 Assignments within Compound Expressions

It is possible to have assignments within compound expressions. For instance:

``````# simple expressions (made up of assignments) separated by newlines
{
one <- 1
pie <- pi
zee <- "z"
}``````

This compound expression contains three simple expressions, all of which are assignments. Interestingly, when an R expression contains such assignments, the values of the variables can be used in later expressions. In other words, you can refer later to `one` or `pie` or `zee`:

``````# simple expressions (made up of assignments) separated by newlines
{
one <- 1
pie <- pi
zee <- "z"
}

one
>  1
pie
>  3.141593
zee
>  "z"``````

Here’s another example:

``````z <- { x = 10 ; y = x^2; x + y }

x
>  10
y
>  100
z
>  110``````

Now that we’ve introduced the concept of compound expressions, we can move on to next chapter where we introduce conditional structures.