### 7.6 Assignment operators

Operator: :

  Assignment operator.

  When the left-hand side is a simple variable (not subscripted), `:` evaluates its right-hand side and associates that value with the left-hand side.

  When the left-hand side is a subscripted element of a list, matrix, declared Maxima array, or Lisp array, the right-hand side is assigned to that element. The subscript must name an existing element; such objects cannot be extended by naming nonexistent elements.

  When the left-hand side is a subscripted element of a `hashed array`, the right-hand side is assigned to that element, if it already exists, or a new element is allocated, if it does not already exist.

  When the left-hand side is a list of simple and/or subscripted variables, the right-hand side must evaluate to a list, and the elements of the right-hand side are assigned to the elements of the left-hand side, in parallel.

  See also `kill` and `remvalue`, which undo the association between the left-hand side and its value.

  Examples:

  Assignment to a simple variable.

      (%i1) a;
      (%o1)                           a
      (%i2) a : 123;
      (%o2)                          123
      (%i3) a;
      (%o3)                          123

  Assignment to an element of a list.

      (%i1) b : [1, 2, 3];
      (%o1)                       [1, 2, 3]
      (%i2) b[3] : 456;
      (%o2)                          456
      (%i3) b;
      (%o3)                      [1, 2, 456]

  Assignment to a variable that neither is the name of a list nor of an array creates a `hashed array`.

      (%i1) c[99] : 789;
      (%o1)                          789
      (%i2) c[99];
      (%o2)                          789
      (%i3) c;
      (%o3)                           c
      (%i4) arrayinfo (c);
      (%o4)                   [hashed, 1, [99]]
      (%i5) listarray (c);
      (%o5)                         [789]

  Multiple assignment.

      (%i1) [a, b, c] : [45, 67, 89];
      (%o1)                     [45, 67, 89]
      (%i2) a;
      (%o2)                          45
      (%i3) b;
      (%o3)                          67
      (%i4) c;
      (%o4)                          89

  Multiple assignment is carried out in parallel. The values of `a` and `b` are exchanged in this example.

      (%i1) [a, b] : [33, 55];
      (%o1)                       [33, 55]
      (%i2) [a, b] : [b, a];
      (%o2)                       [55, 33]
      (%i3) a;
      (%o3)                          55
      (%i4) b;
      (%o4)                          33

  ·

  Categories: Evaluation ·Operators

Operator: ::

  Assignment operator.

  `::` is the same as `:` (which see) except that `::` evaluates its left-hand side as well as its right-hand side.

  Examples:

      (%i1) x : 'foo;
      (%o1)                          foo
      (%i2) x :: 123;
      (%o2)                          123
      (%i3) foo;
      (%o3)                          123
      (%i4) x : '[a, b, c];
      (%o4)                       [a, b, c]
      (%i5) x :: [11, 22, 33];
      (%o5)                     [11, 22, 33]
      (%i6) a;
      (%o6)                          11
      (%i7) b;
      (%o7)                          22
      (%i8) c;
      (%o8)                          33

  ·

  Categories: Evaluation ·Operators

Operator: ::=

  Macro function definition operator. `::=` defines a function (called a "macro" for historical reasons) which quotes its arguments, and the expression which it returns (called the "macro expansion") is evaluated in the context from which the macro was called. A macro function is otherwise the same as an ordinary function.

  `macroexpand` returns a macro expansion (without evaluating it). `macroexpand (foo (x))` followed by `''%` is equivalent to `foo (x)` when `foo` is a macro function.

  `::=` puts the name of the new macro function onto the global list `macros`. `kill`, `remove`, and `remfunction` unbind macro function definitions and remove names from `macros`.

  `fundef` or `dispfun` return a macro function definition or assign it to a label, respectively.

  Macro functions commonly contain `buildq` and `splice` expressions to construct an expression, which is then evaluated.

  Examples

  A macro function quotes its arguments, so message (1) shows `y - z`, not the value of `y - z`. The macro expansion (the quoted expression `'(print ("(2) x is equal to", x))`) is evaluated in the context from which the macro was called, printing message (2).

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$
      (%i5) printq1 (y - z);
      (1) x is equal to y - z
      (2) x is equal to %pi
      (%o5)                                 %pi

  An ordinary function evaluates its arguments, so message (1) shows the value of `y - z`. The return value is not evaluated, so message (2) is not printed until the explicit evaluation `''%`.

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$
      (%i5) printe1 (y - z);
      (1) x is equal to 1234 - 1729 w
      (%o5)                     print((2) x is equal to, x)
      (%i6) ''%;
      (2) x is equal to %pi
      (%o6)                                 %pi

  `macroexpand` returns a macro expansion. `macroexpand (foo (x))` followed by `''%` is equivalent to `foo (x)` when `foo` is a macro function.

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
      (%i5) macroexpand (g (y - z));
      (%o5)                     print(x is equal to, y - z)
      (%i6) ''%;
      x is equal to 1234 - 1729 w
      (%o6)                            1234 - 1729 w
      (%i7) g (y - z);
      x is equal to 1234 - 1729 w
      (%o7)                            1234 - 1729 w

  ·

  Categories: Function definition ·Operators

