Macros in Long Form

As a macro in short form can simply be considered a special kind of macro in long form, we first give some explanantion on the latter. A macro definition in long form is introduced through the use of the keyword macrodef. For instance, the following syntax introduces a macro name one that refers to some code, that is, abstract syntax tree (AST) representing the integer number 1.

macrodef one = `(1)

The special syntax `(exp), where no space is allowed between the backquote (`) and the left parenthsis ((), means to form an abstract syntax tree representing the expression written inside the parentheses. This is often referred to as backquote-notation. Intuitively, one may think that a backquote-notation exerts an effect that freezes everything inside it. Let us now define another macro as follows:

macrodef one_plus_one = `(1 + 1)

The defined macro name one_plus_one refers to some code (i.e., AST) representing 1 + 1. At this point, it is important to stress that the code representing 1 + 1 is different from the code representing 2. The macro name one_plus_one can also be defined as follows:

macrodef one_plus_one = `(,(one) + ,(one))

The syntax ,(exp), where no space is allowed between the comma (,) and the left parenthesis ((), indicates the need to expand (or evaluate) the expression written inside the parentheses. This is often referred to as comma-notation, which is only allowed inside a backquote-notation. Intuitively, a comma-notation cancels out the freezing effect of the enclosing backquote-notation.

In addition to macro names, we can also define macro functions. For instance, the following syntax introduces a macro function cube_mac:

macrodef cube_mac (x) =
  `(,(x) * ,(x) * ,(x)) // [x] should refer to some code

Here are some examples that make use of cube_mac:

fun cubesum (i:int, j: int): int =
  ,(cube_mac `(i)) +  ,(cube_mac `(j))
fun volOfSphere (r: double): double =
  4.0 * 3.1416 * ,(cube_mac `(r)) / 3

After macro expansion, the definitions of the functions cubesum and volOfSphere can be written as

fun cubesum (i: int, j: int): int = (i * i * i) + (j * j * j)
fun volOfSphere (r: double): double = 4.0 * 3.1416 * (r * r * r) / 3

Macros in Short Form

The previous macro function cube_mac can also be defined as follows:

macdef cube_mac (x) = ,(x) * ,(x) * ,(x) // [x] should refer to some code

The keyword macdef introduces a macro definition in short form. The previous examples that make use of cube_mac can now be written as follows:

fun cubesum (i:int, j: int): int = cube_mac (i) +  cube_mac (j)
fun volOfSphere (r: double): double = 4.0 * 3.1416 * cube_mac (r) / 3

In terms of syntax, a macro function in short form is just like an ordinary function. In general, if a unary macro function fmac in short form is defined as as follows:

macdef fmac (x) = exp

where exp stands for some expression, then one may essentially think that a macro definition in long form is defined as follows:

macrodef lfmac (x) = `(exp) // please note the backquote

and each occurrence of fmac(arg) for some expresson arg is automatically rewritten into ,(lfmac(`(arg))). Note that macro functions in short form with multiple arguments are handled analogously.

The primary purpose for introducing macros in short form is to provide a form of syntax that seems more accessible. While macros in long form can be defined recursively (as is to be explained later), macros in short form cannot.