Assignment (computer science)

In computer programming, an assignment statement sets and/or re-sets the value stored in the storage
location(s) denoted by a variable name; in other words, it copies a value into the variable. In most
imperative programming languages, the assignment statement (or expression) is a fundamental construct.

Today, the most commonly used notation for this basic operation has come to be x = expr (originally
Superplan 1949–51, popularized by Fortran 1957 and C) followed by [1]x := expr (originally
ALGOL 1958, popularised by Pascal),[2] although there are many other notations in use. In some
languages the symbol used is regarded as an operator (meaning that the assignment statement as a whole
returns a value) while others define the assignment as a statement (meaning that it cannot be used in an
expression).

Assignments typically allow a variable to hold different values at different times during its life-span and
scope. However, some languages (primarily strictly functional) do not allow that kind of "destructive"
reassignment, as it might imply changes of non-local state. The purpose is to enforce referential
transparency, i.e. functions that do not depend on the state of some variable(s), but produce the same
results for a given set of parametric inputs at any point in time. Modern programs in other languages also
often use similar strategies, although less strict, and only in certain parts, in order to reduce complexity,
normally in conjunction with complementing methodologies such as data structuring, structured
programming and object orientation.

Contents
Semantics
Single assignment
Value of an assignment
Variant forms of assignment
Augmented assignment
Chained assignment
Parallel assignment
Assignment versus equality
Notation
See also
Notes
References

