1. Concepts
     Immutable variables    Weak vs strong immutability    References to objects    Copying objects    Copy-on-write    Interning    Thread safety    Violating immutability  

2. Language-specific details
     Ada    C#    C++    D    Java    Perl    Python    JavaScript    Racket    Scala  

3. See also

4. References

5. External links

In object-oriented and functional programming, an immutable object (unchangeable^[1] object) is an object whose state cannot be modified after it is created.^[2] This is in contrast to a mutable object (changeable object), which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.

Strings and other concrete objects are typically expressed as immutable objects to improve readability and runtime efficiency in object-oriented programming. Immutable objects are also useful because they are inherently thread-safe.^[2] Other benefits are that they are simpler to understand and reason about and offer higher security than mutable objects.^[2]

Concepts

Immutable variables

In imperative programming, values held in program variables whose content never changes are known as constants to differentiate them from variables that could be altered during execution. Examples include conversion factors from meters to feet, or the value of pi to several decimal places.

Read-only fields may be calculated when the program runs (unlike constants, which are known beforehand), but never change after they are initialized.

Weak vs strong immutability

Sometimes, one talks of certain fields of an object being immutable. This means that there is no way to change those parts of the object state, even though other parts of the object may be changeable (weakly immutable). If all fields are immutable, then the object is immutable. If the whole object cannot be extended by another class, the object is called strongly immutable.^[3] This might, for example, help to explicitly enforce certain invariants about certain data in the object staying the same through the lifetime of the object. In some languages, this is done with a keyword (e.g. const in C++, final in Java) that designates the field as immutable. Some languages reverse it: in OCaml, fields of an object or record are by default immutable, and must be explicitly marked with mutable to be so.

References to objects

In most object-oriented languages, objects can be referred to using references. Some examples of such languages are Java, C++, C#, VB.NET, and many scripting languages, such as Perl, Python, and Ruby. In this case, it matters whether the state of an object can vary when objects are shared via references.

Copying objects

If an object is known to be immutable, it can be copied simply by making a copy of a reference to it instead of copying the entire object. Because a reference (typically only the size of a pointer) is usually much smaller than the object itself, this results in memory savings and a potential boost in execution speed.

The reference copying technique is much more difficult to use for mutable objects, because if any user of a mutable object reference changes it, all other users of that reference see the change. If this is not the intended effect, it can be difficult to notify the other users to have them respond correctly. In these situations, defensive copying of the entire object rather than the reference is usually an easy but costly solution. The observer pattern is an alternative technique for handling changes to mutable objects.

Copy-on-write

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 instead merely creates a new reference that still points to the same object. As soon as a user attempts to modify the object through a particular reference, the system makes a real copy, applies the modification to that, and sets the reference to refer to the new copy. The other users are unaffected, because they still refer to the original object. Therefore, under COW, all users appear to have a mutable version of their objects, although in the case that users do not modify their objects, the space-saving and speed advantages of immutable objects are preserved. Copy-on-write is popular in virtual memory systems because it allows them to save memory space while still correctly handling anything an application program might do.

Interning

The practice of always using references in place of copies of equal objects is known as interning. If interning is used, two objects are considered equal if and only if their references, typically represented as pointers or integers, are equal. Some languages do this automatically: for example, Python automatically interns short strings. If the algorithm that implements interning is guaranteed to do so in every case that it is possible, then comparing objects for equality is reduced to comparing their pointers – a substantial gain in speed in most applications. (Even if the algorithm is not guaranteed to be comprehensive, there still exists the possibility of a fast path case improvement when the objects are equal and use the same reference.) Interning is generally only useful for immutable objects.

Thread safety

Immutable objects can be useful in multi-threaded applications. Multiple threads can act on data represented by immutable objects without concern of the data being changed by other threads. Immutable objects are therefore considered more thread-safe than mutable objects.

Violating immutability

Immutability does not imply that the object as stored in the computer's memory is unwriteable. Rather, immutability is a compile-time construct that indicates what a programmer can do through the normal interface of the object, not necessarily what they can absolutely do (for instance, by circumventing the type system or violating const correctness in C or C++).

