How can I capture both superscripts and subscripts after a macro

Question

This question piggy-backs on the answer to Capture a macro's subscripts/superscripts by the macro by egreg.

I'm attempting to use the xparse package to create some macros and I'd rather not have to use different macros when I want to have sub and superscripts (or both at once!).

I'd like a macro like this:

\F
\F{m}
\F{m}_b
\F{m}^a
\F{m}_b^a
\F{m}^a_b

to produce output equivalent to this:

$F$
$F[m]$
$F_b[m]$
$F^a[m]$
$F_b^a[m]$
$F^a_b[m]$

Based on the abolve linked question, I can capture one or the other, but not both. I've made a few attempts, but there must be something very fundamental (or subtle) about now @ifnextchar works that is beyond me.

This code takes two optional arguments, rather than one, but the issue remains: The sub and superscripts always end up at the end of the line, not on the defined first character.

\documentclass{article}
\usepackage{xparse}
\makeatletter
\newcommand{\DFcmd}{\ensuremath{F}}

\NewDocumentCommand\DFhelp{ g g g g }
{
    \IfValueT{#3}{ \def\@DFcmdsub{\DFcmd^{#3}} }{ \def\@DFcmdsub{\DFcmd} }
    \IfValueT{#4}{ \def\@DFcmdsuper{\@DFcmdsub_{#4}} }{ \def\@DFcmdsuper{\@DFcmdsub} }
    \@DFcmdsuper
    \IfNoValueF{#1}{#1}{}
    \IfNoValueF{#2}{#2}{}   
}    

\NewDocumentCommand\DF{ o o }
{%
    \def\firstarg{}%
    \def\secondarg{}%
    \IfNoValueF{#1}{ \def\firstarg{[#1]} }{ \def\firstarg{} }%
    \IfNoValueF{#2}{ \def\secondarg{#2} }{ \def\secondarg{} }%
    \def\superopt{}%
    \def\subopt{}%
    \@ifnextchar^%
    {%
        \assign@superopt%
        \@ifnextchar_%
        {%
            \assign@subopt%
        }%
        {%
            \def\subopt{}%
        }%
    }%
    {%
        \@ifnextchar_%
        {%
            \assign@subopt%
            \@ifnextchar^%
            {%
                \assign@superopt%
            }%
            {%
                \def\superopt{}%
            }%
        }
        {%
            \def\subopt{}%
        }%
    }
    \DFhelp{\firstarg}{\secondarg}{\superopt}{\subopt}%
}    

\def\assign@superopt^#1{ \def\superopt{#1} }
\def\assign@subopt_#1{ \def\subopt{#1} }
\makeatother

Answer 1

Since you only have one mandatory argument (and you are looking for ^ and _) I don't think xparse gains you a lot so i just use \@ifnextchar directly here. Also because you have m in a mandatory {} argument it should always be given so I changed \F to \F{} and added a test for the argument to be empty. (An alternative would be to make the argument optional but then it should be delimited by [] not {}.

\documentclass{article}

\makeatletter
\def\F#1{\def\F@{\ifx\relax#1\relax\else[#1]\fi}\def\F@@{F}\@ifnextchar^\@Fsp\@Fnsp}
\def\@Fsp^#1{\def\F@@{F^{#1}}\@ifnextchar_\@Fspsb{\F@@\F@}}
\def\@Fspsb_#1{\F@@_{#1}\F@}
\def\@Fnsp{\@ifnextchar_{\@Fsb}{\F@@\F@}}
\def\@Fsb_#1{\def\F@@{F_{#1}}\@ifnextchar^\@Fsbsp{\F@@\F@}}
\def\@Fsbsp^#1{\F@@^{#1}\F@}
\begin{document}



$\F{}$

$\F{m}$

$\F{m}_b$

$\F{m}^a$

$\F{m}_b^a$

$\F{m}^a_b$

\end{document}

Answer 2

The following grabs multiple sub and superscripts.

The argument in braces (which apparently is optional) should probably better be in [ ].

Code

\documentclass{article}
\makeatletter
\def\F{%
  \let\f@sub\@empty
  \let\f@super\@empty
  \let\f@main\@empty
  \@ifnextchar\bgroup\f@catch@main\f@test
}
\def\f@catch@main#1{\def\f@main{#1}\f@test}
\def\f@test{%
  \@ifnextchar_\f@catch@sub{\@ifnextchar^\f@catch@super\f@finalize}%
}
\def\f@catch@sub_#1{\expandafter\def\expandafter\f@sub\expandafter{\f@sub#1}\f@test}
\def\f@catch@super^#1{\expandafter\def\expandafter\f@super\expandafter{\f@super#1}\f@test}
\def\f@finalize{%
      F
      \ifx\f@sub\@empty\else_{\f@sub}\fi
      \ifx\f@super\@empty\else^{\f@super}\fi
      \ifx\f@main\@empty\else[\f@main]\fi
}
\makeatother
\begin{document}
$ \F $ \par
$ \F{m} $ \par
$ \F{m}_b $ \par
$ \F{m}^a $ \par
$ \F{m}_b^a $ \par
$ \F{m}^a_b $ \par
$ \F{m}^a_b_a^b $ \par
\end{document}

Output

Answer 3

The following seems to work reasonably well with (at least) the limitation that it requires a space after the macro in order to work.

\documentclass{article}
\usepackage{xparse}
\ExplSyntaxOn

\NewDocumentCommand{\F}{}{
    \peek_charcode:NTF \c_group_begin_token
        {\renstar_F:w}
        {$F$}
}

\cs_new:Npn \renstar_F:w #1#2~ {
    \ensuremath{F#2[#1]}~
}

\ExplSyntaxOff

\begin{document}

\F 

\F{m}

\F{m}_b

\F{m}^a

\F{m}_b^a

\F{m}^a_b

\end{document}

Answer 4

I'd go into a completely different direction. In your case there is no gain whatsoever in defining a complicated macro rather than typing more naturally

$F_{a}^{b}[m]$

In case this is only an example of a more complex situation, I would recommend you a key-value syntax, that avoids chasing for tokens and distinguishing among different situations. This is also more flexible.

Here's the example.

\documentclass{article}
\usepackage{xparse}
\ExplSyntaxOn
\NewDocumentCommand{\DF}{O{}}
 {
  \group_begin:
  \keys_set:nn { renstar/DF } { #1 }
  \renstar_DF:
  \group_end:
 }
\keys_define:nn { renstar/DF }
 {
  arg .tl_set:N = \l_renstar_arg_tl,
  sub .tl_set:N = \l_renstar_sub_tl,
  sup .tl_set:N = \l_renstar_sup_tl,
  symbol .tl_set:N = \l_renstar_symbol_tl,
  symbol .initial:n = F,
 }
\cs_new:Npn \renstar_DF:
 {
  \l_renstar_symbol_tl
  \tl_if_empty:NF \l_renstar_sub_tl
   { \c_math_subscript_token { \l_renstar_sub_tl } }
  \tl_if_empty:NF \l_renstar_sup_tl
   { \c_math_superscript_token { \l_renstar_sup_tl } }
  \tl_if_empty:NF \l_renstar_arg_tl
   { [ \l_renstar_arg_tl ] }
 }
\ExplSyntaxOff

\begin{document}
$\DF$

$\DF[arg=m]$

$\DF[arg=m,sub=a]$

$\DF[sup=b,arg=m]$

$\DF[arg=m,sup=b,sub=a]$

$\DF[symbol=M,sup=x,arg=f]$
\end{document}