==========
Assignment
==========

---------
Immediate
---------

A variable in FriCAS refers to a value. A variable has a name beginning
with an uppercase or lowercase alphabetic character, "%", or "!".
Successive characters (if any) can be any of the above, digits, or "?".
Case is distinguished. The following are all examples of valid, distinct
variable names: ::

  a       tooBig?     a1B2c3%!?
  A       %j          numberOfPoints
  beta6   %J          numberofpoints

The ":=" operator is the immediate assignment operator. Use it to 
associate a value with a variable. The syntax for immediate assignment
for a single variable is: ::

   variable := expression

The value returned by an immediate assignment is the value of expression. ::

  a := 1
    1             
           Type: PositiveInteger

The right-hand side of the expression is evaluated, yielding 1. The value
is then assigned to a. ::

  b := a
    1             
           Type: PositiveInteger

The right-hand side of the expression is evaluated, yieldig 1. This value
is then assigned to b. Thus a and b both have the value 1 after the sequence
of assignments. ::

  a := 2
    2
           Type: PositiveInteger

What is the value of b if a is assigned the value 2? ::

  b
    1
           Type: PositiveInteger

The value of b is left unchanged. 

This is what we mean when we say this kind of assignment is immediate.
The variable b has no dependency on a after the initial assignment. This
is the usual notion of assignment in programming languages such as C,
Pascal, and Fortran.

-------
Delayed
-------

FriCAS provides delayed assignment with "==". This implements a delayed
evaluation of the right-hand side and dependency checking. The syntax for
delayed assignment is ::

   variable == expression

The value returned by a delayed assignment is the unique value of Void. ::

  a == 1
           Type: Void

  b == a
           Type: Void

Using a and b as above, these are the corresponding delayed assignments. ::

  a
   Compiling body of rule a to compute value of type PositiveInteger
   1
           Type: PositiveInteger

The right-hand side of each delayed assignment is left unevaluated until
the variables on the left-hand sides are evaluated. ::

  b
   Compiling body of rule b to compute value of type PositiveInteger
   1
           Type: PositiveInteger

This gives the same results as before. But if we change a to 2 ::

  a == 2
   Compiled code for a has been cleared.
   Compiled code for b has been cleared.
   1 old definition(s) deleted for function or rule a
           Type: Void

Then a evaluates to 2, as expected ::

  a
   Compiling body of rule a to compute value of type PositiveInteger
   2
           Type: PositiveInteger

but the value of b reflects the change to a ::

  b
   Compiling body of rule b to compute value of type PositiveInteger
   2
           Type: PositiveInteger

------------------
Multiple Immediate
------------------

It is possible to set several variables at the same time by using a
tuple of variables and a tuple of expressions. A tuple is a collection
of things separated by commas, often surrounded by parentheses. The
syntax for multiple immediate assignment is ::

 ( var1, var2, ..., varN ) := ( expr1, expr2, ..., exprN )

The value returned by an immediate assignment is the value of exprN. ::

 ( x, y ) := ( 1, 2 )
   2
           Type: PositiveInteger

This sets x to 1 and y to 2. Multiple immediate assignments are parallel
in the sense that the expressions on the right are all evaluated before
any assignments on the left are made. However, the order of evaluation
of these expressions is undefined. ::

 ( x, y ) := ( y, x )
   1
           Type: PositiveInteger

  x
   2
           Type: PositiveInteger

The variable x now has the previous value of y. ::

  y
   1
           Type: PositiveInteger

The variable y now has the previous value of x. 

There is no syntactic form for multiple delayed assignments.