Immutability is a foundational concept in functional programming, and it plays a central role in Scala. Immutability refers to the inability to change the state of an object once it has been created. This article aims to unravel the concept of immutability in Scala, focusing on its importance, how it’s implemented, and its practical applications, all through clear examples.
Immutability: What is it?
In programming, an object is said to be immutable if its state cannot be changed after creation. In Scala, you can create immutable variables using the val keyword. Once defined, their value remains constant, and any attempt to change it results in a compilation error.
Benefits of Immutability
Safety in Concurrency: With no way to change the state, immutable objects are inherently thread-safe.
Predictability: Code is more predictable when data cannot change unexpectedly.
Simpler Reasoning: Immutability simplifies understanding how code behaves, making maintenance and debugging easier.
Declaring Immutable Variables in Scala
In Scala, you can declare an immutable variable using the val keyword:
val name = "John"
If you try to reassign the value:
name = "Doe" // This will result in a compilation error
You will encounter a compilation error stating reassignment to val.
Immutable Collections
Scala also encourages the use of immutable collections. These collections cannot be altered after they are created. Here’s how you can create an immutable list:
Trying to add a new element to the list without creating a new list will result in a compilation error.
Example: Using Immutable Variables
Let’s take a closer look at how immutability can be applied in a real-world example. Suppose we’re dealing with bank accounts, and we want to ensure that the account number remains constant once the account is created.
class BankAccount(val accountNumber: String, var balance: Double) {
def deposit(amount: Double): Unit = {
balance += amount
}
// Other methods here
}
In this example, the account number is an immutable value (declared with val), while the balance is mutable (declared with var). The account number cannot be changed, ensuring the integrity of the account.
