Assignment (computer science)

For assignment of letters to disk file systems, seeDrive letter assignment.

Incomputer programming,anassignment statementsets and/or re-sets thevaluestored in the storage location(s) denoted by avariablename;in other words, it copies a value into the variable. In mostimperativeprogramming languages,the assignment statement (or expression) is a fundamental construct.

Today, the most commonly used notation for this operation isx=expr(originallySuperplan1949–51, popularized byFortran1957 andC). The second most commonly used notation isx:=expr(originallyALGOL1958, popularised byPascal).Many other notations are also in use. In some languages, the symbol used is regarded as anoperator(meaning that the assignment statement as a whole returns a value). Other languages define 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 andscope.However, some languages (primarilystrictly functionallanguages) do not allow that kind of "destructive" reassignment, as it might imply changes of non-local state. The purpose is to enforcereferential 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 asdata structuring,structured programmingandobject orientation.

Semantics

An assignment operation is a process inimperative programmingin which different values are associated with a particular variable name as time passes.The program, in such model, operates by changing its state using successive assignment statements.Primitives of imperative programming languages rely on assignment to doiteration.At the lowest level, assignment is implemented usingmachine operationssuch asMOVEorSTORE.

Variablesare 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.Consequently, assignment is dependent on the concept ofvariables.In an assignment:

• Theexpressionis evaluated in the current state of the program.
• Thevariableis assigned the computed value, replacing the prior value of that variable.

Example: Assuming thatais a numeric variable, the assignmenta:= 2*ameans that the content of the variableais doubled after the execution of the statement.

An example segment ofCcode:

intx=10;
floaty;
x=23;
y=32.4f;

In this sample, the variablexis 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,yis declared without an assignment. In the third line,xis reassigned the value of 23. Finally,yis assigned the value of 32.4.

For an assignment operation, it is necessary that the value of theexpressionis well-defined (it is a validrvalue) and that thevariablerepresents a modifiable entity (it is a valid modifiable (non-const)lvalue). In some languages, typicallydynamicones, 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

See also:Static single-assignment form

Any assignment that changes an existing value (e.g.x:= x + 1) is disallowed inpurely functionallanguages.Infunctional programming,assignment is discouraged in favor of single assignment, more commonly known asinitialization.Single assignment is an example ofname bindingand 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 an expression does not have aside effectif it does not change an observable state of the machine,other than producing the result, and always produces same value for the same input.Imperative assignment can introduce side effects while destroying and making the old value unavailable while substituting it with a new one,and is referred to asdestructive assignmentfor that reason inLISPandfunctional programming,similar todestructive updating.

Single assignment is the only form of assignment available in purely functional languages, such asHaskell,which do not have variables in the sense of imperative programming languagesbut rather named constant values possibly of compound nature, with their elements progressively definedon-demand,for thelazylanguages. Purely functional languages can provide an opportunity forcomputation to be performed in parallel,avoiding thevon Neumann bottleneckof sequential one step at a time execution, since values are independent of each other.

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 (withlet) and true assignment (withset!) 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 theletname=valuesyntax; 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 declaredmutable(meaning capable of being changed after their initial declaration) by the programmer.

Functional programming languages that use single assignment includeClojure(for data structures, not vars),Erlang(it accepts multiple assignment if the values are equal, in contrast to Haskell),F#,Haskell,JavaScript(for constants), 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-backtrackingPrologcode can be consideredexplicitsingle-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, when it is created, to its value (or rather to a computational object that will produce its valueon demand).

Value of an assignment

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

