[Tex/LaTex] List of higher-level LaTeX commands corresponding to TeX commands

best practicesbig-listmacros

Since LaTeX is a format built on top of TeX, it surely has several high level abstractions that perform similarly to TeX commands, with some added error-handling functionality, for example. I always find scattered advice saying

Instead of \def, use \newcommand

…which I'm sure also applies to other commands.

Is there a document compiling such matches? If not, how about we compile them here? So far, I can think of the following. I may or may not be right with some of them, but I hope it illustrates my point.

\def --> \newcommand, \renewcommand
\hskip --> \hspace
\vskip --> \vspace

The objective is to avoid using low-level TeX commands unless absolutely necessary. And even if it were necessary, confine them inside macro definitions.

I imagine this to be community wiki. ~~So one matchup per answer~~. A big-list community wiki answer has been started below, categorized according to problem domains. Feel free to edit and/or add problem domains and matchups.

A TeX --> LaTeX matchup means that they tackle the same problem domain, so one or more TeX commands may match one or more LaTeX commands. Also include with your answer the reasons (or a link) explaining why the LaTeX alternative is better as a high-level implementation.

Best Answer

On the left are TeX commands, on the right are LaTeX commands with similar functionality.

Macro definitions

\def, \gdef --> \newcommand*, \providecommand*, \renewcommand*
\long\def, \long\gdef --> \newcommand, \providecommand, \renewcommand

For commands with a scope, i.e. including grouping, LaTeX provides \newenvironment and \renewenvironment.

Mathematics

$ ... $ --> $ ... $ with fixltx2e, see Are ( and ) preferable to $
$$ ... $$ --> \[ ... \], see Why is [ … ] preferable to $$
\over --> \frac
\atop, \atopwithdelims, \choose --> \genfrac and derived amsmath commands such as \binom, see Why does amsmath print a warning about a foreign command
\leqno, \eqno --> equation environment, optional leqno class or amsmath option

Tables

\cr, \crcr --> \\, \tabularnewline

Spacing

\kern, \hskip --> \hspace
\vskip --> \vspace

Positioning

\centerline --> \centering or the center environment
\raise --> \raisebox

Miscellaneous

\uppercase --> \MakeUppercase

Related Solutions

[Tex/LaTex] Why do paramaters of \renewcommand need to double up the # within a \foreach

Internally the definition of foreach will be saving the body of the loop in a macro so it is like (if looping over a,b,... )

\def\body{%
\renewcommand*{\SomeCommand}[1]{\color{red}#1}%  Using ## here eliminates the error.
    \par\SomeCommand{\x}%
}%
}
\def\x{a}\body
\def\x{b}\body
...

That initial \def (or \newcommand if you prefer) will require a # in the body to be entered as ##. As shown above you would get an error on #1 as \body doesn't take parameters it would have to be entered, as you found, as ##1.

It is possible to define loops in such a way not to require this (for example it could use a token register rather than a macro for saving the body) but that is apparently not the case here.

Note that the need to double # is unrelated to the fact that there is an inner macro definition. It is not that inner macros require ##1 to refer to the first parameter, it is simply that the inner macro definition requires the two tokens # and 1 to refer to the first parameter and to get a # into a macro body you need ##. To see this consider a definition that doesn't have ##1.

You can go

\let\hash=#

and \hash will be let to # but you can not define a macro as

\def\definehash{\let\hash=#}

as that generates

! Illegal parameter number in definition of \definehash.

You need ## to refer to a literal # in a macro definition. So it needs to be

\def\definehash{\let\hash=##}

You ask in comments why it needs four # for a double nested definition. Again it is nothing special about the inner definitions, they never "see" ##1 by the time they are evaluated they just see a single #. If you tried to define

\def\ddefinehash{\def\definehash{\let\hash=##}}

The definition would proceed without error but then if you try to execute \ddefinehash you find that it just has a single # in its definition and so you get the error as before:

! Illegal parameter number in definition of \definehash.
<to be read again> 
                   }
l.12 \ddefinehash

So you need to get two # into the definition of \definehash and each of those has to be entered as ## so you end up with

\def\ddefinehash{\def\definehash{\let\hash=####}}

Putting it all together:

{
\let\hash=#
}

{
\def\definehash{\let\hash=##}
}

{
\def\ddefinehash{\def\definehash{\let\hash=####}}
\ddefinehash
\definehash

\show\ddefinehash
\show\definehash
\show\hash
}

\bye

> \ddefinehash=macro:
->\def \definehash {\let \hash =####}.
l.15 \show\ddefinehash

? 
> \definehash=macro:
->\let \hash =##.
l.16 \show\definehash

? 
> \hash=macro parameter character #.
l.17 \show\hash

? 
 )
No pages of output.

[Tex/LaTex] Are there any open research problems in the world of TeX

I don't know whether these are open problems or not, but since you are looking for a capstone project, you might be interested to explore if the basic algorithmic aspects of TeX can be improved.

Line-breaking algorithm. The current line breaking algorithm is a gold standard that all line-breaking software emulate, but is it the best way to break lines? Knuth and Plass's algorithm made specific premature optimization choices (pun intended!) like separating page-break from line break, assigning badness based on the raggedness of line but not accounting for rivers, etc. The only real advance since then has been character protrusion, and from what I understand, it still follows the same basic line-breaking algorithm. Now don't get me wrong. I am not saying that these choices were wrong. But a lot of these choices were made because the computational resources of that time could not really handle anything more sophisticated. But now that we have computers that are 1000 times more powerful than those in the 70s, it should be possible to explore other options to see if the line breaking algorithm can be improved by taking into account more factors, especially page-breaking, footnotes, side-notes, and floats. What is better, perfect line breaks but huge vertical spaces to balance the page, or slightly underfull lines but no vertical spaces? There is no way to play around with these in the current framework (please correct me if I am wrong).
Automatic breaking of display equations. Currently the breqn package implements the ideas of Michael J Downes, but AFAIK, the algorithmic aspects are not as well understood as that of line-breaking of text. Is it possible to case line-breaking of display equations as an optimization problem and determine a solution based on penalties and badness?
Parsing natural math. There are recurring questions asking if it is possible to automatically translate <= to \le, sin(x/y) to \sin\left(\frac{x}{y}\right), etc. Although it is possible to do so to a varying degree of success with TeX and LuaTeX (e.g., the calcmath module in ConTeXt), I haven't seen any work that tries to understand how to parse math without markup. Given how sophisticated the current NLP techniques are, it should be possible to do better than simple heuristics for parsing natural math.