TeX \newif: Why \edef And \noexpand Over \def?

Aug 16, 2025 by Henrik Larsen 47 views

$Why \newif Uses \edef with \noexpand Instead of \def in Plain TeX?$

Introduction

Hey guys! Ever wondered why the \newif command in plain TeX is defined using \edef with \noexpand instead of a simple \def? It's a fascinating question that dives deep into the heart of TeX's macro expansion and conditional logic. Understanding this seemingly small detail can unlock a greater appreciation for the power and elegance of TeX's design. In this article, we're going to explore the intricacies of \newif, dissect its definition, and understand why the chosen approach is crucial for its correct functionality. We'll also touch upon alternative approaches and why they might not be as effective. So, buckle up and let's delve into the world of TeX macros!

Understanding the Basics: \def, \edef, and \noexpand

Before we dive into the specifics of \newif, let's quickly recap the fundamental TeX commands involved: \def, \edef, and \noexpand. These commands are the building blocks of macro definitions in TeX, and each plays a unique role. Understanding their differences is crucial for grasping why \newif is defined the way it is.

\def: This is the most basic command for defining macros in TeX. It creates a macro that, when encountered, will be replaced by its replacement text. The replacement text is stored verbatim, meaning that any tokens within it are not expanded until the macro itself is expanded. This is known as lazy expansion. For instance, if you define \def\foo{bar}, then every time \foo is used, it will be replaced by bar. The beauty of \def lies in its simplicity and its ability to create macros that can adapt to different contexts.
\edef: This command, short for "expanded definition," is a more powerful variant of \def. Unlike \def, \edef expands the replacement text at the time of definition. This means that any macros or tokens within the replacement text are immediately expanded until only unexpandable tokens remain. This is known as eager expansion. For example, if you have \def\baz{qux} and then define \edef\foo{\baz}, then \foo will be defined as qux directly, not as \baz. The power of \edef comes from its ability to create macros that are pre-processed, making them potentially more efficient at runtime. However, this also means that you need to be careful about what you expand, as some things might not be ready for expansion at the time of definition.
\noexpand: This command is a crucial tool for controlling expansion in TeX. It prevents the immediate expansion of the token that follows it. When TeX encounters \noexpand<token>, it treats <token> as if it were an unexpandable character, even if it's a macro. This is particularly useful within \edef, where you might want to delay the expansion of certain tokens. For instance, if you have \def\baz{qux} and define \edef\foo{\noexpand\baz}, then \foo will be defined as \baz, not qux. The beauty of \noexpand is that it gives you fine-grained control over the expansion process, allowing you to craft macros that behave exactly as you intend.

The interplay between these three commands is what makes TeX's macro system so powerful and flexible. By combining \edef and \noexpand, we can create macros that are partially expanded, giving us the best of both worlds: efficiency and control.

The \newif Command: A Deep Dive

Now that we have a solid understanding of \def, \edef, and \noexpand, let's focus on the star of our show: the \newif command. This command is a cornerstone of conditional logic in plain TeX, allowing you to create boolean flags that can be used to control the behavior of your documents. The definition of \newif might seem a bit cryptic at first glance, but once we break it down, it reveals a clever use of TeX's macro expansion mechanisms.

The fundamental purpose of \newif is to define three macros for a given name, say \iffoo: \iffoo itself (the conditional), \footrue (to set the condition to true), and \foofalse (to set the condition to false). The plain TeX definition of \newif looks something like this (simplified for clarity):

\outer\def\newif#1{
  \expandafter\ifx\csname#1\endcsname\relax
    \expandafter\edef\csname#1true\endcsname{\noexpand\iftrue}
    \expandafter\edef\csname#1false\endcsname{\noexpand\iffalse}
    \expandafter\edef\csname#1\endcsname{\noexpand\iffalse}
  \else
    \errmessage{...}
  \fi
}

Let's break this down piece by piece:

\outer\def\newif#1{...}: This defines \newif as an outer macro, meaning it can't be used inside certain restricted contexts (like inside other macro definitions). The #1 represents the argument to \newif, which will be the name of the conditional we want to create (e.g., iffoo).
\expandafter\ifx\csname#1\endcsname\relax: This is a clever trick to check if a conditional with the given name already exists. \csname...\endcsname creates a control sequence from the characters given (e.g., \csname iffoo\endcsname creates the control sequence \iffoo). The \ifx then compares this control sequence with \relax. If the control sequence doesn't exist, \csname will return \relax, and the \ifx will be true. The \expandafter is used to expand \csname before \ifx sees it.
\expandafter\edef\csname#1true\endcsname{\noexpand\iftrue}: If the conditional doesn't exist, this line defines the ...true macro (e.g., \iffootrue). The \edef ensures that the definition is expanded immediately. However, \noexpand\iftrue prevents \iftrue from being expanded at definition time; we want \iffootrue to simply be a synonym for \iftrue, not to execute \iftrue right now. The \expandafter ensures that \csname is expanded before \edef sees it.
\expandafter\edef\csname#1false\endcsname{\noexpand\iffalse}: This is similar to the previous line, but it defines the ...false macro (e.g., \foofalse) as a synonym for \iffalse.
\expandafter\edef\csname#1\endcsname{\noexpand\iffalse}: This is the crucial line that defines the conditional itself (e.g., \iffoo). It initializes the conditional to false. Again, \noexpand is used to prevent immediate expansion of \iffalse.
\else ... \fi: If the conditional already exists, the \else branch is executed, and an error message is generated.

