Immediate and Delayed Definitions

You may have noticed that there are two different ways to make assignments in the Wolfram Language: lhs=rhs and lhs:=rhs. The basic difference between these forms is when the expression rhs is evaluated. lhs=rhs is an immediate assignment, in which rhs is evaluated at the time when the assignment is made. lhs:=rhs, on the other hand, is a delayed assignment, in which rhs is not evaluated when the assignment is made, but is instead evaluated each time the value of lhs is requested.

lhs=rhs (immediate assignment)rhs is evaluated when the assignment is made
lhs:=rhs (delayed assignment)rhs is evaluated each time the value of lhs is requested

The two types of assignments in the Wolfram Language.

This uses the := operator to define the function ex:
Click for copyable input
Because := was used, the definition is maintained in an unevaluated form:
Click for copyable input
When you make an assignment with the = operator, the righthand side is evaluated immediately:
Click for copyable input
The definition now stored is the result of the Expand command:
Click for copyable input
When you execute ex, the Expand is performed:
Click for copyable input
iex simply substitutes its argument into the already expanded form, giving a different answer:
Click for copyable input

As you can see from the example above, both = and := can be useful in defining functions, but they have different meanings, and you must be careful about which one to use in a particular case.

One rule of thumb is the following. If you think of an assignment as giving the final "value" of an expression, use the = operator. If instead you think of the assignment as specifying a "command" for finding the value, use the := operator. If in doubt, it is usually better to use the := operator than the = one.

lhs=rhsrhs is intended to be the "final value" of lhs (e.g. f[x_]=1-x^2)
lhs:=rhsrhs gives a "command" or "program" to be executed whenever you ask for the value of lhs (e.g. f[x_]:=Expand[1-x^2])

Interpretations of assignments with the = and := operators.

Although := is probably used more often than = in defining functions, there is one important case in which you must use = to define a function. If you do a calculation, and get an answer in terms of a symbolic parameter , you often want to go on and find results for various specific values of . One way to do this is to use the /. operator to apply appropriate rules for in each case. It is usually more convenient, however, to use = to define a function whose argument is .

Here is an expression involving x:
Click for copyable input
This defines a function whose argument is the value to be taken for x:
Click for copyable input
Here is the result when x is taken to be 1+a:
Click for copyable input

An important point to notice in the example above is that there is nothing special about the name x that appears in the x_ pattern. It is just a symbol, indistinguishable from an x that appears in any other expression.

f[x_]=exprdefine a function which gives the value expr for any particular value of x

Defining functions for evaluating expressions.

You can use = and := not only to define functions, but also to assign values to variables. If you type x=value, then value is immediately evaluated, and the result is assigned to x. On the other hand, if you type x:=value, then value is not immediately evaluated. Instead, it is maintained in an unevaluated form, and is evaluated afresh each time is used.

This evaluates RandomReal[] to find a pseudorandom number, then assigns this number to r1:
Click for copyable input
Here RandomReal[] is maintained in an unevaluated form, to be evaluated afresh each time r2 is used:
Click for copyable input
Here are values for r1 and r2:
Click for copyable input
The value of r1 never changes. Every time r2 is used, however, a new pseudorandom number is generated:
Click for copyable input

The distinction between immediate and delayed assignments is particularly important when you set up chains of assignments.

This defines a to be 1:
Click for copyable input
Here a+2 is evaluated to give 3, and the result is assigned to be the value of ri:
Click for copyable input
Here a+2 is maintained in an unevaluated form, to be evaluated every time the value of rd is requested:
Click for copyable input
In this case, ri and rd give the same values:
Click for copyable input
Now the value of a is changed:
Click for copyable input
Now rd uses the new value for a, while ri keeps its original value:
Click for copyable input

You can use delayed assignments such as t:=rhs to set up variables whose values you can find in a variety of different "environments". Every time you ask for Null, the expression rhs is evaluated using the current values of the objects on which it depends.

The righthand side of the delayed assignment is maintained in an unevaluated form:
Click for copyable input
This sets a to 4, then finds the value of t:
Click for copyable input
Here a is 6:
Click for copyable input

In the example above, the symbol a acts as a "global variable", whose value affects the value of t. When you have a large number of parameters, many of which change only occasionally, you may find this kind of setup convenient. However, you should realize that implicit or hidden dependence of one variable on others can often become quite confusing. When possible, you should make all dependencies explicit, by defining functions which take all necessary parameters as arguments.

lhs->rhsrhs is evaluated when the rule is given
lhs:>rhsrhs is evaluated when the rule is used

Two types of transformation rules in the Wolfram Language.

Just as you can make immediate and delayed assignments in the Wolfram Language, so you can also set up immediate and delayed transformation rules.

The righthand side of this rule is evaluated when you give the rule:
Click for copyable input
A rule like this is probably not particularly useful:
Click for copyable input
Here the righthand side of the rule is maintained in an unevaluated form, to be evaluated every time the rule is used:
Click for copyable input
Applying the rule causes the expansion to be done:
Click for copyable input

In analogy with assignments, you should typically use -> when you want to replace an expression with a definite value, and you should use :> when you want to give a command for finding the value.