How do I have to invoke \expandafter for a macro with multiple arguments?

Question

\documentclass[pstricks,border=12pt]{standalone}
\usepackage{pst-node}
\begin{document}
\begin{pspicture}[showgrid](-5,-5)(5,5)
    \pnodes{A}(-2,3)(3,4)(2,-1)(-2,-4)(-4,0)
    \def\points{(0,0)}
    \foreach \x in {0,1,...,4}{%
            \pscircle*[linecolor=blue](A\x){3pt}%
            \xdef\points{\points+.2(A\x)}%
    }
    %The first line below causes errors.
    %\expandafter\nodexn{\points}{B}
    %\pscircle*[linecolor=red](B){3pt}
\end{pspicture}
\end{document}

How do I have to invoke \expandafter for a macro with multiple arguments?

Answer 1

You need to do

\expandafter\nodexn\expandafter{\points}{B}

you need to "jump over" the { too otherwise

\expandafter\nodexn{\points}{B}

just expands { once (to {) before \nodexn gets expanded.

The LaTeX kernel defines a helpful macro \@expandtwoargs as

\def\@expandtwoargs#1#2#3{%
  \edef\reserved@a{\noexpand#1{#2}{#3}}\reserved@a}

which \edefs the first two arguments of a macro before "executing" it. Obviously, you would want to do something like

\makeatletter
\let\expandtwoargs\@expandtwoargs
\makeatother

to be able to use it comfortably. (And of course, this doesn't work for arguments that are not safely fully expandable.)

If you want to expand more than two arguments you can use a temporary macro which contains only the arguments:

\edef\tmp{{\argumentA}{\argumentB}{\argumentC}{\argumentD}}

which then only needs to be expanded once:

\expandafter\myMacro\tmp % \tmp already contains the braces

---

From the same trick box, but quite the opposite problem, namely to expand an argument at the end of a macro with many arguments, can be solved by stuffing everything up to the argument in a temporary macro which than can be "jumped over" very easily:

\def\B{B}
\def\tmp{\myMacro{argument A}{argument B}}
\expandafter\tmp\expandafter{\argumentC}

Otherwise you would need to do

\expandafter\myMacro\expandafter{\expandafter a\expandafter r\expandafter g …

Answer 2

This is a comment on the more general topic raised in Qrrbrbirlbel's answer of selectively expanding one argument of a macro before executing the macro itself. I will take here "expanding" as meaning expanding once, and it is not assumed that the arguments are only single tokens (the expansion will be applied only to the first token of the argument; this could provoke further expansions among this argument of course). My comment is that it is possible to do this expandably.

Nota Bene: a more powerful such "expandable expander" has been added in an edit, below. It also expands only once the (first token of the) targeted argument but this can be promoted to a "full expansion". (see code)

We need these utilities:

\def\expandArg #1#2{\expandafter\expandArgaux\expandafter{#2}{#1}}
\def\expandArgaux #1#2{#2{#1}}

Then imagine I need to have the 3rd of the 5 arguments to \mymacro be expanded once before the execution of \mymacro:

\expandArg {\mymacro {Not me}{Not me}}{Expand Me}{Not me}{Not me} 

does the trick. The difference with the trick mentioned in Qrrbrbirlbel's answer and in comments is that this is expandable in the sense of not needing a \def.

To illustrate:

\def\expandArg #1#2{\expandafter\expandArgaux\expandafter{#2}{#1}}
\def\expandArgaux #1#2{#2{#1}}

\tt
\def\mymacro #1#2#3#4#5{\meaning #3}
\def\x {\y}
\def\y {z}
\mymacro {1}{2}{\x}{4}{5}
\par
\expandArg {\mymacro {1}{2}}{\x}{4}{5}
\bye

Output:

I mentioned in a comment that it was also possible to have the more user-friendly syntax:

\ExpandNth {5}\mymacro{A}{B}{C}{D}{E}{F}{G}

without extra braces, thus, to expandably expand the fifth argument only, prior to the execution of \mymacro.

Here is one way. It acts correctly if given an N zero or less, but will create errors if N exceeds the actual number of arguments. It is also crucial that no spaces are left in-between the arguments of the macro \mymacro to which the expandable expander is applied.

\catcode`\_ 11

\def\ExpandNth #1%
{%
    \romannumeral0\ifnum #1>0
      \expandafter\ExpandNth_a
    \else
      \expandafter\ExpandNth_none
    \fi {#1}%
}
\def\ExpandNth_none #1{ }
\def\ExpandNth_a #1#2{\ExpandNth_b {#1}{#2}}
\def\ExpandNth_b #1%
{%
    \ifnum #1>1
      \expandafter\ExpandNth_c
    \else
      \expandafter\ExpandNth_w
    \fi {#1}%
}
\def\ExpandNth_c #1#2#3%
{%
    \expandafter\ExpandNth_b\expandafter
        {\the\numexpr #1-1}{#2{#3}}%
}%
\def\ExpandNth_w #1#2#3%
{%
    \expandafter\ExpandNth_z\expandafter {#3}{#2}%
}%
% replace #3 above by \romannumeral-`0#3 for "full" expansion

\def\ExpandNth_z #1#2{ #2{#1}}%

\catcode`\_ 8       

\tt

\def\mymacro #1#2#3#4#5{\meaning #1\par
                        \meaning #2\par
                        \meaning #3\par
                        \meaning #4\par
                        \meaning #5\par}
\def\a{\A} \def\A{A}
\def\b{\B} \def\B{B}
\def\c{\C} \def\C{C}
\def\d{\D} \def\D{D}
\def\e{\E} \def\E{E}

\hsize 12cm

Original \string\mymacro:\par
\mymacro \a\b\c\d\e

\medskip\hrule\medskip

With prior (once) expansion of the first argument:\par
\ExpandNth {1}\mymacro \a\b\c\d\e

\medskip\hrule\medskip

With prior (once) expansion of the second argument:\par
\ExpandNth {2}\mymacro \a\b\c\d\e

\medskip\hrule\medskip

With prior (once) expansion of the third argument:\par
\ExpandNth {3}\mymacro \a\b\c\d\e

\medskip\hrule\medskip

With prior (once) expansion of the fourth argument:\par
\ExpandNth {4}\mymacro \a\b\c\d\e

\medskip\hrule\medskip

With prior (once) expansion of the fifth argument:\par
\ExpandNth {5}\mymacro \a\b\c\d\e

\bye

Output:

Answer 3

For this particular application you can simply do

\newcommand{\nodexnX}[1]{\expandafter\nodexn\expandafter{#1}}

and call \nodexnX{\points}{B}

Or you can go further and redefine \nodexn so that it fully expands its first argument

\let\PSTRICKSnodexn\nodexn
\renewcommand{\nodexn}[1]{%
  \begingroup\edef\x{\endgroup
  \noexpand\PSTRICKSnodexn{#1}}\x
}

The LaTeX3 kernel has \exp_args:Nx that's implicitly added with \cs_generate_variant:Nn:

\usepackage{expl3}
\ExplSyntaxOn
\cs_set_eq:NN \pstricks_nodexn:nn \nodexn
\cs_generate_variant:Nn \pstricks_nodexn:nn { x }
\cs_set_eq:NN \nodexn \pstricks_nodexn:xn
\ExplSyntaxOff

If you need to fully expand also the second argument, you can do

\cs_set_eq:NN \pstricks_nodexn:nn \nodexn
\cs_generate_variant:Nn \pstricks_nodexn:nn { xx }
\cs_set_eq:NN \nodexn \pstricks_nodexn:xx

In both case you have effectively redefined \nodexn to expand its argument(s) before the original macro is called.

---

Addition 2022

In the next LaTeX kernel, it will be available \ExpandArgs and

\ExpandArgs{x}\nodexn{\points}{B}

will do the trick. This is an interface to \exp_args:Nx, meaning that the next token is jumped over and the contents of the following braced group will be fully expanded.

You you want to fully expand also the second argument?

\ExpandArgs{xx}\nodexn{\points}{\foo}

will do.

So long as \exp_args:N<characters> exists, one can use \ExpandArgs{<characters>}. The characters are

• N to denote “jump over a token”
• n to denote “jump over a braced group”
• x to fully expand the contents of a braced group using \edef
• e to fully expand the contents of a braced group using \expanded
• f to recursively the contents of a braced group until finding an unexpandable token
• o to expand once the first token inside a braced group

If a needed particular combination does not exist, there is no “official“ user interface to create it, but one can do

\ExplSyntaxOn
\exp_args_generate:n { <characters>, ... }
\ExplSyntaxOff

Many combinations can be generated at once, separating the strings of characters by a comma.

Answer 4

With functional package, tricky argument expansion can be replaced with intuitive function composition, which is similar to other programmming languages such as Lua:

\documentclass[pstricks,border=12pt]{standalone}
\usepackage{pst-node}
\usepackage{functional}
\Functional{scoping=true} % make every function become a group
\begin{document}
\IgnoreSpacesOn
\PrgNewFunction \NodeXn { m m } {
  \nodexn {#1} {#2}
}
\IgnoreSpacesOff
\begin{pspicture}showgrid(5,5)
    \pnodes{A}(-2,3)(3,4)(2,-1)(-2,-4)(-4,0)
    \def\points{(0,0)}
    \foreach \x in {0,1,...,4}{%
            \pscirclelinecolor=blue{3pt}%
            \xdef\points{\points+.2(A\x)}%
    }
    \NodeXn{\Value\points}{B}
    \pscirclelinecolor=red{3pt}
\end{pspicture}
\end{document}