<\body> The menu contains several primitives to control the way expressions in the style-sheet language are evaluated. The most frequent use of these primitives is when you want to write a ``meta-macro'' like which is used for defining or computing on other macros. For instance: <\tm-fragment> |>. >||>>>>>>> When calling > in this example, we first evaluate all instructions inside the primitive, which yields the expression <\tm-fragment> ||>>>> Next, this expression is evaluated, thereby defining a macro . It should be noticed that the conventions for evaluation are slightly different then those from conventional functional languages like . The subtle differences are motivated by our objective to make it as easy as possible for the user to write macros for typesetting purposes. For instance, when calls a macro >|>>|>|body>> with arguments > until >, the argument variables > until > are bound to the unevaluated expressions > until >, and the body is evaluated with these bindings. The evaluation of > takes place each time we request for the argument >. In particular, when applying the macro and again >> to an expression , the expression is evaluated twice. In , the bodies of macros are evaluated twice, whereas the arguments of functions are evaluated. On the other hand, when retrieving a variable (whether it is an argument or an environment variable), the value is not evaluated. Consequently, a macro <\tm-fragment> |>>>> would correspond to a macro <\scheme-fragment> (define-macro (foo x) \ \ `(let ((x (lambda () ,x))) \ \ \ \ \ (blah (x) (x))) Conversely, the macro and function <\scheme-fragment> (define-macro (foo x) (blah x x)) (define (fun x) (blah x x)) admit the following analogues in : <\tm-fragment> <\inactive*> |>>>> <\inactive*> ||>>>> Here the primitives and are used to retrieve the value of an argument an environment variable. The primitives , , and behave in the same way as their analogues. The primitive is a shortcut for quasi-quotation followed by evaluation. <\initial> <\collection>