Enforced immutability: Difference between revisions

Prepend V/var keyword with minus sign to make variable immutable:

=={{header|6502 Assembly}}==

Side note: Trying to write to ROM at runtime will typically have no effect, but can also interact with memory-mapped ports resulting in undesired operation. (Some NES/Famicom cartridges would access mapper hardware by writing values to ROM)

Labeled constants are also immutable, as the assembler replaces them with their equivalent values during the assembly process. The 6502 isn't aware those labels ever existed.

=={{header|68000 Assembly}}==

Most assemblers allow you to define labels which can refer to constant values for clarity.

bit6 equ %01000000

MOVE.B (A0),D0

AND.B #bit7,D0

When the program is being assembled, the assembler dereferences the labels and replaces them in-line with the labeled constants. They cannot be altered at runtime (except with self-modifying code).

=={{header|8th}}==

Items in 8th are constants if they are declared inside a word (function). Otherwise, they are mutable, unless the "const" word is used:

123 const var, one-two-three

That declares that the number 123 is constant and may not be modified (not that the variable named 'one-two-three' is constant)

To declare a global constant, use:

Subsequent attempts to redefine the constant give an error:

=={{header|Ada}}==

Ada provides the <code>constant</code> keyword:

Types can be declared as limited: Objects of these types cannot be changed and also not compared nor copied:

X, Y: T;

B: Boolean;

X := Y; -- illegal (cannot be compiled

B := X = Y; -- illegal

=={{header|ALGOL 68}}==

When a ''name'' is defined it can be identified as a constant value with an equality, eg pi = 355/113.

For a variable an assignment ":=" would be used instead, eg pi := 355/113;

REAL pi = 3.1415 9265; # pi is constant that the compiler will enforce #

REF REAL var = LOC REAL; # var is a constant pointer to a local REAL address #

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

It should be noted that Enforced immutability goes against the nature of AHK. However, it can be achieved using objects:

MsgBox % "MyData.Data = " MyData.Data

MyData.Data := "This will fail to set"

return

}

You could still use ''ObjInsert/ObjRemove'' functions, since they are designed to bypass any custom behaviour implemented by the object. Also, technically you could still use the ''SetCapacity method'' to truncate the object, or the ''GetAddress method'' to modify the object using memory addresses.

=={{header|BASIC}}==

Many BASICs support the <code>CONST</code> keyword:

Some flavors of BASIC support other methods of declaring constants. For example, [[FreeBASIC]] supports C-style defines:

=={{header|BBC BASIC}}==

BBC BASIC doesn't have named constants. The closest you can get is to use a function:

PRINT FNconst

=={{header|Bracmat}}==

All values (expressions) in Bracmat are immutable, except those that contain <code>=</code> operators.

changed:?(myVar.m);

lst$myVar

{{out}}

