How to make a declaration from a command?

Question

There are two forms of setting the type style: the declarative method e.g, \itshape and the command form, e.g, \textit. The command form takes an argument whereas the declarative form does not --- it just applies itself to whatever comes afterwards.

I would like to develop a declarative form, say \UppercaseIt, of the command form \MakeUppercase{<text>}. I have read, in source2e.pdf on CTAN the code for implementing \textit, \itshape and \MakeUppercase and can't claim that I understand any of them. I am after something like {\UppercaseIt some text} instead of \MakeUppercase{some text}.

I only have a code outline of what I'm after, since I don't know how to do it:

\documentclass{article}

\newcommand{\UppercaseIt}{%
  %... magic
}

\begin{document}

\MakeUppercase{some text}% Yields SOME TEXT

{\UppercaseIt some text}% Should yield SOME TEXT

\end{document}

Answer 1

Others already said why this isn't really possible, so I won't bring more sand to this beach. Here's an implementation that fakes that behaviour by scanning ahead until the next explicit close brace, then grabbing everything and passing it to \MakeUppercase as argument.

The implementation uses expl3's new \peek_analysis_map_inline:n to read the input stream token by token, and decide what to do based on the catcode of that token. If a token of catcode 1 (begin group) is found, a counter is increased. Similarly, if a token of catcode 2 (end group) is found, that counter is decreased. If a token of catcode 2 is found, and the counter is zero, the scanning stops, the tokens collected thus far are passed as argument to \MakeUppercase (\text_uppercase:n, actually), and the final end group token found is left to TeX do its thing.

This differs wildly from font commands like \itshape that obey TeX groups. \itshape (using it as the example) will take effect until the current group is closed, or until the document ends. The group-end may be an explicit end group token like }, an implicit one like \egroup, or an actual \endgroup, or some other less common ones, and this token may be hidden inside a macro. The command defined here only works with explicit end group tokens (}), seen without expanding tokens (basically what TeX would accept as the close brace when grabbing an argument to a macro).

Here is the code:

