Gdddk

Frequently I see users redefine macros using (for example)

letoldmacromacro% Store macro in oldmacro
renewcommandmacro%
 % ...redefined macro
 oldmacro%

and other times they use

usepackageletltxmacro% http://ctan.org/pkg/letltxmacro
LetLtxMacrooldmacromacro% Store macro in oldmacro
renewcommandmacro%
 % ...redefined macro
 oldmacro%

Why would one use LetLtxMacro when let works just as well? Or, more specifically, when would one use LetLtxMacro and/or why?

There are two main cases when LetLtxMacro should be used (and it doesn't harm if used in other cases).

Case 1

The command to get a copy of has been defined with DeclareRobustCommand, like

DeclareRobustCommandfoo[1]-#1-

(with any number of arguments, even zero). There are other commands defined in different ways, but at the end come up as being in this same case.

What happens here is that LaTeX defines two commands, in a way similar to this

deffooprotectfoo•
newcommandfoo•[1]-#1-

where by • I mean a space in the name of the second command. How this trick is achieved is unimportant. We can realize if a command is of this kind by asking texdef: with the command line

> texdef -t latex texttt

we get

texttt:
macro:->protect texttt 

texttt :
long macro:#1->ifmmode nfss@text ttfamily #1else hmode@bgroup text@command #1ttfamily check@icl #1check@icr expandafter egroup fi 

This shows precisely what's happening: texdef prints first the meaning of texttt, which is protecttexttt• (the space here is invisibile), but then know about the nature of this command and so prints also the meaning of texttt• and this is shown by the space before the colon.

What would be the problem in doing

letoldfoofoo
renewcommandfoo[1]!oldfoo#1!

for changing the working of foo? Let's see what happens (I'll continue to use • for denoting the space in the name of a macro).

fooBAR
!oldfooBAR!
!protectfoo•BAR!
!-BAR-!

which seems pretty good: the renewed macro does what we want. But wait! We use DeclareRobustCommand to be sure that foo in moving arguments is treated correctly. So let's see what happens when fooBAR is used in a moving argument, such as a section title; the annotation in the .toc file will contain

!foo BAR!

which in the end will result in printing !!-BAR-!!, which is not what we want. Why? Because the writing process expands unprotected macros. So LaTeX does

fooBAR
!oldfooBAR!
!protectfoo•BAR!
!foo• BAR!

Since foo• was preceded by protect, the last line is what's written. But when the .toc file is read in, TeX only sees a space after foo, because it inputs a text file, so it will dutily expand foo.

If one uses

LetLtxMacrooldfoofoo

LaTeX will essentially do

defoldfooprotectoldfoo•
letoldfoo•foo•

so that the problem above will not appear any more.

Case 2

If the command we want to save the meaning of has been defined with newcommand to have an optional argument, then there are risks like in the previous case; they are explained in this answer. The situation is of the form

newcommandxyz[2][!]#1-#2

and, for instance, smash (as redefined by amsmath) falls in this case. With

texdef -t latex -p amsmath smash

we'd get

smash:
macro:->@protected@testopt smash \smash tb

and this is a clear sign that LetLtxMacro should be used.

Other cases

If the command to save has been defined with newrobustcmd from the etoolbox package, then LetLtxMacro should be used in order to safely copy its meaning.

Warning

Don't try LetLtxMacro with commands defined by NewDocumentCommand (or similar commands) from xparse. The letltxmacro package doesn't support them.