[Tex/LaTex] the difference between \empty and \@empty

macrostex-core

I want to elaborate a command that would print differently simple differential dx and multidimensional differential d^3x. For this purpose I invented the command \dif with one optional argument. It is defined as follows:

\newcommand{\dif}[1][]{%
    \def\@tmp@a{#1}%
    \ifx\@tmp@a\@empty
        [b1]\mathrm{d}
    \else
        [b2]\mathrm{d}^{#1}{} \!
    \fi
}

Here [b1] and [b2] are added for debugging. Branch [b1] is intended for the case when the command is called without any argument, e.g. \dif{x}. Second branch [b2] should be taken in case where, e.g., the command \dif[3]{x} is used to print d^3x. The definition, shown above, seems to work fine. However, if \@empty is substituted with \empty first branch is always ignored.

The command \empty is explained in The TeXBook, so that initially I tried it for this code and only occasionally reverted to \@empty having remembered a post at this site where it was said that the \end command of Plain TeX is redefined to \@@end in LaTeX.

Can somebody explain what is the difference between \empty and
\@empty in LaTeX and, perhaps, suggest a better solution for my
problem?

Best Answer

The \@empty and \empty macros are defined in the source file for the LaTeX format latex.ltx on line 122 and 441, respectively:

\def\@empty{}

\let\empty\@empty

So both are actually identical. I as well wondered about having two names for the same thing around. I guess the LaTeX developers wanted a macro which is safer for being redefined by the user or other packages.

You code actually should work with both \@empty and \empty. Put a \show\@empty and \show\empty before your \ifx to debug the issue. Maybe one gets redefined somewhere. In that case you could place a \tracingall\tracingassigns=1\relax \tracingonline=0\relax very early of your document preamble and then search for the redefinition in the log file.

Related Solutions

[Tex/LaTex] the difference between \let and \def

The difference is in the time at which the ‘right hand side’ is evaluated.

Thus \let\foo\bar defines \foo to have the value that \bar had at the point of definition. On the other hand, \def\foo{\bar} in effect defines \foo to have the value that \bar has at the point of use.

Consider:

\def\bar{hello}
\let\fooi\bar
\def\fooii{\bar}
\fooi +\fooii

\def\bar{goodbye}
\fooi +\fooii

This produces

hello+hello
hello+goodbye

This is a simple process.

However it's also a subtle one, so it might be worth highlighting a few key points:

When TeX encounters control sequences such as \fooi, it evaluates them; if these are macros (that is, they have been defined by \def, or \let equal to something which was defined by \def), then the result is that they will expand to other tokens, which TeX will then examine in turn, and so on, recursively, until what's left is either ‘primitive’ control sequences or letters (I'm simplifying a little bit).
\fooi expands directly to the characters hello (because \bar initially did, and \fooi was defined to have the same value).
\fooii, in contrast, expands to \bar, which is then immediately reexamined and reexpanded. In the first case, \bar expands to hello and in the second case to goodbye. The definition of \fooii hasn't changed, but \bar has been redefined in between.
Getting a clear idea of the process of this recursive expansion is very helpful when learning how to develop and debug TeX macros.

[Tex/LaTex] the difference between \let and \edef

\edef expands the argument, whereas \let doesn't. Here is an example to illustrate the difference:

\def\txt{a}
\def\foo{\txt}
\let\bar\foo
\bar -> a
\def\txt{b}
\bar -> b

However,

\def\txt{a}
\def\foo{\txt}
\edef\bar{\foo}
\bar -> a
\def\txt{b}
\bar -> a

There are also other differences, say, the arguments and so on. But how to expansion may be the most important(?).

This is an interesting question. May I expand the question further more?

What is the difference between \let and \expandafter\def\expandafter\foo\expandafter ? Do they always behave the same?

\def\txt{bar}
\def\foo{\txt}
\expandafter\def\expandafter\bar\expandafter{\foo}
\let\BAR\foo

{\tt \string\bar = \meaning\bar}\par
{\tt \string\BAR = \meaning\bar}

Sneaky inline answer to this rhetorical question, since I wrote the original question :)

If you are doing this on macros that take no arguments, then the difference between them is negligible. OTOH, you cannot use the \expandafter\def... construct if you're trying to copy the definition of a macro that takes arguments.

In fact, this brings to light one of the aspects that I was hoping people would discuss here. \let creates a literal copy of a macro at the instant that it is executed, whereas \edef will take the contents of the macro and expand it recursively to create a new macro entirely. When you are only using the macros as places to store data (such as \def\name{Will}) then the differences are largely inconsequential, but when the macros are being used as ‘functions’ that take arguments or have contents that have various expansion restrictions applied to it (with \protected, \noexpand, and so on) then the differences can be very important indeed.

Best Answer

Related Solutions

[Tex/LaTex] the difference between \let and \def

[Tex/LaTex] the difference between \let and \edef

Related Question