Chapter 4. Immutable Variables

Immutable variables is a topic that gives everyone the shudders when they first get into it. Let’s get the big question out of the way first: how can an application run if variables never change? This is a good question, so let’s look at the following rules about immutability:

  • Local variables do not change.
  • Global variables can change only references.

Object variables, especially in Java, are references to the object itself. This means that changing the “reference” to which the variable points should be an atomic process. This is important because if we are going to update the variable, we will access it either pre- or post-update but never in an intermediate state. We’ll discuss this a little later, but right now, let’s look at mutability.

We’re Getting Groovy Now

Remember from the preceding chapter that we’re going to be writing in Groovy from this point on.


When we think of variables, we normally think of mutable variables. After all, a variable is variable, which means that we should be able to store many different values in it and reuse it.

As we think of mutable variables, we realize that this is how we normally write code—with variables that inherently change over time. In Example 4-1, notice how f changes and is assigned two distinct values? This is how we normally deal with variables.

Example 4-1. Modifying a variable
def f = 10
f = f + f

So what happens when we have a variable that is passed to a function and we try to mutate that? Let’s ...

Get Becoming Functional now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.