Language-specific details

In Python, Java and the .NET Framework, strings are immutable objects. Both Java and the .NET Framework have mutable versions of string. In Java these are StringBuffer and StringBuilder (mutable versions of Java {{Javadoc:SE|java/lang|String}}) and in .NET this is StringBuilder (mutable version of .Net String). Python 3 has a mutable string (bytes) variant, named bytearray.^[4]

Additionally, all of the primitive wrapper classes in Java are immutable.

Similar patterns are the Immutable Interface and Immutable Wrapper.

In pure functional programming languages it is not possible to create mutable objects without extending the language (e.g. via a mutable references library or a foreign function interface), so all objects are immutable.

Ada

In Ada, any object is declared either variable (i.e. mutable; typically the implicit default), or constant (i.e. immutable) via the constant keyword.

  type Some_type is new Integer; -- could be anything more complicated  x: constant Some_type:= 1; -- immutable  y: Some_type; -- mutable

Subprogram parameters are immutable in the in mode, and mutable in the in out and out modes.

  procedure Do_it(a: in Integer; b: in out Integer; c: out Integer) is  begin    -- a is immutable    b:= b + a;    c:= a;  end Do_it;

C#

In C# you can enforce immutability of the fields of a class with the readonly statement.

By enforcing all the fields as immutable, you obtain an immutable type.

    public readonly double _value;    public AnImmutableType(double x)     {       _value = x;     }    public AnImmutableType Square()     {       return new AnImmutableType(_value*_value);     }

C++

In C++, a const-correct implementation of Cart would allow the user to declare new instances of the class as either const (immutable) or mutable, as desired, by providing two different versions of the getItems() method. (Notice that in C++ it is not necessary — and in fact impossible — to provide a specialized constructor for const instances.)

  private:   std::vector items;

  public:   Cart(const std::vector& v): items(v) { }

   std::vector& getItems() { return items; }   const std::vector& getItems() const { return items; }   int total() const { /* return sum of the prices */ } };

Note that, if there were a field that is a pointer or reference to another object, then it might still be possible to mutate the object pointed to by such a pointer or reference within a const method, without violating const-correctness. It can be argued that in such a case the object is not really immutable.

C++ also provides abstract (as opposed to bitwise) immutability via the mutable keyword, which lets a member variable be changed from within a const method.

  private:   std::vector items;   mutable int    costInCents;   mutable bool   totaled;

  public:   Cart(const std::vector& v): items(v), totaled(false) { }

   const std::vector& getItems() const { return items; }   int total() const {      if (!totaled) {         costInCents = 0;         for (std::vector::const_iterator itor = items.begin(); itor != items.end(); ++itor)            costInCents += itor->costInCents();

         totaled = true;      }      return costInCents;   } };

D

In D, there exist two type qualifiers, const and immutable, for variables that cannot be changed.^[5] Unlike C++'s const, Java's final, and C#'s readonly, they are transitive and recurively apply to anything reachable through references of such a variable. The difference between const and immutable is what they apply to: const is a property of the variable: there might legally exist mutable references to referred value, i.e. the value can actually change. In contrast, immutable is a property of the referred value: the value and anything transitively reachable from it cannot change (without breaking the type system, leading to undefined behavior). Any reference of that value must be marked const or immutable. Basically for any unqualified type T, const(T) is the disjoint union of T (mutable) and immutable(T).

  /*mutable*/ Object mField;    const     Object cField;    immutable Object iField;

For a mutable C object, its mField can be written to. For a const(C) object, mField cannot be modified, it inherits const; iField is still immutable as it its the stronger guarantee. For an immutable(C), all fields are immutable.

In a function like this:

Inside the braces, c might refer to the same object as m, so mutations to m could indirectly change c as well. Also,

c might refer to the same object as i, but since the value then is immutable, there are no changes. However, m and i cannot legally refer to the same object.

In the language of guarantees, mutable has no guarantees (the function might change the object), const is an outward-only guarantee that the function will not change anything, and