In mostexpression-oriented programming languages(for example,C), the assignment statement returns the assigned value, allowing such idioms asx = y = a,in which the assignment statementy = areturns the value ofa,which is then assigned tox.In a statement such aswhile((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,Schemefor example, the return value of an assignment is undefined and such idioms are invalid.

InHaskell,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 theunit 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 primarilysyntactic sugarto 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

Main article:Augmented assignment

The case where the assigned value depends on a previous one is so common that many imperative languages, most notablyCand the majority of its descendants, provide special operators calledaugmented assignment,like*=,soa = 2*acan instead be written asa *= 2.Beyond syntactic sugar, this assists the task of the compiler by making clear that in-place modification of the variableais possible.

Chained assignment

A statement likew = x = y = zis called achained assignmentin which the value ofzis assigned to multiple variablesw, x,andy.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 (Cfor example), chained assignments are supported because assignments are expressions, and have values. In this case chain assignment can be implemented by having aright-associative assignment,and assignments happen right-to-left. For example,i = arr[i] = f()is equivalent toarr[i] = f(); i = arr[i].InC++they are also available for values of class types by declaring the appropriate return type for the assignment operator.

InPython,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 thati = arr[i] = f()evaluates the expressionf(),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 ofi.This is essentially equivalent totmp = f(); i = tmp; arr[i] = tmpthough no actual variable is produced for the temporary value.

Parallel assignment

Some programming languages, such asAPL,Common Lisp,Go,JavaScript(since 1.7),PHP,Maple,Lua,occam 2,Perl,Python,REBOL,Ruby,andPowerShellallow several variables to be assigned in parallel, with syntax like:

a, b:= 0, 1

which simultaneously assigns 0 toaand 1 tob.This is most often known asparallel assignment;it was introduced inCPLin 1963, under the namesimultaneous assignment,and is sometimes calledmultiple 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 calledunpackingordestructuring assignment:

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

The list will be unpacked so that 0 is assigned toaand 1 tob.Furthermore,

a, b:= b, a

swaps the values ofaandb.In languages without parallel assignment, this would have to be written to use a temporary variable

vart:= a
a:= b
b:= t

sincea:= b; b:= aleaves bothaandbwith the original value ofb.

Some languages, such asGo,F#andPython,combine parallel assignment, tuples, and automatictuple unpackingto allow multiple return values from a single function, as in this Python example,

deff():
return1,2
a,b=f()

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

// Valid C# or Rust syntax
(a,b)=(b,a);

// C# tuple return
(string,int)f()=>("foo",1);
var(a,b)=f();

// Rust tuple return
letf=||("foo",1);
let(a,b)=f();

This provides an alternative to the use ofoutput parametersfor returning multiple values from a function. This dates toCLU(1974), and CLU helped popularize parallel assignment generally.

C# additionally allows generalizeddeconstruction assignmentwith implementation defined by the expression on the right-hand side, as the compiler searches for an appropriateinstanceorextensionDeconstructmethod on the expression, which must have output parameters for the variables being assigned to.For example, one such method that would give theclassit appears in the same behavior as the return value off()above would be

voidDeconstruct(outstringa,outintb){a="foo";b=1;}

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

Assignment versus equality

See also:Relational operator § Confusion with assignment operators

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 toHeinz Rutishauser's languageSuperplan,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 1957and 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.

— Niklaus Wirth,Good Ideas, Through the Looking Glass

Beginning programmers sometimes confuse assignment with therelational operatorfor equality, as "=" meansequalityin 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 asBASIC,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:

• InALGOLandPascal,the assignment operator is a colon and an equals sign (":=") while the equality operator is a single equals ("=").
• InC,the assignment operator is a single equals sign ("=") while the equality operator is a pair of equals signs ("==").
• InR,the assignment operator is basically<-,as inx <- 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),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 anifstatement, for instance, an assignment is quite likely to return a value interpretable as Boolean true, in which case thethenclause will be executed, leading the program to behave unexpectedly. Some language processors (such asgcc) can detect such situations, and warn the programmer of the potential error.

Notation

See also:Comparison of programming languages (variable and constant declarations)

The two most common representations for the copying assignment areequals sign(=) and colon-equals (:=). Both forms may semantically denote either an assignmentstatementor an assignmentoperator(which also has a value), depending on language and/or usage.

variable=expression	Fortran,PL/I,C(anddescendantssuch asC++,Java,etc.),Bourne shell,Python,Go(assignment to pre-declared variables),R,PowerShell,Nim,etc.
variable:=expression	ALGOL(and derivatives),Simula,CPL,BCPL,Pascal(and descendants such asModula),Mary,PL/M,Ada,Smalltalk,Eiffel,Oberon,Dylan,Seed7,Python(an assignment expression),Go(shorthand for declaring and defining a variable),Io,AMPL,ML(assigning to a reference value),AutoHotkeyetc.

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,Smalltalk,Atari 2600 BASIC Programming
variable=:expression	J
LETvariable=expression	BASIC
letvariable:=expression	XQuery
setvariabletoexpression	AppleScript
setvariable=expression	C shell
Set-Variablevariable(expression)	PowerShell
variable:expression	Macsyma, Maxima,K
variable:expression	Rebol
varvariableexpression	mIRC scripting language
reference-variable:-reference-expression	Simula

Mathematicalpseudo codeassignments are generally depicted with a left-arrow.

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

MOVEexpressionTOvariable	COBOL
expression→variable	TI-BASIC,Casio BASIC
expression->variable	POP-2,BETA,R
putexpressionintovariable	HyperTalk,LiveCode
PUTexpressionINvariable	ABC

Some expression-oriented languages, such asLispand Tcl, uniformly use prefix (or postfix) syntax for all statements, including assignment.

(setfvariableexpression)	Common Lisp
(set!variableexpression)	Scheme
setvariableexpression	Tcl
expressionvariable!	Forth

See also

• Assignment operator (C++)
• Unification (computer science)
• Immutable object
• Assignment problem