Scala immutable vs mutable. What is the way one should go?

Question

I'm just learning to program in scala. I have some experience in functional programming, as I have in object oriented programming. My question is kind of simple, yet tricky:

Which structures should be used in Scala? Should we only stick to immutables, eg. modifing lists by iterating through it and stick a new one together, or go for mutables? What is your opinion on that, what are the performance aspects, memory related aspects, ...

I'm likely to program in a functional style, but it often expands to an insane amount of effort to do things which are easily done by using mutables. Is it situation dependent, what to use?

Answer 1

Prefer immutable to mutable state. Use mutable state only where it is absolutely necessary. Some notable reasons include:

• Performance. The standard libraries make wide use of vars and while loops, even though this is not idiomatic Scala. This should not be emulated, however, except for cases where you have profiled to determine that modifying the code to be more imperative will bring a significant performance gain.

• I/O. I/O, or interacting with the outside world is inherently state dependent, and thus must be dealt with in a mutable manner.

This is no different than the recommended coding style found in all major languages, imperative or functional. For example, in Java it is preferable to use data objects with only private final fields. Code written in an immutable (and functional) way is inherently easier to understand because when one sees a val, they know it will never change, reducing the possible number of states any particular object or function can be in.

In many cases, it also allows automatic parallel execution, for example, collection classes in Scala all have a par function, which will return a parallel collection that automatically run the calls to functions like map or reduce in parallel.