TeX - LaTeX Stack Exchange is a question and answer site for users of TeX, LaTeX, ConTeXt, and related typesetting systems. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

When you write


the results are often identical. What is the difference between these two commands? When do they behave the same? When do they not?

(The question isn't for me; inspired by this question comparing \let and \def, I'm asking this question so it can be used as a reference to point people towards in the future.)

share|improve this question
up vote 34 down vote accepted

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

\bar -> a
\bar -> b


\bar -> a
\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?


{\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.

share|improve this answer
\let\foo\bar and \ea\def\ea\foo\ea{\bar} (where \ea is short for \expandafter) are the same if and only if \bar is a parameterless macro which is not \long, \outer or \protected. So, for example, if we do \newcommand{\bar}{Leo} and \ea\def\ea\foo\ea{\bar}, \foo and \bar will not be the same as far as \ifx is concerned, while with \let\foo\bar they will. – egreg Jun 29 '11 at 23:33

As already has been said \edef expands its argument. This not only mean that the content will be different to a definition with \let, it also means that the argument must be expandable. You can always do a \let\a\b but e.g. \edef\a{\tableofcontents} will break. Also \edef expands its argument, it doesn't execute them. So things like this will not work:

share|improve this answer

The main difference is that \let creates a new reference (a.k.a. name) to an existing value while \def (and friends) creates a completely new value and name pair. If you can get yourself to think of names and values as separate things, then the difference between the two primitives is fairly easy to understand (in my opinion).

share|improve this answer
And if you can't manage to think of names and values as different things, you're not going to get very far with TeX macro programming. (I was going to say "you're going to have trouble", but then I remembered that everyone has trouble...) – SamB Mar 9 '12 at 18:47

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.