Semantics
An assignment operation is a process in imperative programming in which different values are associated
with a particular variable name as time passes.[1] The program, in such model, operates by changing its
state using successive assignment statements.[2][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.[2][4]

Variables are containers for values. It is possible to put a value into a 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.

An example segment of C code:

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

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. In such languages, a variable is automatically declared the first time it is assigned to,
with the scope it is declared in varying by language.

Single assignment
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 reassignment is allowed.

An evaluation of expression does not have a side effect if it does not change an observable state of the
machine,[5] 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,[6] 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 the 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 (for data structures, not
vars), Erlang (it accepts multiple assignment if the values are equal, in contrast to Haskell), F#, Haskell,
Lava, OCaml, Oz (for dataflow variables, not cells), Racket (for some data structures like lists, not
symbols), SASL, Scala (for vals), SISAL, Standard ML. 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 ((ch =
getchar()) != EOF) {…}, 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 the unit type, which is
represented as (). This type has only one possible value, therefore containing no information. It is
typically the type of an expression that is evaluated purely for its side effects.

Variant forms of assignment

Certain use patterns are very common, and thus often have special syntax to support them. These are
primarily syntactic sugar to reduce redundancy in the source code, but also assists readers of the code in
understanding the programmer's intent, and provides the compiler with a clue to possible optimization.

Augmented assignment
The case where the assigned value depends on a previous one is so common that many imperative
languages, most notably C and the majority of its descendants, provide special operators called
augmented assignment, like *=, so a = 2*a can instead be written as a *= 2.[3] Beyond syntactic
sugar, this assists the task of the compiler by making clear that in-place modification of the variable a is
possible.

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. Chained assignments are equivalent to a
sequence of assignments, but the evaluation strategy differs between languages. For simple chained
assignments, like initializing multiple variables, the evaluation strategy does not matter, but if the targets
(l-values) in the assignment are connected in some way, the evaluation strategy affects the result.

In some programming languages (C for example), chained assignments are supported because
assignments are expressions, and have values. In this case chain assignment can be implemented by
having a right-associative assignment, and assignments happen right-to-left. For example, i = arr[i]
= f() is equivalent to arr[i] = f(); i = arr[i]. In C++ they are also available for values of
class types by declaring the appropriate return type for the assignment operator.

In Python, assignment statements are not expressions and thus do not have a value. Instead, chained
assignments are a series of statements with multiple targets for a single expression. The assignments are
executed left-to-right so that i = arr[i] = f() evaluates the expression f(), then assigns the
result to the leftmost target, i, and then assigns the same result to the next target, arr[i], using the new
value of i.[9] This is essentially equivalent to tmp = f(); i = tmp; arr[i] = tmp though no
actual variable is produced for the temporary value.

Parallel assignment
Some programming languages, such as APL, Common Lisp[10], Go,[11] JavaScript (since 1.7), PHP,
Maple, Lua, occam 2,[12] Perl,[13] Python,[14] REBOL, Ruby,[15] 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. This is most often known as parallel assignment; it was
introduced in CPL in 1963, under the name simultaneous assignment,[16] and is sometimes called
multiple assignment, though this is confusing when used with "single assignment", as these are not
opposites. If the right-hand side of the assignment is a single variable (e.g. an array or structure), the
feature is called unpacking[17] or destructuring assignment:[18]

var list := {0, 1}

a, b := list
The list will be unpacked so that 0 is assigned to a and 1 to b. Furthermore,

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.

Some languages, such as Go and Python, combine parallel assignment, tuples, and automatic tuple
unpacking to allow multiple return values from a single function, as in this Python example,

def f():
return 1, 2
a, b = f()

while other languages, such as C#, shown here, require explicit tuple construction and deconstruction
with parentheses:

(a, b) = (b, a);

(string, int) f() => ("foo", 1);

var (a, b) = f();

This provides an alternative to the use of output parameters for returning multiple values from a function.
This dates to CLU (1974), and CLU helped popularize parallel assignment generally.

C# additionally allows generalized deconstruction assignment with implementation defined by the

expression on the right-hand side, as the compiler searches for an appropriate instance or extension
Deconstruct method on the expression, which must have output parameters for the variables being
assigned to.[19] For example, one such method that would that would give the class it appears in the same
behavior as the return value of f() above would be

void Deconstruct(out string a, out int b) { a = "foo"; b = 1; }

In C and C++, the comma operator is similar to parallel assignment in allowing multiple assignments to
occur within a single statement, writing a = 1, b = 2 instead of a, b = 1, 2. This is primarily
used in for loops, and is replaced by parallel assignment in other languages such as Go.[20] However, the
above C++ code does not ensure perfect simultaneity, since the right side of the following code a = b,
b = a+1 is evaluated after the left side. In languages such as Python, a, b = b, a+1 will assign
the two variables concurrently, using the initial value of a to compute the new b.

Assignment versus equality

The use of the equals sign = as an assignment operator has been frequently criticized, due to the conflict
with equals as comparison for equality. This results both in confusion by novices in writing code, and
confusion even by experienced programmers in reading code. The use of equals for assignment dates
back to Heinz Rutishauser's language Superplan, designed from 1949 to 1951, and was particularly
popularized by Fortran:

A notorious example for a bad idea was the choice of the equal sign to denote assignment. It
goes back to Fortran in 1957[a] 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.[21]

— 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 ALGOL and 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 ("==").
In R, the assignment operator is basically <-, as in x <- value, but a single equals sign
can be used in certain contexts.
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 (including one famous attempt to backdoor the Linux kernel [22]), where the
assignment operator also returns the value assigned (in the same way that a function returns a value), and
can be validly nested inside expressions. 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
The two most common representations for the copying assignment are equals sign (=) and colon-equals
(:=). Both forms may semantically denote either an assignment statement or an assignment operator
(which also has a value), depending on language and/or usage.
 variable = Fortran, PL/I, C (and descendants such as C++, Java, etc.), Bourne shell, Python, Go
expression (assignment to pre-declared variables), R, Windows PowerShell, etc.

ALGOL (and derivatives), Simula, CPL, BCPL, Pascal[23] (and descendants such as
variable := Modula), Mary, PL/M, Ada, Smalltalk, Eiffel,[24][25] Oberon, Dylan,[26] Seed7, Python (an
expression assignment expression),[27] Go (shorthand for declaring and defining a variable),[28] Io,
AMPL, ML,[29] AutoHotkey etc.

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

variable << expression Magik

variable <- expression F#, OCaml, R, S

variable <<- expression R

assign("variable", expression) R

variable ← expression APL,[30] Smalltalk

variable =: expression J

LET variable = expression BASIC

let variable := expression XQuery

set variable to expression AppleScript

set variable = expression C shell

Set-Variable variable (expression) Windows PowerShell

variable : expression Macsyma, Maxima, Rebol, K

var variable expression mIRC scripting language

reference-variable :- reference-expression Simula

Mathematical pseudo code assignments are generally depicted with a left-arrow.

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 POP-2, BETA, R

put expression into variable LiveCode

Some expression-oriented languages, such as Lisp[31][32] and Tcl, uniformly use prefix (or postfix)
syntax for all statements, including assignment.

(setf variable expression) Common Lisp

(set! variable expression) Scheme[33][34][35]

set variable expression Tcl

expression variable ! Forth

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

Notes
a. Use of = predates Fortran, though it was popularized by Fortran.

References
1. "2cs24 Declarative" (https://web.archive.org/web/20060424045449/http://www.csc.liv.ac.uk/
~frans/OldLectures/2CS24/declarative.html). www.csc.liv.ac.uk. Archived from the original
(http://www.csc.liv.ac.uk/~frans/OldLectures/2CS24/declarative.html) on 24 April 2006.
Retrieved 20 April 2018.
2. "Imperative Programming" (http://www.cs.uah.edu/~weisskop/Notes424-524/ch12.ppt).
uah.edu. Retrieved 20 April 2018.
3. Ruediger-Marcus Flaig (2008). Bioinformatics programming in Python: a practical course for
beginners (https://books.google.com/books?id=kS7Dye-dv54C&pg=PA98). Wiley-VCH.
pp. 98–99. ISBN 978-3-527-32094-3. Retrieved 25 December 2010.
4. Crossing borders: Explore functional programming with Haskell (http://www.ibm.com/develo
perworks/java/library/j-cb07186.html) Archived (https://web.archive.org/web/201011191908
21/http://www.ibm.com/developerworks/java/library/j-cb07186.html) November 19, 2010, at
the Wayback Machine, by Bruce Tate
5. Mitchell, John C. (2003). Concepts in programming languages (https://books.google.com/bo
oks?id=7Uh8XGfJbEIC&pg=PA23). Cambridge University Press. p. 23. ISBN 978-0-521-
78098-8. Retrieved 3 January 2011.
6. "Imperative Programming Languages (IPL)" (http://www.seas.gwu.edu/~bell/csci210/lecture
s/imperative_languages.pdf) (PDF). gwu.edu. Retrieved 20 April 2018.
7. John C. Mitchell (2003). Concepts in programming languages (https://books.google.com/bo
oks?id=7Uh8XGfJbEIC&pg=PA81). Cambridge University Press. pp. 81–82. ISBN 978-0-
521-78098-8. Retrieved 3 January 2011.
8. Hudak, Paul (2000). The Haskell School of Expression: Learning Functional Programming
Through Multimedia. Cambridge: Cambridge University Press. ISBN 0-521-64408-9.
9. "7. Simple statements — Python 3.6.5 documentation" (https://docs.python.org/reference/si
mple_stmts.html#assignment-statements). docs.python.org. Retrieved 20 April 2018.
10. "CLHS: Macro SETF, PSETF" (http://www.lispworks.com/documentation/HyperSpec/Body/
m_setf_.htm#psetf). Common Lisp Hyperspec. LispWorks. Retrieved 23 April 2019.
11. The Go Programming Language Specification: Assignments (https://golang.org/ref/spec#As
signments)
12. INMOS Limited, ed. (1988). Occam 2 Reference Manual. New Jersey: Prentice Hall.
ISBN 0-13-629312-3.
13. Wall, Larry; Christiansen, Tom; Schwartz, Randal C. (1996). Perl Programming Language (h
ttps://archive.org/details/programmingperl00wall) (2 ed.). Cambridge: O´Reilly. ISBN 1-
56592-149-6.
14. Lutz, Mark (2001). Python Programming Language (https://archive.org/details/programming
pytho00lutz) (2 ed.). Sebastopol: O´Reilly. ISBN 0-596-00085-5.
15. Thomas, David; Hunt, Andrew (2001). Programming Ruby: The Pragmatic Programmer's
Guide (https://archive.org/details/programmingruby000thom). Upper Saddle River: Addison
Wesley. ISBN 0-201-71089-7.
16. D.W. Barron et al., "The main features of CPL", Computer Journal 6:2:140 (1963). full text
(subscription) (http://comjnl.oxfordjournals.org/cgi/reprint/6/2/134)
17. "PEP 3132 -- Extended Iterable Unpacking" (http://legacy.python.org/dev/peps/pep-3132/).
legacy.python.org. Retrieved 20 April 2018.
18. "Destructuring assignment" (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refer
ence/Operators/Destructuring_assignment). MDN Web Docs. Retrieved 20 April 2018.
19. "Deconstructing tuples and other types" (https://docs.microsoft.com/en-us/dotnet/csharp/de
construct). Microsoft Docs. Microsoft. Retrieved 29 August 2019.
20. Effective Go (https://golang.org/doc/effective_go.html): for (https://golang.org/doc/effective_
go.html#for), "Finally, Go has no comma operator and ++ and -- are statements not
expressions. Thus if you want to run multiple variables in a for you should use parallel
assignment (although that precludes ++ and --)."
21. Niklaus Wirth. "Good Ideas, Through the Looking Glass". CiteSeerX 10.1.1.88.8309 (https://
citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.88.8309). Missing or empty |url=
(help)
22. Corbet (6 November 2003). "An attempt to backdoor the kernel" (https://lwn.net/Articles/571
35/).
23. Moore, Lawrie (1980). Foundations of Programming with Pascal. New York: John Wiley &
Sons. ISBN 0-470-26939-1.
24. Meyer, Bertrand (1992). Eiffel the Language. Hemel Hempstead: Prentice Hall
International(UK). ISBN 0-13-247925-7.
25. Wiener, Richard (1996). An Object-Oriented Introduction to Computer Science Using Eiffel.
Upper Saddle River, New Jersey: Prentice Hall. ISBN 0-13-183872-5.
26. Feinberg, Neal; Keene, Sonya E.; Mathews, Robert O.; Withington, P. Tucker (1997). Dylan
Programming. Massachusetts: Addison Wesley. ISBN 0-201-47976-1.
27. "PEP 572 -- Assignment Expressions" (https://www.python.org/dev/peps/pep-0572/).
python.org. 28 February 2018. Retrieved 4 March 2020.
28. "The Go Programming Language Specification - The Go Programming Language" (https://g
olang.org/ref/spec#Short_variable_declarations). golang.org. Retrieved 20 April 2018.
29. Ullman, Jeffrey D. (1998). Elements of ML Programming: ML97 Edition. Englewood Cliffs,
New Jersey: Prentice Hall. ISBN 0-13-790387-1.
30. Iverson, Kenneth E. (1962). A Programming Language (https://web.archive.org/web/200906
04091725/http://www.softwarepreservation.org/projects/apl/book/APROGRAMMING%20LA
NGUAGE/view). John Wiley and Sons. ISBN 0-471-43014-5. Archived from the original (htt
p://www.softwarepreservation.org/projects/apl/book/APROGRAMMING%20LANGUAGE/vie
w) on 2009-06-04. Retrieved 2010-05-09.
31. Graham, Paul (1996). ANSI Common Lisp (https://archive.org/details/ansicommonlisp00gra
h). New Jersey: Prentice Hall. ISBN 0-13-370875-6.
32. Steele, Guy L. (1990). Common Lisp: The Language. Lexington: Digital Press. ISBN 1-
55558-041-6.
33. Dybvig, R. Kent (1996). The Scheme Programming Language: ANSI Scheme. New Jersey:
Prentice Hall. ISBN 0-13-454646-6.
34. Smith, Jerry D. (1988). Introduction to Scheme. New Jersey: Prentice Hall. ISBN 0-13-
496712-7.
35. Abelson, Harold; Sussman, Gerald Jay; Sussman, Julie (1996). Structure and Interpretation
of Computer Programs. New Jersey: McGraw-Hill. ISBN 0-07-000484-6.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Assignment_(computer_science)&oldid=943929108"

This page was last edited on 4 March 2020, at 17:40 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using
this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia
Foundation, Inc., a non-profit organization.