\documentclass{article}
\usepackage{xparse}
\ExplSyntaxOn
\tl_new:N \l__wilson_collect_tl
\int_new:N \l__wilson_nesting_int
\NewDocumentCommand \UppercaseIt { }
  {
    % magic follows:
    \wilson_declarative_command:n
      { \text_uppercase:n {##1} }
  }
\cs_new_protected:Npn \wilson_declarative_command:n #1
  {
    \cs_set_protected:Npn __wilson_do_cmd:n ##1 {#1}
    \tl_clear:N \l__wilson_collect_tl
    \peek_analysis_map_inline:n { __wilson_analyse:nnn {##1} {##2} {##3} }
  }
\cs_new_protected:Npn __wilson_analyse:nnn #1 #2 #3
  {
    \if_case:w "#3 \exp_stop_f:
      \exp_after:wN \use_i:nn
    \or:
      \int_incr:N \l__wilson_nesting_int
      \exp_after:wN \use_i:nn
    \or:
      \int_compare:nNnTF { \l__wilson_nesting_int } = { 0 }
        { \exp_after:wN \use_ii:nn }
        {
          \int_decr:N \l__wilson_nesting_int
          \exp_after:wN \use_i:nn
        }
    \else:
      \exp_after:wN \use_i:nn
    \fi:
      { \tl_put_right:Nn \l__wilson_collect_tl {#1} }
      { __wilson_analyse_end:n {#1} }
  }
\cs_new_protected:Npn __wilson_analyse_end:n #1
  {
    \tl_set:Nx \l__wilson_collect_tl { \l__wilson_collect_tl }
    \peek_analysis_map_break:n
      {
        \exp_last_unbraced:NNNo
          \exp_args:NV __wilson_do_cmd:n \l__wilson_collect_tl
          #1
      }
  }
\ExplSyntaxOff
\begin{document}
\MakeUppercase{some text}% Yields SOME TEXT
{\UppercaseIt some text}% Should yield SOME TEXT
{\UppercaseIt {some} text}% Should yield SOME TEXT
\end{document}

But then, that was just to show off \peek_analysis_map_inline:n, which is really handy. With those restrictions you can get the same behaviour, with much less work by using something simple as:

\documentclass{article}
\newcommand\UppercaseIt{%
  \expandafter\UppercaseItAux
    \expandafter{\iffalse}\fi}
\newcommand\UppercaseItAux[1]{%
  \def\uppercasetmpa{\MakeUppercase{#1}}%
  \expandafter\uppercasetmpa\iffalse{\fi}}
\begin{document}
\MakeUppercase{some text}% Yields SOME TEXT
{\UppercaseIt some text}% Should yield SOME TEXT
{\UppercaseIt {some} text}% Should yield SOME TEXT
\end{document}

Answer 2

New version of the luaotfload package (2020-12-31 luaotfload v3.16) introducess new virtual font features upper and lower. When they are used then the converting is done at font level, exactly as OP expects.

For example, in OpTeX, we can try:

\fontfam[lmfonts]
\def\UppercaseIt{\setff{upper}\currvar}
Normal text 
{\UppercaseIt a {\bf converted} text, accents: áéčš}, 
normal text.
\bye

Answer 3

No solution can do exactly the same as font switching, becuase font switching is done at TeX's main processor and next processing is in "normal" mode: all commands are interpreted just now.

You can do only two pass processing, the parameter is scanned in the first pass and then it is put to \uppercase primitive. But the behavior differs, for example you can:

\fontswitch ... \dosomething exactly now in a macro .... \end{document}

but this cannot work:

\UppercaseIt ...  \dosomething exacty now in a macro ... \end{document}

The implementation of your task is only "academical". I can show you more simple implementation than scanning token per token (shown in another answers here):

\def\UppercaseIt{\afterassignment\UppercaseItA 
   \long\expandafter\def\expandafter\tmp\expandafter{\iffalse}\fi}
\def\UppercaseItA{\uppercase\expandafter{\tmp}\egroup}
Test: {\UppercaseIt some text}% Should yield SOME TEXT
\bye

Answer 4

REVISED ANSWER

With the latest tokcycle package features, one does not need an explicit terminator to the token cycle. Rather, the cycle can peek ahead to see if an end-of-group/environment is next in the input stream and terminate accordingly.

Furthermore, I have created a generic command \MakeDeclarationOf which takes syntax such as

\MakeDeclarationOf\MakeUppercase\UppercaseIt
\MakeDeclarationOf\bang\Foo

to create the declaration \UppercaseIt to make subsequent things uppercase or \Foo to make subsequent things operated on by \bang.

When \MakeDeclarationOf\MakeUppercase\UppercaseIt is invoked, it makes a tokencycle environment with the name \UppercaseIt. An auxiliary command, \testendgroup is used by the tokencycle to check for end-of group/environment tokens in the input stream and, finding one, to insert the tokcycle universal terminator \endtokcycraw in the input stream.

Thus, \UppercaseIt can be terminated with \endUppercaseIt, with a }, with an \egroup, with an \endgroup, or with an \end (if at the current environment depth).

When terminated, the tokencycle takes the collected tokens of the input stream and applies a wrapper consisting of the first argument that had been supplied to \MakeDeclarationOf. Thus, the net result of having something like {\UppercaseIt abc} is that the following tokens are executed: \MakeUppercase{abc}.

The following MWE makes two such declarative commands, to demonstrate that multiple declarations don't interfere with each other.

\documentclass{article}
\usepackage{tokcycle}
\newcounter{envlevel}
\newcommand\MakeDeclarationOf[2]{
\xtokcycleenvironment#2
  {\addcytoks{####1}\testendgroup}
  {\processtoks{####1}\testendgroup}
  {\trackenvs{####1}\addcytoks{####1}\testendgroup}
  {\addcytoks{####1}\testendgroup}
  {\setcounter{envlevel}{0}}
  {\cytoks\expandafter{\expandafter#1\expandafter{\the\cytoks}}}%
}
\newcommand\trackenvs[1]{%
  \ifx\begin#1\stepcounter{envlevel}\else
   \ifx\end#1\addtocounter{envlevel}{-1}\fi\fi   
}
\newcommand\testendgroup{\tcpeek\z
  \ifx\egroup\z\tcpush{\empty\endtokcycraw}\else
  \ifx\endgroup\z\tcpush{\empty\endtokcycraw}\else
  \ifx\end\z\ifnum\value{envlevel}=0 \tcpush{\empty\endtokcycraw}\fi\fi
  \fi\fi
}
\newcommand\bang[1]{!#1!}
\begin{document}
\MakeDeclarationOf\MakeUppercase\UppercaseIt
\MakeDeclarationOf\bang\Foo
Here is {\Foo declaration test} to see \textbackslash bang
This is a test \UppercaseIt of finding endUppercaseIt
\endUppercaseIt
This is a test {\UppercaseIt of finding right brace} 
continuing...
This is a test \bgroup\UppercaseIt of finding egroup\egroup 
continuing...
This is a test \begingroup\UppercaseIt of finding endgroup
\endgroup continuing...
Test \Foo of \begin{itshape}terminating at\end{itshape}
the proper \textbackslash end
\end{document}