[Tex/LaTex] What are the differences between \def, \edef, \gdef and \xdef?

tex-core

I am a LaTeX guy, slowly working into the miracles of TeX.

Can anybody tell me the differences between \def, \edef, \gdef and \xdef?

Where shall I use which, what are the pros and cons? Or is it suspected to be unclean code, if I mix TeX commands in LaTeX?

Please give a short example, of how to use the command.

Best Answer

There are no pros and cons: \def and \edef perform different tasks. With

\def<cs><parameter text>{<replacement text>}

you define <cs> to look for its arguments (if any) and to be replaced by <replacement text>, which is not interpreted in any way at definition time. With

\edef<cs><parameter text>{<replacement text>}

the replacement text is fully expanded at definition time.

For instance, if we have

\def\aaa{aaa}
\def\bbb{x\aaa}
\edef\ccc{y\aaa}
\def\aaa{AAA}

a call like

\bbb \ccc

would produce

xAAAyaaa

because the replacement text of \ccc is what remains after full expansion, so \edef\ccc{y\aaa} is the same as \def\ccc{yaaa}.

Note that the expansion in \edef is done at definition time, so parameter tokens like #1 and so on will be untouched.

A less silly example: if you want that \thissection expands to the value of the section counter at the time the command is defined, you have to say

\edef\thissection{\thesection}

because this “freezes” the value by doing the expansion at definition time. To the contrary, with \def\thissection{\thesection} the macro \thissection would print the current section number.

LaTeX has the variant \protected@edef that avoids some quirks with “robust macros”, so something like \protected@edef\cs{\textbf{a}} works whereas \edef\cs{\textbf{a}} wouldn't (there's plenty of examples on the site).

About \gdef and \xdef there's not much to say: the former is completely equivalent to \global\def and the latter to \global\edef (assuming primitive meaning of \global, of course). LaTeX has \protected@xdef.

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