When a Maple expression is about to be printed, either via a call to the print function, or as output from a user-entered command, the expression undergoes print preprocessing. This modifies the expression in ways that make it easier for the user interface to render it in a suitable form, or to make it more human-readable.

Print preprocessing performs the following actions:

Names of tables, procedures, and modules are replaced by their values.

Procedures of the form `print/foo` are applied to unevaluated functions of the form foo(a, b, ...).

ModulePrint procedures/methods are applied to modules and objects.

Arrays, Matrices, Vectors, and tables are converted to a more compact form if they would be unwieldy to display.

The print_preprocess function can be used to apply print preprocessing to an expression, returning the preprocessed expression instead of printing it. (If the returned value were printed, it would produce the same output as printing the original expression.)

The print_preprocess function is most often used within a `print/foo` or ModulePrint procedure to recursively apply print preprocessing to a sub-expression.

The lprint function does not perform full print-preprocessing, since its purpose is to produce output that is syntactically correct Maple input that recreates the original expression. It does do some preprocessing however:

Arrays, Matrices, and Vectors are processed.

ModuleDeconstruct procedures/methods are applied to modules and objects (the purpose of ModuleDeconstruct is to generate a call to a constructor expression that would recreate the module or object if executed).

m := module()
  export a;
  local ModulePrint := proc()
    return [print_preprocess(a)];
  end proc;
end module:

$m:-a≔5\:$$\mathrm{eval}\left(m\right)$

$\left[5\right]$

$m:-a≔\mathrm{LinearAlgebra}:-\mathrm{RandomMatrix}\left(20\right)\:$$\mathrm{eval}\left(m\right)$

`print/foo` := proc()
local oof, i;
  return oof(seq(print_preprocess([_passed][i]), i = _npassed .. 1, -1));
end proc:

$\mathrm{foo}\left(1\,2\right)$

$\mathrm{oof}\left(2\,1\right)$

$m:-a≔\mathrm{foo}\left(1\,2\right)\:$$\mathrm{eval}\left(m\right)$

$\left[\mathrm{oof}\left(2\,1\right)\right]$

$\mathrm{lprint}\left(\mathrm{print\_preprocess}\left(\mathrm{eval}\left(m\right)\right)\right)$

[oof(2,1)]

$\mathrm{lprint}\left(\mathrm{eval}\left(m\right)\right)$

module () local ModulePrint; export a; ModulePrint := proc () return [print_preprocess(a)] end proc; a := foo(1,2); end module