In this section we'll discuss simple local assignment to variables, multiple local assignment, and installation and use of method functions. See also the operator =, which handles other forms of assignment, as well as the operator <-, which is an assignment operator that evaluates its left hand side and can have assignment methods installed for it by the user.

- Usage:
`x := e`

- Inputs:
- Outputs:
- a thing, the value of the expression is
`e`

- a thing, the value of the expression is
- Consequences:
- a new local variable
`x`is created. The scope of`x`is the innermost current function body or for loop, or the current file. `e`is assigned to`x`, so future references to the value of`x`yield`e`- a warning message is issued if a local variable with the same name has already been created

- a new local variable

i1 : x o1 = x o1 : Symbol |

i2 : x := 4 o2 = 4 |

i3 : x o3 = 4 |

In the next example, we see that the scope of the local variable `p` is limited to the body of the function.

i4 : g = () -> ( p := 444; p ) o4 = g o4 : FunctionClosure |

i5 : g() o5 = 444 |

i6 : p o6 = p o6 : Symbol |

In this example, we see that the scope of the local variable `j` is limited to the body of a for loop.

i7 : i="a b c"; |

i8 : for i to 3 list j := i+1 o8 = {1, 2, 3, 4} o8 : List |

i9 : i o9 = a b c |

i10 : j o10 = j o10 : Symbol |

In this example, we see that a function returned by another function retains access to the values of local variables in its scope.

i11 : g = () -> ( p := 444; () -> p ) o11 = g o11 : FunctionClosure |

i12 : g() o12 = -*Function[stdio:11:26-11:29]*- o12 : FunctionClosure |

i13 : oo () o13 = 444 |

Functions returned by a function can also modify local variables within their scope, thereby communicating with each other.

i14 : g = () -> ( p := 444; (() -> p, i -> p = i)) o14 = g o14 : FunctionClosure |

i15 : (b,c) = g() o15 = (b, c) o15 : Sequence |

i16 : b() o16 = 444 |

i17 : c 555 o17 = 555 |

i18 : b() o18 = 555 |

Since the value of the entire expression is `e`, and since the operator = is right-associative (see precedence of operators), `e` can be easily assigned to more than one variable, as in the following example.

i19 : a := b := 44 o19 = 44 |

i20 : a o20 = 44 |

i21 : b o21 = 44 |

By the way, there is a difference between a variable (to which values can be assigned) and a symbol (which can be used as an indeterminate in making a polynomial ring). If you want a local variable to which is assigned the corresponding local symbol, then combine the use of := with the use of local, as in the following example, which illustrates a good way to do a computation in a temporary ring without disturbing the values of any global variables.

i22 : g = () -> ( x := local x; R := QQ[x]; (x+2)^10); |

- Usage:
`(x,y,z,...) := (c,d,e,...)`

- Inputs:
- Outputs:
- the value of the expression is
`(c,d,e,...)`

- the value of the expression is
- Consequences:
- new local variables
`x`,`y`,`z`, ... are created - the expressions c,d,e,... are assigned to the variables x,y,z,..., respectively, as above.
- If the left hand side has more elements than the right hand side, then the extra symbols on the left side are given the value null.
- If the left hand side has fewer elements than the right hand side, then the last symbol on the left hand side is given as value a sequence containing the trailing elements of the right hand side.
- If the right hand side is not a sequence, then it is assigned to the first symbol on the left, and the remaining symbols are assigned the value null.

- new local variables

Multiple assignment effectively means that functions can return multiple values usefully.

i23 : g() 10 9 8 7 6 5 4 3 o23 = x + 20x + 180x + 960x + 3360x + 8064x + 13440x + 15360x + ----------------------------------------------------------------------- 2 11520x + 5120x + 1024 o23 : QQ[x] |

i24 : f = i -> (i,i^2) o24 = f o24 : FunctionClosure |

i25 : (r,s) := f 9 o25 = (9, 81) o25 : Sequence |

i26 : r o26 = 9 |

- Usage:
`X OP Y := (x,y) -> ...`

- Inputs:
`X`, a type`OP`, one of the binary operators for which users may install methods, namely: % & * ** + ++ - .. ..< / // : << <== <=== <==> == ===> ==> >> ? @ @@ \ \\ ^ ^** ^^ _ | |- || and or SPACE . The operator SPACE, indicating adjacency, may be omitted from the usage above.`Y`, a type`(x,y) -> ...`, a function

- Outputs:
- the value of the expression is the same as the function on the right hand side

- Consequences:
- the function on the right hand side is installed as the method for
`X OP Y`. See the next subsection below for using it.

- the function on the right hand side is installed as the method for

i27 : s o27 = 81 |

i28 : String * String := peek; |

Warning: the installation of new methods may supplant old ones, changing the behavior of Macaulay2.

- Usage:
`x OP y`