Operator: :=

  The function definition operator.

  `f(x_1, ..., x_n) := expr` defines a function named f with arguments x_1, …, x_n and function body expr. `:=` never evaluates the function body (unless explicitly evaluated by quote-quote `''`). The function body is evaluated every time the function is called.

  `f[x_1, ..., x_n] := expr` defines a so-called `memoizing function`. Its function body is evaluated just once for each distinct value of its arguments, and that value is returned, without evaluating the function body, whenever the arguments have those values again. (A function of this kind is also known as a “array function”.)

  `f[x_1, ..., x_n](y_1, ..., y_m) := expr` is a special case of a `memoizing function`. `f[x_1, ..., x_n]` is a `memoizing function` which returns a lambda expression with arguments `y_1, ..., y_m`. The function body is evaluated once for each distinct value of `x_1, ..., x_n`, and the body of the lambda expression is that value.

  When the last or only function argument x_n is a list of one element, the function defined by `:=` accepts a variable number of arguments. Actual arguments are assigned one-to-one to formal arguments x_1, …, x_(n - 1), and any further actual arguments, if present, are assigned to x_n as a list.

  All function definitions appear in the same namespace; defining a function `f` within another function `g` does not automatically limit the scope of `f` to `g`. However, `local(f)` makes the definition of function `f` effective only within the block or other compound expression in which `local` appears.

  If some formal argument x_k is a quoted symbol, the function defined by `:=` does not evaluate the corresponding actual argument. Otherwise all actual arguments are evaluated.

  See also `define` and `::=`.

  Examples:

  `:=` never evaluates the function body (unless explicitly evaluated by quote-quote).

      (%i1) expr : cos(y) - sin(x);
      (%o1)                    cos(y) - sin(x)
      (%i2) F1 (x, y) := expr;
      (%o2)                   F1(x, y) := expr
      (%i3) F1 (a, b);
      (%o3)                    cos(y) - sin(x)
      (%i4) F2 (x, y) := ''expr;
      (%o4)              F2(x, y) := cos(y) - sin(x)
      (%i5) F2 (a, b);
      (%o5)                    cos(b) - sin(a)

  `f(x_1, ..., x_n) := ...` defines an ordinary function.

      (%i1) G1(x, y) := (print ("Evaluating G1 for x=", x, "and y=", y),
       x.y - y.x);
      (%o1) G1(x, y) := (print("Evaluating G1 for x=", x, "and y=",
                                                     y), x . y - y . x)
      (%i2) G1([1, a], [2, b]);
      Evaluating G1 for x= [1, a] and y= [2, b]
      (%o2)                           0
      (%i3) G1([1, a], [2, b]);
      Evaluating G1 for x= [1, a] and y= [2, b]
      (%o3)                           0

  `f[x_1, ..., x_n] := ...` defines a `memoizing function`.

      (%i1) G2[a] := (print ("Evaluating G2 for a=", a), a^2);
                                                           2
      (%o1)     G2  := (print("Evaluating G2 for a=", a), a )
                  a
      (%i2) G2[1234];
      Evaluating G2 for a= 1234
      (%o2)                        1522756
      (%i3) G2[1234];
      (%o3)                        1522756
      (%i4) G2[2345];
      Evaluating G2 for a= 2345
      (%o4)                        5499025
      (%i5) arrayinfo (G2);
      (%o5)              [hashed, 1, [1234], [2345]]
      (%i6) listarray (G2);
      (%o6)                  [1522756, 5499025]

  `f[x_1, ..., x_n](y_1, ..., y_m) := expr` is a special case of a `memoizing function`.

      (%i1) G3[n](x) := (print ("Evaluating G3 for n=", n), diff (sin(x)^2,
       x, n));
      (%o1) G3 (x) := (print("Evaluating G3 for n=", n),
              n
                                                           2
                                                   diff(sin (x), x, n))
      (%i2) G3[2];
      Evaluating G3 for n= 2
                                      2           2
      (%o2)          lambda([x], 2 cos (x) - 2 sin (x))
      (%i3) G3[2];
                                      2           2
      (%o3)          lambda([x], 2 cos (x) - 2 sin (x))
      (%i4) G3[2](1);
                                 2           2
      (%o4)                 2 cos (1) - 2 sin (1)
      (%i5) arrayinfo (G3);
      (%o5)                   [hashed, 1, [2]]
      (%i6) listarray (G3);
                                      2           2
      (%o6)         [lambda([x], 2 cos (x) - 2 sin (x))]

  When the last or only function argument x_n is a list of one element, the function defined by `:=` accepts a variable number of arguments.

      (%i1) H ([L]) := apply ("+", L);
      (%o1)                H([L]) := apply("+", L)
      (%i2) H (a, b, c);
      (%o2)                       c + b + a

  `local` makes a local function definition.

      (%i1) foo (x) := 1 - x;
      (%o1)                    foo(x) := 1 - x
      (%i2) foo (100);
      (%o2)                         - 99
      (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
      (%o3)                          200
      (%i4) foo (100);
      (%o4)                         - 99

  ·

  Categories: Function definition ·Operators