Magma now allows automatic printing of expressions: basically, a statement consisting of an expression (or list of expressions) alone is taken as a shorthand for the print statement.

Subsections

• Semantics
• The Previous Value Buffer

Some subtleties are involved in understanding the precise behaviour of Magma in interpreting lone expressions as statements. The rules Magma follows are outlined here. In the following, a call-form means any expression of the form f(( arguments)); that is, anything which could be a procedure call or a function call.

• Any single expression followed by a semicolon which is not a call-form is printed, just as if you had 'print' in front of it.
• For a single call-form followed by a semicolon (which could be a function call or procedure call), the first signature which matches the input arguments is taken and if that is procedural, the whole call is taken as a procedure call, otherwise it is taken as function call and the results are printed.
• A comma-separated list of any expressions is printed, just as if you had 'print' in front of it. Here any call-form is taken as a function call only so you can't call procedures here.
• A print level modifier is allowed after an expression list (whether length 1 or more). Again any call-form is taken as a function call only so you can't call procedures here.
• Any list of objects printed, whether by any of the above rules or by the 'print' statement, is placed in the previous value buffer. $1 gives the last printed list, $2 the one before, etc. Note that multi-return values stay as a list of values in the previous value buffer. The only way to get at the individual values of such a list is by assignment to a list of identifiers, or by where (this is of course the only way to get the second result out of Quotrem, etc.). In other places, a $1 expression is evaluated with principal value semantics.

> 1;
1
> x := 3;
> x;
3

> 1 + 1;                  // really function call '+'(1, 1)
2
> Q := [ 0 ];
> Append( Q, 1);          // first (in fact only) match is procedure call
> Append(Q, 1);           // first (in fact only) match is function call
[ 0, 1, 1 ]
> // Assuming fp is assigned to a procedure or function:
> fp(x);                  // whichever fp is at runtime
> SetVerbose("Meataxe", true);  // simple procedure call

> 1, 2;
1 2
> // Assuming f assigned:
> f(x), 1;                            // f only can be a function
> SetVerbose("Meataxe", true), 1;     // type error in 'SetVerbose'
>                                     // (since no function form)

> 1: Magma;
1
> Sym(3), []: Maximal;
Symmetric group acting on a set of cardinality 3
Order = 6 = 2 * 3
[]
> SetVerbose("Meataxe", true): Magma; // type error as above

> 1;
1
> $1;
1
> 2, 3;
2 3
> $1;
2 3
> Quotrem(124124, 123);
1009 17
> $1;
1009 17
> a, b := $1;
> a;
1009

Magma also provides a few procedures to manipulate the previous value buffer in which $1, etc. are stored.

ShowPrevious() : ->

(Procedure.) Show all the previous values stored.

ShowPrevious(i) : RngIntElt ->

(Procedure.) Show the i-th previous value stored.

(Procedure.) Clear all the previous values stored. This is useful for making sure that no more memory is used up than what the current identifiers refer to.

(Procedure.) Set the size of the previous value buffer (this is not how many values are defined in it at the moment, but the maximum number that will be stored). The default size is 3.

Return the size of the previous value buffer.