immutable is a bidirectional guarantee (the function will not change the value and the caller must not change it).

Values that are const or immutable must be initialized by direct assignment at the point of declaration or by a constructor.

Because const parameters forget if the value was mutable or not, a similar construct, inout, acts, in a sense, as a variable for mutablity information.

A function of type const(S) function(const(T)) returns const(S) typed values for mutable, const and immutable arguments. In contrast, a function of type inout(S) function(inout(T)) returns S for mutable T arguments, const(S) for const(T) values, and immutable(S) for immutable(T) values.

Casting immutable values to mutable inflicts undefined behavior upon change, even if the original value comes from a mutable origin. Casting mutable values to immutable can be legal when there remain no mutable references afterward. "An expression may be converted from mutable (...) to immutable if the expression is unique and all expressions it transitively refers to are either unique or immutable."^[5] If the compiler cannot prove uniqueness, the casting can be done explicitly and it is up to the programmer to ensure that no mutable references exist.

The type string is an alias for immutable(char)[], i.e. a typed slice of memory of immutable characters.^[6] Making substrings is cheap, as it just copies and modifies a pointer and a length filed, and safe, as the underlying data cannot be changed. Objects of type const(char)[] can refer to strings, but also to mutable buffers.

Making a shallow copy of a const or immutable value removes the outer layer of immutablity: Copying an immutable string (immutable(char[])) returns a string (immutable(char)[]). The immutable pointer and length are being copied and the copies are mutable. The referred data has not been copied and keeps its qualifier, in the example immutable. It can be stripped by making a depper copy, e.g. using the dup function.

Java

A classic example of an immutable object is an instance of the Java String class

The method toLowerCase() does not change the data "ABC" that s contains. Instead, a new String object is instantiated and given the data "abc" during its construction. A reference to this String object is returned by the toLowerCase() method. To make the String s contain the data "abc", a different approach is needed:

Now the String s references a new String object that contains "abc". 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.

The keyword final (detailed article) is used in implementing immutable primitive types and object references,^[7] but it cannot, by itself, make the objects themselves immutable. See below examples:

Primitive type variables (int, long, short, etc.) can be reassigned after being defined. This can be prevented by using final.

    is      => 'ro',   # read only    default => 'data', # can be overridden by supplying the constructor with                       # a value: Immutable->new(value => 'something else');

    my $class = shift;    return $class if ref($class);    die "Arguments to new must be key => value pairs\"        unless (@_ % 2 == 0);    my %defaults = (        value => 'data',    );    my $obj = {        %defaults,        @_,    };    bless $obj, $class;    # prevent modification of the object data    lock_hash %$obj;

    my $class = shift;    return $class if ref($class);    die "Arguments to new must be key => value pairs\"        unless (@_ % 2 == 0);    my %defaults = (        value => 'data',    );    my $obj = {        %defaults,        @_,    };    bless $obj, $class;    # prevent modification of the object data    lock_hash %$obj;

    my $self = shift;    if (my $new_value = shift) {        # trying to set a new value        die "This object cannot be modified\";    } else {        return $self->{value}    }

    def __setattr__(self, *args):        raise TypeError("Can not modify immutable instance")

    def __init__(self, x, y):        # We can no longer use self.value = value to store the instance data        # so we must explicitly call the superclass        super(ImmutablePoint, self).__setattr__('x', x)        super(ImmutablePoint, self).__setattr__('y', y)

• Wisznice Commune
• Wiszniow
• Wiszniów
• Wiszno
• Wiszowate
• Wisówka
• Wisła Stadium
• Wisław
• Wisławie
• Wisławka
• Wisław, West Pomeranian Voivodeship
• Wisłoczek
• Wisłok Wielki
• Wisłowiec
• WITA (AM)
• Witaehan kaetcheubi
• Witagron
• Witakete United
• Witalij K.
• Witalij Kalojew
• Witali Kalojew
• Witalis Ludwiczak
• Witalis Peak
• Witalowka
• Witalówka