assignment

In computer programming, an assignment statement sets or re-sets the value stored in the storage location(s) denoted by a variable name. In most imperative computer programming languages, assignment statements are one of the basic statements. Common notations for the assignment operator are = and :=.^[1]

Assignment statements typically allow for the same variable to contain different values at different times during program execution. Thus, languages featuring destructive assignment rarely enforce referential transparency, which requires a procedure to return the same results for a given set of inputs at any point in time.

Semantics

An assignment operation is a process in imperative programming in which different values are associated with a particular variable name as time passes.^[2] The program, in such model, operates by changing its state using successive assignment statements.^[1][3] Primitives of imperative programming languages rely on assignment to do iteration.^[4] At the lowest level, assignment is implemented using machine operations such as MOVE or STORE.^[1][4]

The variables are containers for values. It is possible to put a value into variable and later replace it with a new one. An assignment operation modifies the current state of the executing program.^[3] Consequently, assignment is dependent on the concept of variables. In an assignment:

• The expression is evaluated in the current state of the program.
• The variable is assigned the computed value, replacing the prior value of that variable.

Example: Assuming that a is a numeric variable, the assignment a := 2*a means that the content of the variable a is doubled after the execution of the statement. The case that the assigned value depends on previous one is so common that many imperative languages, most notably C and the majority of its descendants, augment the notion of assignment by defining special binary operators like *= for convenience so that the example becomes a *= 2.^[3]

An example segment of C code:

int x = 10; 
float y;
x = 23;
y = 32.4;

In this sample, the variable x is first declared as an int, and is then assigned the value of 10. Notice that the declaration and assignment occur in the same statement. In the second line, y is declared without an assignment. In the third line, x is reassigned the value of 23. Finally, y is assigned the value of 32.4.

For an assignment operation, it is necessary that the value of the expression is well-defined (it is a valid rvalue) and that the variable represents a modifiable entity (it is a valid modifiable (non-const) lvalue). In some languages, typically dynamic ones, it is not necessary to declare a variable prior to assigning it a value.

Single assignment

In pure functional programming, destructive assignment is not allowed, because of side effects^[5]

Any assignment that changes an existing value (e.g. x := x + 1) is disallowed in purely functional languages.^[4] In functional programming, assignment is discouraged in favor of single assignment, also called initialization. Single assignment is an example of name binding and differs from assignment as described in this article in that it can only be done once, usually when the variable is created; no subsequent re-assignment is allowed. Once created by single assignment, named values are not variables but immutable objects.

An evaluation of expression does not have a side effect if it does not change an observable state of the machine,^[6] and produces same values for same input.^[4] Imperative assignment can introduce side effects while destroying and making the old value unavailable while substituting it with a new one,^[5] and is referred to as "destructive assignment" for that reason in LISP and functional programming, similar to destructive updating.

Single assignment is the only form of assignment available in purely functional languages, such as Haskell, which do not have variables in the sense of imperative programming languages^[4] but rather named constant values possibly of compound nature with their elements progressively defined on-demand. Purely functional languages can provide an opportunity for computation to be performed in parallel, avoiding von Neumann bottleneck of sequential one step at time execution, since values are independent of each other.^[7]

Impure functional languages provide both single assignment as well as true assignment (though true assignment is typically used with less frequency than in imperative programming languages). For example, in Scheme, both single assignment (with let) and true assignment (with set!) can be used on all variables, and specialized primitives are provided for destructive update inside lists, vectors, strings, etc. In OCaml, only single assignment is allowed for variables, via the let name = value syntax; however destructive update can be used on elements of arrays and strings with separate <- operator, as well as on fields of records and objects that have been explicitly declared mutable (meaning capable of being changed after their initial declaration) by the programmer.

Functional programming languages that use single assignment include Clojure, Erlang, F#, Haskell, Lava, Objective Caml, Oz, SASL, Scala (for vals), SISAL. Non-backtracking Prolog code can be considered explicit single-assignment, explicit in a sense that its (named) variables can be in explicitly unassigned state, or be set exactly once. In Haskell, by contrast, there can be no unassigned variables, and every variable can be thought of as being implicitly set to its value (or rather to a computational object that will produce its value on demand) when it is created.

Value of an assignment

In some programming languages, an assignment statement returns a value, while in others it does not.

In most expression-oriented programming languages (for example, C), the assignment statement returns the assigned value, allowing such idioms as x = y = a, in which the assignment statement y = a returns the value of a, which is then assigned to x. In a statement such as while (f = read()) {…}, the return value of a function is used to control a loop while assigning that same value to a variable.

In other programming languages, Scheme for example, the return value of an assignment is undefined and such idioms are invalid.

In Haskell,^[8] there is no variable assignment; but operations similar to assignment (like assigning to a field of an array or a field of a mutable data structure) usually evaluate to unit, the value of the unit type, which is typically the type of an expression that is evaluated purely for its side effects.

