[Tex/LaTex] Bug? LaTeX misparses nested optional arguments

nestingoptional arguments

LaTeX seems to be having problems handling nested optional arguments. I've included a minimal code example that generates the error:

\documentclass[12pt,oneside]{book}
\begin{document}

\newcommand{\termbad}[2][]{#2#1}
\newcommand{\termgood}[2][]{#2#1}

\newcommand{\up}[1]{#1}
\newcommand{\dd}[1][]{#1}

\termgood{\up{Tart}}{Pop}
\termbad[\up{Tart}]{Pop}    

\termgood{\dd[Tart]}{Pop}
\termbad[{\dd[Tart]}]{Pop}
%\termbad[\dd[Tart]]{Pop}


\end{document}

If you run this code, it works. If you remove the % in the second to last line, it fails with:

Runaway argument?

Tart{Pop} \par \par \end {document}

!File ended while scanning use of \dd.

After further tinkering, I have discovered the problem: LaTeX is reading the ] for the inner optional argument as the end of the outer optional argument and then passing a malformed argument in. So it is passing in \dd[Tart as the optional argument to \termbad instead of \dd[Tart].

This still feels like a bug to me. Nesting braces in arguments works, brackets should as well. The following are workarounds:

Enclose the inner optional argument in braces (as in the line before %).
Redefine your inner function to require its argument instead of using optional arguments.
Redefine your outer function to require its argument instead of using optional arguments.

Any one of the three works around the issue.

(Reposted here; question was originally posted to stackexchange and then closed instead of being migrated.)

Best Answer

When TeX reads arguments, then TeX only checks for matching curly braces (characters with catcode 1 and 2). Square brackets are not special in this sense. The first ] that is not hidden inside curly braces is taken as the end of the optional argument. Therefore an additional set of braces is the usual solution:

\foo[{\bar[...]}]{...}

It is only a bug, if this does not work, e.g. if the definition passes optional arguments to other commands:

\def\foo#1#2{\bar[#1]{#2}}

This should be

\def\foo#1#2{\bar[{#1}]{#2}}

Then #1 may contain square brackets, especially ].

Related Solutions

[Tex/LaTex] Optional arguments in pgfkeys

Here are all the ways I know of to do what you want:

First, you could use \pgfkeyslet together with a macro, defined through \newcommand, that takes an optional argument (Marc's approach, simplified a bit but somewhat less functional). The downside: first, you have to remember to take care of the \pgfkeyseov that is inserted, and also, if you only pass one argument, the braces are removed so you have to double them. Marc's method doesn't have this problem (and is therefore perfect for what you ask, but see my last paragraph) but requires you to get your hands fairly dirty with delimited macros, kernel functions, and internal workings of the pgfkeys system (the manual even tells you never to set .@cmd directly).
Second, you could use the .code handler directly together with a \newcommand macro. This makes it unnecessary to deal with \pgfkeyseov but, because the processing passes through an internally-defined macro that takes a single argument delimited by that control sequence, the key's value is handled twice and so you need three levels of braces. This is, obviously, not desirable.
Third, you could use .code 2 args (Andrew's approach), which works if you have learned about the double-processing and remember to add two levels of braces (the third level is unnecessary because the result is not going to be passed to a macro that expects braces).
Fourth, you could give up on having one key with two arguments and do it in what I consider to be the right way: define two keys and some defaults that enforce the mandatory/optional semantics, and have everything go through a macro that sets things up so the usage is transparent. In this one, you just have to write \mykeyfour{mandatory = ?, optional = ?}; if you skip mandatory, then rather than TeX crashing, you simply get an (invalid) text (though you could have it raise an error if you like).

I prefer option four because, in my opinion, what you are asking for literally is in violation of the key-value paradigm. You seem to want to define a key that acts like a LaTeX macro, but keys don't behave like macros: they behave like pgfkeys keys! That has its own rules, its own facilities for setting defaults and handling optional values, and correspondingly, its own syntax conventions. I would also like to observe that it only makes sense to have optional arguments in a top-level key that a user might call: in any internal key, you have enough control to make all arguments explicit. However, in a user-visible key there is a good reason not to do this either.

Among the many technical reasons not to do it the way you want is one practical one: it obscures the intent of the code. Having multiple arguments means that the meaning of the argument must be inferred from the position; but in a key-value system, the whole point is that the meaning can be inferred from the name of the key! If your key is /draw a box and takes an optional argument [height] and mandatory argument {width}, then you have not done better than \makebox. If I were defining a key-value version of makebox I would have it work like \makebox[width = w, height = h]{text} (in fact, I did this in How to create a command with key values?), so that you knew what the random numbers meant. Using keys means you have the freedom to be verbose, to separate the ingredients of your function and have them processed in any order at any time and be handled independently. Use that freedom!

Here are my examples:

\documentclass{article}
\usepackage{pgfkeys}

\makeatletter
% arg 3 = \pgfeov
\newcommand\macro[3][]{(mandatory arg: #2; optional arg: #1)}
\pgfkeyslet{/key/.@cmd}{\macro}
\makeatother

\newcommand\macrotwo[2][]{(mandatory arg: #2; optional arg: #1)}
\pgfkeys{
 /key two/.code = \macrotwo#1
}

\pgfkeys{
 /key three/.code 2 args = {(mandatory arg: #1; optional arg: #2)}
}

\newcommand\mykeyfour[1]{%
 \pgfkeys{/key four,optional,mandatory,#1,print}%
}
\pgfkeys{
 /key four/.is family, /key four,
 optional/.default = {},
 optional/.store in = \keyfouroptional,
 mandatory/.default = {(invalid)},
 mandatory/.store in = \keyfourmandatory,
 print/.code = {(mandatory arg: \keyfourmandatory, optional arg: \keyfouroptional)},
}

\begin{document}
\noindent /key:

 \pgfkeys{/key = [optional]{mandatory}}

 % The braces are removed when the argument is scanned...
 \pgfkeys{/key = {{mandatory}}}

\noindent /key two:

 \pgfkeys{/key two = [optional]{mandatory}}

 % Would you believe that the braces are unwrapped TWICE?
 \pgfkeys{/key two = {{{mandatory}}}}

\noindent /key three:

 \pgfkeys{/key three = {mandatory}{optional}}

 % Braces removed twice again...
 \pgfkeys{/key three = {{mandatory}}}

\noindent /key four:

 \mykeyfour{mandatory = mandatory, optional = optional}

 \mykeyfour{optional = optional, mandatory = mandatory}

 \mykeyfour{mandatory = mandatory}

 \mykeyfour{optional = optional}
\end{document}

Pass optional empty arguments in a newcommand down to another command with optional empty arguments in LaTeX

You can use \NewDocumentCommand.

\NewDocumentCommand{\hlc}{O{yellow}m}{\sethlcolor{#1}\hl{#2}}

\NewDocumentCommand{\hlcite}{oom}{%
  \hlc[green]{%
    \IfNoValueTF{#1}{% no optional argument
      \parencite{#3}%
    }{%
      \IfNoValueTF{#2}{% just one optional argument
        \parencite[#1]{#3}%
      }{% both optional arguments
        \parencite[#1][#2]{#3}%
      }%
    }%
  }% end of \hlc
}

Note that you don't want a space between \sethlcolor{#1} ad \hl{#2}.

Best Answer

Related Solutions

[Tex/LaTex] Optional arguments in pgfkeys

Pass optional empty arguments in a newcommand down to another command with optional empty arguments in LaTeX

Related Question