The key takeaway here is the use of \edef with \noexpand. This combination allows us to define macros that act as aliases for \iftrue and \iffalse without immediately expanding them. This is essential for the correct behavior of conditionals in TeX. Now, let's explore why using a simple \def wouldn't work as well.

Why Not Just Use \def?

Okay, so we've seen how \newif uses \edef and \noexpand. But why not just use a simple \def? It seems like it would be a simpler approach, right? Well, let's consider what would happen if we tried to define \newif using \def instead.

If we replaced the \edef lines with \def, the definition would look something like this:

\outer\def\newif#1{
  \expandafter\ifx\csname#1\endcsname\relax
    \expandafter\def\csname#1true\endcsname{\iftrue}
    \expandafter\def\csname#1false\endcsname{\iffalse}
    \expandafter\def\csname#1\endcsname{\iffalse}
  \else
    \errmessage{...}
  \fi
}

At first glance, this might seem equivalent. However, there's a subtle but crucial difference in how TeX handles the expansion of macros defined with \def. Remember, \def stores the replacement text verbatim, without immediate expansion. This means that the macros \iffootrue, \foofalse, and \iffoo would be defined to literally contain the tokens \iftrue and \iffalse.

The problem arises when these conditionals are used later in the document. TeX's conditional logic relies on the meaning of \iftrue and \iffalse, not just their literal presence. When TeX encounters a conditional like \iffoo, it needs to see either \iftrue or \iffalse directly to make a decision. If it sees a macro that expands to \iftrue or \iffalse, it's a different story. TeX won't recognize it as a conditional.

To illustrate this, imagine the following scenario:

\newif\iffoo
\footrue
\iffoo
  This text will be printed if \iffoo is true.
\else
  This text will be printed if \iffoo is false.
\fi

If \newif were defined using \def, the \iffoo in the conditional would not be recognized as a conditional. TeX would simply see a macro named \iffoo and wouldn't know how to interpret it in the context of an \if...\else\fi construct. As a result, the conditional would likely fail, or worse, lead to unpredictable behavior.

By using \edef with \noexpand, we ensure that \iffootrue is defined as an alias for \iftrue, and \foofalse as an alias for \iffalse. This means that when TeX expands \iffoo, it directly sees \iffalse (or \iftrue if \footrue has been used), which it can correctly interpret as a conditional.

In essence, the use of \edef with \noexpand in \newif is not just a matter of style; it's a fundamental requirement for the correct functioning of conditionals in TeX. It ensures that the conditional macros are defined in a way that TeX's conditional logic can understand and process.

Alternative Approaches and Why They Fall Short

Now that we've established why \edef with \noexpand is the preferred approach, let's briefly consider some alternative approaches and why they might not be as effective. This will further solidify our understanding of the nuances of TeX's macro expansion.

One alternative might be to use \let to define the conditional macros. \let creates a direct equivalence between two tokens, making one an exact alias of the other. For example, \let\iffootrue\iftrue would make \iffootrue an exact synonym for \iftrue. This approach seems promising, but it has a limitation:

The problem with using \let directly within \newif is that it requires the control sequences \iftrue and \iffalse to be defined at the time \newif is executed. In plain TeX, these conditionals are indeed defined globally. However, in other TeX formats (like LaTeX), the definition of \iftrue and \iffalse might be more complex or might not be available in the same way at all times. This means that a \newif defined using \let might not be portable across different TeX formats.

The \edef with \noexpand approach, on the other hand, is more robust because it doesn't rely on the immediate availability of \iftrue and \iffalse. Instead, it creates macros that, when expanded, will act as \iftrue and \iffalse. This delayed expansion makes the \newif command more flexible and portable.

Another alternative might be to use a different conditional mechanism altogether. TeX provides several ways to implement conditional logic, such as using counters or token lists. However, these approaches often involve more complex code and might not be as efficient or elegant as using the built-in \iftrue and \iffalse conditionals. The \newif command, with its use of \edef and \noexpand, provides a clean and efficient way to create boolean flags that integrate seamlessly with TeX's conditional logic.

Conclusion

So, there you have it! The reason why \newif uses \edef with \noexpand instead of a simple \def in plain TeX boils down to the intricacies of macro expansion and conditional logic. The \edef ensures that the conditional macros are defined as aliases for \iftrue and \iffalse, while \noexpand prevents immediate expansion, allowing the conditionals to be used correctly later in the document. This clever combination ensures that TeX's conditional logic can understand and process the defined conditionals.

We've also explored why alternative approaches, such as using \def directly or \let, might not be as effective due to the way TeX handles macro expansion and the need for portability across different TeX formats. The \edef with \noexpand approach strikes a perfect balance between efficiency, flexibility, and portability.

Understanding this seemingly small detail about \newif can significantly deepen your understanding of TeX's macro system and its powerful capabilities. So, the next time you use \newif in your TeX documents, you'll have a newfound appreciation for the cleverness behind its definition! Keep experimenting and exploring the fascinating world of TeX, guys!