Chained assignment

A statement like w = x = y = z is called a chained assignment in which the value of z is assigned to multiple variables w, x, and y. Chained assignments are often used to initialize multiple variables, as in

a = b = c = d = f = 0

Not all programming languages support chained assignment.

In some programming languages (C for example), chained assignments are supported because assignments return values. In C++ they are also available for values of class types by making appropriate return type for the assignment operator. This is however strongly discouraged because it also allows values of class types to be assigned to temporary objects, which results in a statement with no effect (assignment to temporary objects is detected as error only for non-class types).

In Python, assignment statements are not expressions and thus do not return a value, but chained assignment is recognized and supported as a special case of the assignment statement.

Parallel assignment

Some programming languages, such as JavaScript (since 1.7), occam 2,^[9] Perl,^[10] Python,^[11] REBOL, Ruby,^[12], C++ (since C++11 using tuples), and Windows PowerShell allow several variables to be assigned in parallel, with syntax like:

a,b := 0,1

which simultaneously assigns 0 to a and 1 to b. If the right-hand side of the assignment is an array variable, this feature is sometimes called sequence unpacking:

var list := {0, 1}
a,b := list

The list will be unpacked so that 0 is assigned to a and 1 to b. More interestingly,

a,b := b,a

Swaps the values of a and b. In languages without parallel assignment, this would have to be written to use a temporary variable

var t := a
a := b
b := t

since a:=b ; b:=a leaves both a and b with the original value of b.

Parallel assignment was introduced in CPL in 1963, under the name simultaneous assignment.^[13]

Assignment versus equality

A notorious example for a bad idea was the choice of the equal sign to denote assignment. It goes back to Fortran in 1957 and has blindly been copied by armies of language designers. Why is it a bad idea? Because it overthrows a century old tradition to let “=” denote a comparison for equality, a predicate which is either true or false. But Fortran made it to mean assignment, the enforcing of equality. In this case, the operands are on unequal footing: The left operand (a variable) is to be made equal to the right operand (an expression). x = y does not mean the same thing as y = x.^[14]

—Niklaus Wirth, Good Ideas, Through the Looking Glass

Beginning programmers sometimes confuse assignment with the relational operator for equality, as "=" means equality in mathematics, and is used for assignment in many languages. But assignment alters the value of a variable, while equality testing tests whether two expressions have the same value.

In some languages, such as BASIC, a single equals sign ("=") is used for both the assignment operator and the equality relational operator, with context determining which is meant. Other languages use different symbols for the two operators. For example:

• In Pascal, the assignment operator is a colon and an equals sign (":=") while the equality operator is a single equals ("=").
• In C, the assignment operator is a single equals sign ("=") while the equality operator is a pair of equals signs ("==").

The similarity in the two symbols can lead to errors if the programmer forgets which form ("=", "==", ":=") is appropriate, or mistypes "=" when "==" was intended. This is a common programming problem with languages such as C, where the assignment operator also returns the value assigned, and can be validly nested inside expressions (in the same way that a function returns a value). If the intention was to compare two values in an if statement, for instance, an assignment is quite likely to return a value interpretable as Boolean true, in which case the then clause will be executed, leading the program to behave unexpectedly. Some language processors (such as gcc) can detect such situations, and warn the programmer of the potential error.

Notation

Common textual representations of the assignment include an equals sign (=) and colon-equals (:=). These two forms are typical of programming languages (such as C) that classify assignment as an infix operator.

variable = expression	BASIC, Bourne shell, C (and many of its descendants), Fortran, Java, PL/I, Python, Windows PowerShell...
variable := expression	Ada, ALGOL, Dylan,[15] Eiffel,[16][17] Pascal[18]

Other possibilities include a left arrow or a keyword, though there are other, rarer, variants:

variable << expression	Magik
variable <- expression	Objective Caml, R, S
variable ← expression	APL[19]
variable =: expression	J
LET variable = expression	BASIC
set variable to expression	AppleScript
set variable = expression	C shell
Set-Variable variable (expression)	Windows PowerShell
val variable = expression	ML[20]
variable : expression	Macsyma, Maxima
var variable expression	mIRC scripting language

Some platforms put the expression on the left and the variable on the right:

MOVE expression TO variable	COBOL
expression → variable	TI-BASIC, Casio BASIC
expression -> variable	R

Some expression-oriented languages, such as Lisp^[21][22] and Tcl, uniformly use prefix syntax for all statements, including assignment.

(setf variable expression)	Common Lisp
(set! variable expression)	Scheme[23][24][25]
set variable expression	Tcl

See also

• Assignment operator in C++
• Operator (programming)
• Name binding
• Unification (computing)
• Immutable object
• Const-correctness

References