- Inputs:
`x`, an object of type`X``OP`, one of the binary operators for which users may install methods, listed above. The operator SPACE, indicating adjacency, may be omitted from the usage above.`y`, an object of type`Y`

- Outputs:
- the previously installed method for
`X OP Y`is called with arguments`(x,y)`, and its return value is returned. If no such method has been installed, then Macaulay2 searches for a method for`X' OP Y'`, where`X'`is an ancestor of`X`and`Y'`is an ancestor of`Y`(see inheritance for details).

- the previously installed method for

i29 : "left" * "right" o29 = ("left", "right") |

i30 : String * Number := peek; |

i31 : "left" * 33 o31 = ("left", 33) |

Some methods for operators are

i32 : "left" * 3.3 o32 = ("left", 3.3) |

i33 : ZZ + ZZ := (x,y) -> x+y+100 o33 = -*Function[stdio:37:18-37:25]*- o33 : FunctionClosure |

i34 : 3 + 4 o34 = 7 |

i35 : CC + CC := (w,z) -> w*z o35 = -*Function[stdio:39:18-39:23]*- o35 : FunctionClosure |

- Usage:
`OP X = (x) -> ...`

- Inputs:
- Outputs:
- the value of the expression is the same as the function on the right hand side

- Consequences:
- the function on the right hand side is installed as the method for
`OP X`. See the next subsection below for using it.

- the function on the right hand side is installed as the method for

i36 : ii + ii o36 = 2*ii o36 : CC (of precision 53) |

i37 : - String := peek; |

Warning: the installation of new methods may supplant old ones, changing the behavior of Macaulay2.

- Usage:
`OP x`

- Inputs:
`OP`, one of the unary prefix operators for which users may install methods, listed above.`x`, an object of type`X`

- Outputs:
- the previously installed method for
`OP X`is called with argument`x`, and its return value is returned. If no such method has been installed, then Macaulay2 searches for a method for`OP X'`, where`X'`is an ancestor of`X`(see inheritance for details).

- the previously installed method for

i38 : - "foo" o38 = "foo" |

i39 : - String := peek; |

- Usage:
`X OP = (x) -> ...`

- Inputs:
- Outputs:
- the value of the expression is the same as the function on the right hand side

- Consequences:
- the function on the right hand side is installed as the method for
`OP X`. See the next subsection below for using it.

- the function on the right hand side is installed as the method for

i40 : - "foo" o40 = "foo" |

i41 : String ~ := peek; |

Warning: the installation of new methods may supplant old ones, changing the behavior of Macaulay2.

- Usage:
`x OP`

- Inputs:
`x`, an object of type`X``OP`, one of the unary postfix operators for which users may install methods, listed above.

- Outputs:
- the previously installed method for
`X OP`is called with argument=`x`, and its return value is returned. If no such method has been installed, then Macaulay2 searches for a method for to`X' OP`, where`X'`is an ancestor of`X`(see inheritance for details).

- the previously installed method for

i42 : "foo" ~ o42 = "foo" |

i43 : String ~ := peek; |

- Usage:
`f X := (x) -> ...``f(X) := (x) -> ...`

- Inputs:
- Consequences:
- the function on the right hand side is installed as the method for assignment to
`f X`. See the next subsection below for using it.

- the function on the right hand side is installed as the method for assignment to

i44 : "foo" ~ o44 = "foo" |

i45 : source String := peek; |

Warning: the installation of new methods may supplant old ones, changing the behavior of Macaulay2.

- Usage:
`f x`

- Inputs:
`f`, a method function`x`, an object of type`X`

- Outputs:
- the previously installed method for
`f X`is called with argument`x`, and its return value is returned

- the previously installed method for

i46 : source "foo" o46 = "foo" |

i47 : source String := peek; |

- Usage:
`f(X,Y) := (x,y) -> ...`

- Inputs:
- Consequences:
- the function on the right hand side is installed as the method for
`f(X,Y)`. See the next subsection below for using it.

- the function on the right hand side is installed as the method for

i48 : source "foo" o48 = "foo" |

i49 : source(String,Number) := peek; |

i50 : source("foo",33) o50 = ("foo", 33) |

Warning: the installation of new methods may supplant old ones, changing the behavior of Macaulay2.

The same syntax works for 3 or 4 arguments.

- Usage:
`f(x,y)`

- Inputs:
`f`, a method function`x`, an object of type`X``y`, an object of type`Y`

- Outputs:
- the previously installed method for
`f(X,Y)`is called with arguments`(x,y)`, and the return value is returned. If no such method has been installed, then Macaulay2 searches for a method for`f(X',Y')`, where`X'`is an ancestor of`X`and`Y'`is an ancestor of`Y`(see inheritance for details).

- the previously installed method for

i51 : source("foo",3.3) o51 = ("foo", 3.3) |

i52 : source(String,String) := peek; |

The same syntax works for 3 or 4 arguments.

Another use of the operator := is for installing methods for creation of new objects. For details, see new.