<pre>(myVar=

=={{header|C}}==

You can create simple constants using the C preprocessor:

#define MINSIZE 10

Alternatively, you can modify parameters and variables with the const keyword to make them immutable:

const double pi = 3.14159;

const double minsize = 10;

{

/* ... */

It is possible to remove the <tt>const</tt> qualifier of the type a pointer points to through a cast, but doing so will result in undefined behavior.

=={{header|C sharp|C#}}==

Fields can be made read-only (a runtime constant) with the '''readonly''' keyword.

When used on reference types, it just means the reference cannot be reassigned. It does not make the object itself immutable.<br/>

Primitive types can be declared as a compile-time constant with the '''const''' keyword.

Parameters can be made readonly by preceding them with the '''in''' keyword. Again, when used on reference types, it just means the reference cannot be reassigned.

x = 5; //Compile error

Local variables of primitive types can be declared as a compile-time constant with the '''const''' keyword.

const double sqrt5 = 2.236;

...

To make a type immutable, the programmer must write it in such a way that mutation is not possible. One important way to this is to use readonly properties. By not providing a setter, the property can only be assigned within the constructor.

On value types (which usually should be immutable from a design perspective), immutability can be enforced by applying the '''readonly''' modifier on the type. It will fail to compile if it contains any members that are not read-only.

{

public Point(int x, int y) => (X, Y) = (x, y);

public int X { get; }

public int Y { get; }

On a struct that is not made readonly, individual methods or properties can be made readonly by applying the '''readonly''' modifier on that member.

{

public readonly int Length => 3;

=={{header|C++}}==

In addition to the examples shown in [[#C|C]], you can create a class whose instances contain instance-specific const members, by initializing them in the class's constructor.

class MyOtherClass

return 0;

You can also use the const keyword on methods to indicate that they can be applied to immutable objects:

{

private:

return x;

}

=={{header|Clojure}}==

Everything in Clojure except for Java interop are immutable.

#'user/d

user> (assoc d 3 7)

[1 2 3 7 5]

user> d

=={{header|COBOL}}==

Constants in COBOL are not stored in memory, but are closer to C's macros, by associating a literal with a name.

Prior to COBOL 2002, you could define figurative literals for characters only:

CONFIGURATION SECTION.

SPECIAL-NAMES.

A new syntax was introduced in COBOL 2002 which allowed defining constants for other types.

Prior to COBOL 2002, there were non-standard extensions available that also implemented constants. One extension was the the 78 level-number:

Another was the <code>CONSTANT SECTION</code>:

=={{header|D}}==

// enum allows to define manifest (compile-time) constants:

// Not allowed, the setter property is missing:

// t.x = 10; // Error: not a property t.x

=={{header|Delphi}}==

Typed constants can be assigned to using the {$WRITABLECONST ON} or {J+} compiler directives (off by default).

STR1 = 'abc'; // regular constant

=={{header|Dyalect}}==

Dyalect supports creation of constants using "let" keyword:

A constant can contain a value of any type:

=={{header|E}}==

Variables are immutable unless declared with the '<code>var</code>' keyword.

Below the surface, each variable name is bound to a Slot object, which can be thought of as a one-element collection. If the var keyword is used, then the slot object is mutable; else, immutable. It is never possible to change the slot a name is bound to.

Any object which is immutable and contains no immutable parts has the property DeepFrozen.

def things :DeepFrozen := [&x, 2, 3] # This is OK

(The unary <code>&</code> operator gets the slot of a variable, and can be thought of almost exactly like C's <code>&</code>.)

Normally there is no need to enforce immutability in Ela - everything is immutable by default. Ela doesn't support mutable variables like imperative languages. All built-in data structures are immutable as well. The only way to create a mutable data structure is to use an unsafe module "cell", that implements reference cells in Ocaml style:

Function mutate can be used to mutate a reference cell:

In order to unwrap a value from a cell one can use a valueof function:

=={{header|Elixir}}==

Erlang variables are immutable by nature. The following would be an error:

However, since = actually performs pattern matching, the following is permissible:

=={{header|Euphoria}}==

constant s = {1,2,3}

=={{header|F_Sharp|F#}}==

As a functional language, everything in F# is immutable by default. Interestingly, <code>const</code> is a reserved word but is non-functional.

=={{header|Factor}}==

Tuple slots may be declared <code>read-only</code>. For example, the <code>range</code> tuple declares its slots <code>read-only</code>:

Note that the <code>CONSTANT:</code> word does nothing to enforce immutability on the object it places on the stack, as it is functionally equivalent to a standard word definition with stack effect <code>( -- obj )</code>.

=={{header|Forth}}==

Forth has constant, 2constant and fconstant for creating named constants. This can only be done for global scoped objects, not for function parameters.

256 constant one-hex-dollar

s" Hello world" 2constant hello \ "hello" holds the address and length of an anonymous string.

355 119 2constant ratio-pi \ 2constant can also define ratios (e.g. pi)

3.14159265e fconstant pi

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

In type declaration statements a PARAMETER attribute can be specified turning the data object into a named constant.

Dummy arguments of procedures can be given an INTENT attribute. An argument with INTENT(IN) cannot be changed by the procedure

=={{header|FreeBASIC}}==

dim as const uinteger IMMUT2 = 2222 'or explicitly declared as constants

=={{header|Go}}==

Strings in Go are immutable. Attempts to modify them fail to compile:

func main() {

s := "immutable"

s[0] = 'a'

<pre>

test.go:5: cannot assign to s[0]

=={{header|Haskell}}==

Since Haskell is purely functional everything is immutable by default.

=={{header|Icon}} and {{header|Unicon}}==

In Icon and Unicon pretty much everything can be changed. There really isn't an easy way to protect a variable from being changed. There are compile time constants created by ''$define'' (as shown); although, they can be explicitly undefined. String values themselves are immutable; however, manipulating them creates new string values. The effect is that the value assigned to a variable will change even though the value itself won't. For more see [[Icon%2BUnicon/Intro#Mutable_and_Immutable_Types|Mutable and Immutable Types]].

=={{header|J}}==

(Tangentially: note that J has a rich language for defining numeric constants. For example, 2*pi represented as a floating point number would be 2p1. These are analogous to names but can never be modified.)

A=: '*' 2 3 5 7} A

A

th** *s*a test

B

C=: 'this is a test'

1 readonly_jmf_ 'C'

| C =:'some new value'

C

=={{header|Java}}==

Variables in Java can be made immutable by using the <code>final</code> modifier (works on any type, primitive or reference):

int mutableInt = 4;

mutableInt = 6; //this is fine

Using final on a reference type means the reference cannot be reassigned, but does not necessarily mean that the object that it points to can't be changed:

immutableString = new String("anotherTest"); //this is an error

final StringBuffer immutableBuffer = new StringBuffer();

immutableBuffer.append("a"); //this is fine and it changes the state of the object

Whether an object can be modified is entirely up to whether the object provides either methods or non-final public/protected fields for mutation. Objects can be made immutable (in a sense that is more appropriate for this task) by making all fields <code>final</code> or <code>private</code>, and making sure that no methods modify the fields:

private final int num;

private final String word;

}

//no "set" methods are given

In the <code>Immute</code> class above, the object pointed to by "buff" is still technically mutable, since its internal values can still be changed. The <code>private</code> modifier ensures that no other classes can access that variable. Some trickery needed to be done to ensure that no pointers to the actual mutable objects are passed out. Programmers should be aware of which objects that they use are mutable (usually noted in javadocs).

'''Update''': const is now a standard part of ES6 JavaScript, and works with all data types, including arrays, objects, and parameters. It is not, however, included in the ES5 standard.

=={{header|jq}}==

Here, the result is ["a", "b"].

{{works with|Julia|0.6}}

=={{header|Kotlin}}==

Here are some examples:

// constant top level property

println(mc.myInt)

mc.myFunc(0)

{{out}}

=={{header|Logtalk}}==

Logtalk supports both static and dynamic objects. Static objects are usually defined in source files. Object predicates are static by default. These objects can be defined locked against runtime modifications. For simplicity, the following example uses a prototype:

:- object(immutable).

:- end_object.

=={{header|Lua}}==

{{works with|lua|5.4}}

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{"Tau"}

Tau = 2

=={{header|MBS}}==

=={{header|Nemerle}}==

Everything is immutable by default.

=={{header|Nim}}==

let y = "immutablefoo" # Immutable variable, at runtime

const z = "constantfoo" # Immutable constant, at compile time

x[0] = 'M'

y[0] = 'I' # Compile error: 'y[0]' cannot be assigned to

=={{header|OCaml}}==

File <code>ImString.mli</code> containing the interface:

val create : int -> im_string

val index : im_string -> char -> int

val contains : im_string -> char -> bool

File <code>ImString.ml</code> containing the "implementation":

let create = String.create

let of_string s = s

let to_string s = s

Here we can see that in the implementation the new type for immutable strings is defined with <code>type im_string = string</code>, and the definition of this type is hidden in the interface with <code>type im_string</code>.

All these rules are checked at runtime and exceptions are raised if a piece of code breaks those immutability rules.

MyClass method: setA(value) value := a ;

MyClass new(ListBuffer new, 12) // KO : Not an immutable value.

ListBuffer new Constant new: T // KO : A constant cannot be mutable.

=={{header|PARI/GP}}==

=={{header|Perl}}==

The constant pragma allows you to create subroutines that always return the same value and that cannot be modified:

The module Readonly.pm provides a means of enforcing immutablity upon scalars and arrays, however, this imposes a considerable performance penalty:

Readonly::Scalar my $pi => 3.14159;

"b" => 2,

"c" => 3

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">str</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"immutable string"</span>

You can also optionally enforce one-off initial typechecks. In the following the compiler may infer the types and optimise away the typecheck, however for more complex initialisations this may lead to performance improvements later on, assuming eg a fatal `typecheck error, n is "no such directory"` is acceptable/wanted.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #008080;">constant</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">}</span>

<span style="color: #008080;">constant</span> <span style="color: #004080;">string</span> <span style="color: #000000;">str</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"immutable string"</span>

=={{header|PHP}}==

You can create constants using the define function. This only works with scalars.

Or: {{works with|PHP|5.3+}}

http://us.php.net/manual/en/language.constants.syntax.php

In PicoLisp it is a central design issue that the programmer is in control of everything, and thus can modify any value. Even program parts written in C or assembly can be changed on the fly.

The nearest thing would be to define a function, e.g.

-> pi

: (pi)

but even this could be modified, e.g.:

-> 3

: (pi)

=={{header|PL/I}}==

PL/I supports Named Constants. This avoids the default data attributes used when writing ''simple'' constants (such as 3).

constants: Proc Options(main);

Dcl three Bin Fixed(15) Value(3);

Put Skip List(1/three);

Put Skip List(1/3);

{{out}}

<pre> 0.33333332

=={{header|PowerBASIC}}==

Constants are declared by prefacing the variable name with <code>$</code> for strings and <code>%</code> for numeric variables:

=={{header|PureBasic}}==

PureBasic does not natively use immutable variables, only constants.

#i_Const2 = 3.1415

However using an OO approach, PureBasic allows for creation of new variable classes such as immutable ones.

Interface PBVariable ; Interface for any value of this type

;- And clean up

*v1\Destroy()

=={{header|Python}}==

Some datatypes such as strings are immutable:

>>> s[0] = "h"

File "<pyshell#1>", line 1, in <module>

s[0] = "h"

While classes are generally mutable, you can define immutability by overriding __setattr__:

def __setattr__(self, *args):

raise TypeError(

"'Immut' object does not support item assignment")

TypeError: 'Immut' object does not support item assignment

=={{header|Racket}}==

In addition, new type definitions using <tt>struct</tt> are immutable by default:

mutable struct definitions need to explicitly use a <tt>#:mutable</tt>, keyword next to a field to specify it as mutable, or as an option to the whole struct to make all fields mutable.

(formerly Perl 6)

You can create constants in Raku with <code>constant</code>:

constant $msg = "Hello World";

Immutability is abstract enough that you can define an infinite constant lazily:

Variables are considered mutable by default, but may be marked as readonly after initialization:

Unlike variables, formal parameters are considered readonly by default even if bound to a mutable container.

$x += $y; # ERROR

}

$x += $y; # ok, but NOT propagated back to caller

$x;

A number of built-in types are considered immutable value types, including:

<pre>Str String (finite sequence of Unicode characters)

=={{header|REXX}}==

Programming note: &nbsp; The REXX language doesn't have immutable variables as such, but the method can be emulated with a simple subroutine. &nbsp; Immutable variables are set via a REXX subroutine which makes a shadow copy of the variable. &nbsp; Later, the same subroutine can be invoked (mutiple times if wanted) to check if any immutable variables have been altered (compromised). &nbsp; Three REXX variables are preempted: '''immutable.''', '''_''', and '''__''' &nbsp; (the last two are just used for temporary variables and any unused variable names can be used).

call immutable '$=1' /* ◄─── assigns an immutable variable. */

call immutable ' pi = 3.14159' /* ◄─── " " " " */

return words(immutable.0) /*return number immutables. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output'''

<pre>

=={{header|Ring}}==

# Project : Enforced immutability

assert( x = 10)

assert( x = 100 )

Output:

<pre>

=={{header|Ruby}}==

You can make things immutable at run-time with Ruby using the built-in Object#freeze method:

msg << "!"

puts msg #=> Hello World!

puts msg.frozen? #=> false

Since Ruby version 2.1 freezing strings can give a performance boost.

There is no way to unfreeze a frozen object.

The freeze can not be canceled but the object of approximately the same contents not to freeze up can be gotten if using Object#dup.

msg = "Hello World!".freeze

msg2 = msg.clone # Copies the frozen and tainted state of obj.

puts msg3 #=> Hello World!

puts msg2.frozen? #=> true

=={{header|Rust}}==

Rust <tt>let</tt> bindings are immutable by default. This will raise a compiler error:

You must declare a variable mutable explicitly:

Similarly, references are immutable by default e.g.

let y = &x;

*y += 2 // Raises compiler error. Even though x is mutable, y is an immutable reference.

// Note that though y is now a mutable reference, y itself is still immutable e.g.

let mut z = 5;

=={{header|Scala}}==

=={{header|Scheme}}==

This R6RS macro can be effortlessly ported to [[Racket]] by replacing <tt>make-variable-transformer</tt> with <tt>make-set!-transformer</tt> and <tt>(raise (syntax-violation ...))</tt> with <tt>(raise-syntax-error ...)</tt>.

(syntax-rules ()

((_ id v)

'set! "Cannot redefine constant" stx #'id)))

((id . args) #'(_id . args))

Example use case:

;;

fnord

;; => 28

(set! fnord 42)

It works with procedures as well:

;;

square

;; => 25

(set! square (lambda (n) (* n n n)))

=={{header|Seed7}}==

Seed7 provides <code>const</code> definitons.

Constants can have any type:

const string: bar is "bar";

Constants can be initialized with expressions:

Any function, even user defined functions can be used to initialize a constant:

return degree * PI / 180.0;

The initialisation expression is evaluated at compile-time.

It is possible to initialize a constant with data from the file system:

The compiler can even get initialisation data from the internet:

Types are also defined as constants (in other languages this is called a ''typedef''):

Function definitions (see above for the definition of ''deg2rad'') have also the form of a <code>const</code> definition.

=={{header|Sidef}}==

=={{header|SuperCollider}}==

b = [1, 2, 3];

b[1] = 100; // returns [1, 100, 3]

b.freeze; // make b immutable

=={{header|Swift}}==

Swift has a notion of immutable values built into the language.

a = 1 // error: a is immutable

var b = 1

It also extends this to higher level data structures. For example Swift has a notion of value types vs reference types.

struct Point {

var x: Int

let pClass = ClassPoint(x: 1, y: 1)

Value types are always passed by value. This applies to collections in Swift.

// A common Swift beginner trap

func addToArray(_ arr: [Int]) {

let array = [1]

addToArray(array)

=={{header|Tcl}}==

Although there is no built-in support for constants, it is trivial to construct on top of Tcl's variable tracing facility:

upvar 1 $varName var

# Allow application of immutability to an existing variable, e.g., a procedure argument

return -code error "immutable"

}} $value]

Interactive demonstration:

% puts "pi=$pi"

pi=3.14159

can't set "pi": immutable

% puts "pi is still $pi"

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

==={{header|C Shell}}===

=={{header|XPL0}}==

Pi:= 3.15; \causes a compile error: statement starting with a constant

=={{header|Vlang}}==

To change the values of variables, arguments, and struct fields the keyword "mut" is used.

mut age := 20

mut s := 'hello'

=={{header|Wren}}==

Note though that if fields are reference types (lists, maps, user-defined classes etc.) even a 'getter' method may enable their internal state to be mutated unless you copy them first.

construct new(f) {

_f = f // sets field _f to the argument f

System.print(a.f)

a.f = 8

{{out}}

Side note: Trying to write to ROM at runtime will simply have no effect, and will not raise any kind of hardware exception or segfault.

=={{header|zkl}}==

Mutability is up to each object. Strings, numbers are immutable. Lists can be either. Dictionaries can switch.

ROList(1,2,3).del(0) //-->SyntaxError : Can't find del, which means you can't call it

d:=Dictionary(); d.add("one",1)

D(one:1)