Val or var, mutable or immutable?

There is nothing in the syntax of the declaration of the class String that enforces it as immutable; rather, none of the String class's methods ever affect the data that a String object contains, thus making it immutable. By default, fields and local variables are mutable. They can be made immutable using the final keyword.

Primitive wrappers (Integer, Long, Short, Double, Float, Character, Byte, Boolean) are also all immutable. Immutable classes can be implemented by following a few simple guidelines. In Python, some built-in types (numbers, booleans, strings, tuples, frozensets) are immutable, but custom classes are generally mutable.

In JavaScript, some built-in types (numbers, strings) are immutable, but custom classes are generally mutable. Racket substantially diverges from other Scheme implementations by making its core pair type ("cons cells") immutable. Instead, it provides a parallel mutable pair type, via mcons, mcar, set-mcar!

Etc. In addition, many immutable types are supported, for example, immutable strings and vectors, and these are used extensively. The language also supports immutable hash tables, implemented functionally, and immutable dictionaries.

In Scala, any variable can be defined as mutable or immutable: in the declaration, one can use val (value) for immutable variables and var (variable) for mutable ones. Note that even though an immutable variable can not be reassigned, it may still refer to a mutable object and it is still possible to call mutating methods on that object. Defines an immutable entity maxValue (the integer type is inferred at compile-time) and a mutable entity named currentValue.

By default, collection classes such as List and Map are immutable, so update-methods return a new instance rather than mutating an existing one. While this may sound inefficient, the implementation of these classes and their guarantees of immutability mean that the new instance can re-use existing nodes, which, especially in the case of creating copies, is very efficient. A technique that blends the advantages of mutable and immutable objects, and is supported directly in almost all modern hardware, is copy-on-write (COW).

Using this technique, when a user asks the system to copy an object, it will instead merely create a new reference that still points to the same object. As soon as a user modifies the object through a particular reference, the system makes a real copy and sets the reference to refer to the new copy.