\documentclass[10pt]{article}
\usepackage[margin=1.3in]{geometry}
\usepackage[T2A,T1]{fontenc}             
\usepackage{tokcycle,xcolor,manfnt,lmodern,mathtools}
%%%%TRIAL PACKAGE CHANGES (MAKE SURE EXAMPLE FILE COMPILES CORRECTLY)
\makeatletter
\makeatother
%%%%END TRIAL
\colorlet{bred}{red!90!blue}
\usepackage{tikz}
% MACROS: REDEFINE TO ALLOW \cytoks TO ESCAPE SCOPE OF exampleA
\aftertokcycle{\global\cytoks\expandafter{\the\cytoks}}
% ENVIRONMENTS: REDEFINE TO ALLOW \cytoks TO ESCAPE SCOPE OF exampleA
\makeatletter\renewcommand\tcenvscope{\global\cytoks}\makeatother

\def\ddbend{\setbox0=\hbox{\dbend\dbend}\leavevmode\llap{%
  \raisebox{10pt}{\box0~}}}

\usepackage[skins,listings]{tcolorbox}

\newtcblisting{exampleA}[2][]{%
  colframe=red!70!yellow!50!black,
  colback=red!75!yellow!5!white,
  coltitle=red!50!yellow!3!white,
  bicolor,colbacklower=white,
  top=0mm,bottom=0mm,left=0mm,right=0mm,
  arc=1mm,boxrule=1pt,
  fonttitle=\sffamily\bfseries,
  sidebyside,
  title=#2,#1}

\newtcblisting{exampleB}[2][]{%
  colframe=red!50!yellow!50!black,
  colback=red!50!yellow!5!white,%white,
  coltitle=red!50!yellow!3!white,
  bicolor,colbacklower=white,%red!50!yellow!5!white,
  fonttitle=\sffamily\bfseries,
  sidebyside,text and listing,
  top=0mm,bottom=0mm,left=0mm,right=0mm,
  arc=1mm,boxrule=1pt,
  title=#2,#1}

\newtcblisting{exampleC}[2][]{%
  colframe=cyan!70!yellow!50!black,
  colback=cyan!30!yellow!5!white,%white,
  coltitle=cyan!50!yellow!3!white,
  fonttitle=\sffamily\bfseries,
  listing only,
  top=0mm,bottom=0mm,left=0mm,right=0mm,
  arc=1mm,boxrule=1pt,
  title=#2,#1}

\newtcblisting{exampleD}[2][]{%
  colframe=red!70!yellow!50!black,
  colback=red!20!yellow!5!white,
  coltitle=red!50!yellow!3!white,
  fonttitle=\sffamily\bfseries,
  text only,
  top=0mm,bottom=0mm,left=0mm,right=0mm,
  arc=1mm,boxrule=1pt,
  title=#2,#1}

\def\altdecytoks{\par\medskip\begingroup\noindent\macname{cytoks}
  \ \textit{alt}detokenization:\\\raggedright\footnotesize\ttfamily
  \expandafter\altdetokenize\expandafter{\the\cytoks}\normalsize\par
  \endgroup\medskip}

\newcommand\TokCycle{\textsf{tokcycle}}

\fboxsep=1.5pt
\DeclareUnicodeCharacter{1D60}{$\varphi$}%{\fbox{U+1D60}}
\DeclareUnicodeCharacter{1D131}{$\sharp$}%{\fbox{U+1D131}}

\parindent0pt
\parskip0pt
\begin{document}
{\centering\LARGE \TokCycle{} Package Examples\par\smallskip
\large\today\par}

\tableofcontents

%%%%%%%%%%%%%% SUPPORT MACRO

\newcommand\macname[1]{\texttt{\char92#1}} 

\newcommand\underdot[1]{\ooalign{#1\cr\hfil{\raisebox{-5pt}{.}}\hfil}}

\newcounter{colorindex}

\newcommand\restorecolor{\setcounter{colorindex}{100}}

\newcommand\reducecolor[1]{%
  \color{red!\thecolorindex!cyan}%
  \addtocounter{colorindex}{-#1}%
  \ifnum\thecolorindex<1\relax\setcounter{colorindex}{1}\fi
}

\newif\ifmacro
\newcommand\altdetokenize[1]{\begingroup\stripgroupingtrue\macrofalse
  \stripimplicitgroupingcase{-1}%
  \tokcycle
    {\ifmacro\def\tmp{##1}\ifcat\tmp A\else\unskip\allowbreak\fi\macrofalse\fi
     \detokenize{##1}\ifx##1\bgroup\unskip\fi\ifx##1\egroup\unskip\fi}
    {\ifmacro\unskip\macrofalse\fi\{\processtoks{##1}\ifmacro\unskip\fi\}\allowbreak}
    {\tctestifx{\\##1}{\\}{\ifmacro\unskip\allowbreak\fi
     \allowbreak\detokenize{##1}\macrotrue}}
    { \hspace{0pt plus 3em minus .3ex}}
    {#1}%
  \unskip
\endgroup}

\newcommand\plusl[1]{\char\numexpr`#1+1\relax}

\newcommand\vowelcap[1]{%
  \ifx a#1A\else
  \ifx e#1E\else
  \ifx i#1I\else
  \ifx o#1O\else
  \ifx u#1U\else
  #1\fi\fi\fi\fi\fi
}

\newcommand\spaceouttext[2]{%
  \tokcycle
    {\addcytoks{##1\nobreak\hspace{#1}}}%
    {\processtoks{##1}}
    {\addcytoks{##1}}%
    {\addcytoks{##1\hspace{#1}}}
    {#2}%
  \the\cytoks\unskip}

\newcommand\growdim[2]{%
\tokcycle{\addcytoks{##1}}
         {\addcytoks{#1\dimexpr##1}}
         {\addcytoks{##1}}
         {\addcytoks{##1}}{%
    #2}%
\the\cytoks}

\newcommand\nextcap[1]{%
       \edef\tmp{#1}%
       \tctestifx{-#1}{\def\capnext{T}}{}% <- TEST FOR HYPHEN
       \tctestifcon{\if T\capnext}%
         {\tctestifcon{\ifcat\tmp A}% <- TEST FOR NEXT CAT-11
           {\addcytoks{\uppercase{#1}}\def\capnext{F}}%
           {\addcytoks{#1}}}%
         {\addcytoks{#1}}%
}

\newcommand\TitleCase[1]{%
  \def\capnext{T}% <- INITIAL ENTRY
  \tokcycle
    {\nextcap{##1}}
    {\def\capnext{T}\processtoks{##1}}% <- GROUP ENTRY
    {\addcytoks{##1}}
    {\addcytoks{##1}\def\capnext{T}}% <-CAT-10 SPACE
    {#1}%
  \the\cytoks
}

\tokcycleenvironment\spaceBgone
    {\addcytoks{##1}}
    {\processtoks{##1}}
    {\addcytoks{##1}}
    {\addcytoks{\hspace{.2pt plus .2pt minus .8pt}}}%


\tokcycleenvironment\remaptext
    {\addcytoks[x]{\tcremap{##1}}}
    {\processtoks{##1}}
    {\addcytoks{##1}}
    {\addcytoks{##1}}
\newcommand*\tcmapto[2]{\expandafter\def\csname tcmapto#1\endcsname{#2}}
\newcommand*\tcremap[1]{\ifcsname tcmapto#1\endcsname
  \csname tcmapto#1\expandafter\endcsname\else\expandafter#1\fi}
\tcmapto am   \tcmapto bf   \tcmapto cz   \tcmapto de   \tcmapto ey
\tcmapto fl   \tcmapto gx   \tcmapto hb   \tcmapto ic   \tcmapto jn
\tcmapto ki   \tcmapto lr   \tcmapto mh   \tcmapto nt   \tcmapto ok
\tcmapto ps   \tcmapto qa   \tcmapto ro   \tcmapto sq   \tcmapto tw
\tcmapto uj   \tcmapto vp   \tcmapto wd   \tcmapto xg   \tcmapto yu
\tcmapto zv

\tokcycleenvironment\greek%     NEW TOKCYCLE ENVIRONMENT:
{\addcytoks[4]{\tcremap{##1}}}% HOW TO TREAT CHARACTERS
{\processtoks{##1}}%            HOW TO TREAT GROUP CONTENTS
{\addcytoks{##1}}%              HOW TO TREAT MACROS
{\addcytoks{##1}}%              HOW TO TREAT SPACES

\newcommand\findinstring[2]{\begingroup%
  \stripgroupingtrue
  \setcounter{runcount}{0}%
  \tokcycle
    {\nextctltok{##1}}
    {\nextctltok{\opengroup}\processtoks{##1}\nextctltok{\closegroup}}
    {\nextctltok{##1}}
    {\nextctltok{\tcspace}}
    {#1}%
  \edef\numlet{\theruncount}%
  \expandafter\def\expandafter\searchword\expandafter{\the\cytoks}%
%
  \aftertokcycle{\matchfound}%
  \setcounter{runcount}{0}%
  \def\matchfound{F}%
  \tokcycle
    {\nextcmptok{##1}}
    {\nextcmptok{\opengroup}\processtoks{##1}\nextcmptok{\closegroup}}
    {\nextcmptok{##1}}
    {\nextcmptok{\tcspace}}
    {#2}%
\endgroup}
\newcounter{runcount}
\makeatletter
\newcommand\rotcytoks[1]{\cytoks\expandafter\expandafter\expandafter{%
  \expandafter\tc@gobble\the\cytoks#1}}
\makeatother
\newcommand\testmatch[1]{\ifx#1\searchword\gdef\matchfound{T}\fi}%
\newcommand\rotoradd[2]{\stepcounter{runcount}%
  \ifnum\theruncount>\numlet\relax#1\else#2\fi
  \expandafter\def\expandafter\tmp\expandafter{\the\cytoks}}
\newcommand\nextcmptok[1]{\rotoradd{\rotcytoks{#1}}{\addcytoks{#1}}\testmatch{\tmp}}
\newcommand\nextctltok[1]{\stepcounter{runcount}\addcytoks{#1}}

\newcounter{sigd}
\newcounter{trailingz}
\newif\iffounddot
\newif\ifzerosig
\newcommand\sigdigits[1]{%
  \setcounter{sigd}{0}% SIGNIFICANT DIGIT COUNT
  \setcounter{trailingz}{0}% TRAILING ZERO COUNT
  \founddotfalse% MADE T WHEN DECIMAL HAS BEEN 1ST LOCATED
  \zerosigfalse% MADE T WHEN ZERO BECOMES SIGNIFICANT
  \tokcycle% CYCLE THROOUGH EACH TOKEN
  {\tctestifx{.##1}%
   {\iffounddot\throwerr\fi\founddottrue}% IF .
   {\tctestifnum{`##1>`/}%
    {\tctestifnum{`##1<`:}%
     {\tctestifnum{##1>0}%
      {\stepcounter{sigd}\zerosigtrue\setcounter{trailingz}{0}}% IF 1-9
      {\ifzerosig\stepcounter{sigd}\fi\stepcounter{trailingz}}% IF 0
     }%
     {\throwerr}% IF ASCII > `9
    }%
    {\throwerr}% IF ASCII < `0
   }%
  }% APPLY ABOVE LOGIC FOR CHAR TOKENS
  {\throwerr}% IF BRACES
  {\throwerr}% IF CONTROL SEQUENCE
  {}% IGNORE SPACES
  {#1}% THE ARGUMENT
  \iffounddot\else\addtocounter{sigd}{-\thetrailingz}\fi% TRAILING ZEROS
  \expandafter\ifx\expandafter\relax\detokenize\expandafter{\the\cytoks}%
  \relax\else\setcounter{sigd}{-1}\fi% CHECK FOR INVALID INPUT
  \thesigd
}
\newcommand\throwerr{\addcytoks{##1}}% ADD INVALID TOKS TO \cytoks

\newcounter{Tcount}
\xtokcycleenvironment\capTive% ENVIRONMENT NAME
{\tctestifx{t##1}{\stepcounter{Tcount}\addcytoks{T}}{\addcytoks{##1}}}% CHAR. DIRECTIVE
{\processtoks{##1}}% GROUP DIRECTIVE
{\addcytoks{##1}}% MACRO DIRECTIVE
{\addcytoks{##1}}% SPACE DIRECTIVE
{\setcounter{Tcount}{0}\color{red}\tcafterenv{\ Here}}% INITIALIZATION CODE
{\theTcount{} t's capitalized: \addcytoks{!!}}% CLOSE-OUT CODE

\newcounter{wordcount}
\newcounter{lettercount}
\newif\ifinword
\newif\ifrunningcount
\newcommand\dumpword{%
  \addcytoks[1]{\accumword}%
  \tctestifcon\ifinword{\stepcounter{wordcount}%
    \ifrunningcount\addcytoks[x]{$^{\thewordcount,\thelettercount}$}\fi}{}%
  \inwordfalse\def\accumword{}}
\makeatletter
\newcommand\addletter[1]{%
  \tctestifcatnx A#1{\stepcounter{lettercount}\inwordtrue}{\dumpword}%
  \tc@defx\accumword{\accumword#1}}
\makeatother

\xtokcycleenvironment\countem
  {\addletter{##1}}
  {\processtoks{##1}\dumpword}
  {\dumpword\addcytoks{##1}}
  {\dumpword\addcytoks{##1}}
  {\def\accumword{}\setcounter{wordcount}{0}\setcounter{lettercount}{0}}
  {\dumpword\ifrunningcount\else\tcafterenv{\par(Wordcount=\thewordcount,
    Lettercount=\thelettercount)}\fi}

\newcounter{pointcount}
\newcommand\addtopoints[1]{(\textit{#1 point}%
  \ifnum#1=1\relax\else\textit{s}\fi)}
\NewEnviron{pointtracker}[2][points]{%
  \par\bigskip\resettokcycle
  \setcounter{pointcount}{0}%
  \Macrodirective{\addcytoks{##1}\tctestifx{\addtopoints##1}{\sumpoints}{}}%
  \def\tmp{\tokencyclexpress{\large\bfseries#2: \thepointcount\ #1}}%
  \expandafter\tmp\BODY\endtokencyclexpress
}
\def\sumpoints{\tcpop\Q\addtocounter{pointcount}{\Q}\tcpushgroup{\Q}}

\newcommand\scalerule[1]{%
  \tcpeek\zA
  \ifx[\zA\tcpopuntil]\opt\fi% IF PRESENT, POP OPTIONAL ARG
  \tcpop\ArgA% POP ARG1
  \tcpop\ArgB% POP ARG2
  \tcpushgroup[x]{#1\dimexpr\ArgB}% PUSH BACK IN REVERSE (LIFO) FASHION
  \tcpushgroup[x]{#1\dimexpr\ArgA}
  \ifx[\zA\tcpush[x]{\expandafter\scaleopt\opt{#1}}\fi
}
\def\scaleopt[#1]#2{[#2\dimexpr#1]}

\newcommand\protectruleargs[1]{\ifx\rule#1%
  \tcpeek\zA
  \ifx[\zA\tcpopuntil]\opt
  \addcytoks[1]{\opt}\fi% IF OPTIONAL ARG PRESENT, POP AND SAVE TO \cytoks
  \tcpopliteral\ArgA% MUST POP ARG 1 WITH BRACES
  \addcytoks[1]{\ArgA}%
  \tcpopliteral\ArgB%  MUST POP ARG 2 WITH BRACES
  \addcytoks[1]{\ArgB}%
  \fi
}

\newif\iffoundstring
\newcommand\findstring[4]{% {CURRENT TOK}{MATCH STRING}{SUCCESS OP}{FAIL CMDS}
  \foundstringfalse% DEFAULT CONDITION
  \def\poptoks{}% INITIALIZATION. IF MATCH FAILS, MUST TO RESTORE POPPED TOKENS
  \expandafter\matchnextchar\ifx#1#2\relax\relax\fi\empty\relax
  \iffoundstring\addcytoks{#3{#2}}\else\tcpush{\poptoks}#4\fi
}
\def\matchnextchar#1#2\relax{\tctestifx{#1\empty}{}{% NO MATCH FROM 1ST TOKEN
  \tctestifx{\relax#1}{%
    \foundstringtrue% NOTHING LEFT TO COMPARE; MATCH FOUND
  }{%
    \tcpeek\Q% WITHOUT POPPING...
    \tctestifx{\Q\bgroup}{}{% PEEK FOR GROUPS OR...
      \tctestifx{\Q\tcsptoken}{}{% SPACES THAT INDICATE MATCH FAILURE
        \tcpopappto\poptoks% POP TOKEN AND APPEND TO \poptoks
        \expandafter\tctestifx\expandafter{\Q#1}{%
          \matchnextchar#2\relax% STILL MATCHING; KEEP GOING
        }{}%
      }%
    }%
  }%
}}

\newcommand\foo{$\bullet$}
\newcommand\foocheck[1]{\tcpeek\z\ifx\foo\z\else
  \ifx\par\z\else\addcytoks{#1}\fi\fi}
\tokcycleenvironment\dofoo
  {\addcytoks{##1}}
  {\processtoks{##1}}
  {\ifx\par##1\foocheck{##1}\else\addcytoks{##1}\fi}
  {\foocheck{##1}}

\newcommand\coleqchek[1]{\tcpeek\z
  \ifx=\z\tcpop\z\addcytoks{\coloneqq}\else\addcytoks{#1}\fi}
\tokcycleenvironment\subcoloneqq
{\tctestifx{:##1}{\coleqchek{##1}}{\addcytoks{##1}}}
{\processtoks{##1}}
{\tctestifcon{\if\detokenize{:}\detokenize{##1}}
  {\coleqchek{##1}}{\addcytoks{##1}}}
{\addcytoks{##1}}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Examples, examples, and more examples}

Often, the best way to learn a new tool is to see examples of
  it being used.
Here, a number of examples are gathered that span the spectrum 
  of \TokCycle{} usage.

\subsection{Application basics}

\subsubsection{Using the CGMS directives}

Apply different directives to Characters (under-dot), Groups
  (visible braces), Macros (boxed, detokenized), and 
  Spaces (visible space).

\begin{exampleC}[]{The \macname{underdot} macro}
\newcommand\underdot[1]{\ooalign{#1\cr\hfil{\raisebox{-5pt}{.}}\hfil}}
\end{exampleC}


\begingroup
\begin{exampleA}[lefthand width=7.8cm]{Apply different directives to
  characters{,} groups{,} macros{,} and spaces}
\tokcycle{\addcytoks{\underdot{#1}}}
         {\addcytoks{\{}\processtoks{#1}
          \addcytoks{\}}}
         {\addcytoks{\fbox{\detokenize{#1}}}}
         {\addcytoks{\textvisiblespace}}
{This \textit{is \textbf{a}} test.}
\the\cytoks
\end{exampleA}

\endgroup

\subsubsection{Escaping text}

Text between two successive escape characters is bypassed
  by \TokCycle{} and instead echoed to the output token list 
  (\macname{cytoks}).
The default escape character is $|$.  
One can change the token-cycle escape character by way of the
  \macname{settcEscapechar} macro.
As of version 1.5, the secape character need no longer be restricted to
  ASCII characters, but can now include an otherwise unutilized macro name.
Below, the character codes are incremented by one; however, the
  arguments of \macname{rule} as well as other text are protected against that.

\begingroup

\begin{exampleC}[]{The unexpandable \macname{plusl} macro to increase
 the ASCII value of tokens by 1}
\newcommand\plusl[1]{\char\numexpr`#1+1\relax}
\end{exampleC}

\begin{exampleA}[lefthand width=5cm]{Escaping text and macro parameters 
  in the input stream}
\tokcycle
{\addcytoks{\plusl{#1}}}
{\processtoks{#1}}
{\addcytoks{#1}}
{\addcytoks{#1}}
{This \fbox{code is a test 
  |(I can also escape text)|}
  of |\rule{1em}{.5em}|
  {\bfseries mine}.}
\the\cytoks
\par\settcEscapechar{\Esc}
\tokcyclexpress{%
Now we \Esc test a new escape token \Esc here.}
\the\cytoks
\end{exampleA}

\endgroup

\subsubsection{Unexpandable, unexpanded, and expanded Character 
  directives}

\begingroup
This section concerns the issue of whether the characters of the input
  stream are transformed before or after being placed in the 
  output token list (\macname{cytoks}).

\medskip
\begin{minipage}[t]{\textwidth}
Transform characters (+1 ASCII) via unexpandable macro:\medskip

\begin{exampleA}[lefthand width=8.3cm]
  {Unexpandable Character directive}
\tokcycle
{\addcytoks{\plusl{#1}}}
{\processtoks{#1}}
{\addcytoks{#1}}
{\addcytoks{#1}}{%
  This \textit{code \textup{is} a test} of mine.}
\the\cytoks
\end{exampleA}

\altdecytoks

Note how the above detokenization shows the actual transformation
  instructions involving \macname{plusl}.
This is done because \macname{plusl} is not expandable.
\end{minipage}

\par\noindent\hrulefill\medskip
\endgroup

\noindent\begin{minipage}[t]{\textwidth}
Capitalize vowels (but don't expand the character directive)

\begingroup

\begin{exampleC}[]{The expandable\macname{vowelcap} macro}
\newcommand\vowelcap[1]{%
  \ifx a#1A\else
  \ifx e#1E\else
  \ifx i#1I\else
  \ifx o#1O\else
  \ifx u#1U\else
  #1\fi\fi\fi\fi\fi
}
\end{exampleC}

\begin{exampleA}[lefthand width=8.3cm]
  {Not expanded Character directive}
\tokcycle
{\addcytoks{\vowelcap{#1}}}
{\processtoks{#1}}
{\addcytoks{#1}}
{\addcytoks{#1}}{%
  This \textit{code \textup{is} a test} of mine.}
\the\cytoks
\end{exampleA}

\altdecytoks 

The above detokenization also shows the transformation macro,
  \macname{vowelcap}, as part of \macname{cytoks}.
But because \macname{vowelcap} is expandable, we did not need to
  leave it at this stage, as the next example shows.

\par\noindent\hrulefill\medskip
\endgroup
\end{minipage}

\begin{minipage}[t]{\textwidth}
\begingroup
Capitalize vowels (expanding the character directive)

\medskip
By using the \texttt{[x]} option of \macname{addcytoks}, the 
  \macname{vowelcap} is fully expanded prior to being placed in
  the \macname{cytoks} token list.


\begin{exampleA}[lefthand width=8.3cm]
  {Expanded Character directive}
\tokcycle
{\addcytoks[x]{\vowelcap{#1}}}
{\processtoks{#1}}
{\addcytoks{#1}}
{\addcytoks{#1}}{%
  This \textit{code \textup{is} a test} of mine.}
\the\cytoks
\end{exampleA}

\altdecytoks

Here, we see no vestiges of \macname{vowelcap} in \macname{cytoks}, 
  but only the transformed result.
\endgroup
\end{minipage}

\enlargethispage{12pt}
\subsubsection{Unexpanded vs. pre-expanded input stream}

\begingroup
\Characterdirective{\addcytoks[x]{\vowelcap{#1}}}

\noindent\begin{minipage}[t]{\textwidth}
\begin{exampleA}[lefthand width=5.5cm]{Normal token cycle (input stream
  not pre-expanded)}
\tokcycle
{\addcytoks[x]{\vowelcap{#1}}}
{\processtoks{#1}}
{\addcytoks{#1}}
{\addcytoks{#1}}%
{This \fbox{code 
  is a test \today} of 
  {\bfseries mine}.}
\the\cytoks
\end{exampleA}

\altdecytoks

In the above case, vowel-capping is not applied to the date, because
  \macname{today} remains unexpanded in the \macname{cytoks} token list.

\noindent\hrulefill\strut
\end{minipage}

Note that, when pre-expanding the input stream, one must 
  \macname{noexpand} the macros that are \textit{not} 
  to be pre-expanded.

\begin{exampleA}[lefthand width=5.5cm]{Pre-\macname{expanded} token cycle
  input stream}
\expandedtokcyclexpress
{This \noexpand\fbox{code 
  is a test \today} of 
  {\noexpand\bfseries mine}.}
\the\cytoks
\end{exampleA}

\altdecytoks

Here, we see the date subjected to vowel-capping, because the \TokCycle{}
  input was expanded prior to the token cycle.
Thus \macname{today} no longer appears \textit{explicitly} in the 
  \macname{cytoks} token list.
Its pre-expansion into character tokens is now subject to the 
  \macname{vowelcap}.

\endgroup

\subsection{Grouping}

Differentiating explicit groups, e.g., \{...\}, from
  implicit groups, e.g. \macname{bgroup}...\macname{egroup},
  is done automatically by \TokCycle.
The user has options on how \TokCycle{} should treat these tokens.
The desired options are to be set prior to the \TokCycle{} invocation.


\subsubsection{Treatment options for implicit groups}

\begingroup

The macro
\macname{stripimplicitgroupingcase} can take three possible
  integer arguments: 0 (default) to automatically place unaltered
  implicit group tokens in the \macname{cytoks} output; 1 to strip
  implicit group tokens from the output; or $-$1 to instead pass the
  implicit group tokens to the Character directive (as implicit
  tokens) for separate processing (typically, when detokenization
  is desired).

\begin{exampleA}[lefthand width=6cm]{Using 
  \macname{stripimplicitgroupingcase} to affect treatment of 
  implicit grouping tokens}
\resettokcycle
\Characterdirective{\addcytoks[x]{%
  \vowelcap{#1}}}
\def\z{Announcement: 
  {\bfseries\bgroup\itshape 
  Today \egroup it is} \today, 
  a Wednesday}
\expandafter\tokencyclexpress\z
\endtokencyclexpress\medskip

\detokenize\expandafter{\the\cytoks}
\bigskip

\stripimplicitgroupingcase{1}
\expandafter\tokencyclexpress\z
\endtokencyclexpress\medskip

\detokenize\expandafter{\the\cytoks}
\end{exampleA}

%\tokcyclexpress{Announcement: {\bfseries\bgroup\itshape 
%  Today \egroup it is} \today, a Wednesday.}\the\cytoks

%\detokenize\expandafter{\the\cytoks}

\endgroup

\subsubsection{Treatment options for explicit groups}

\begingroup

For explicit group tokens, e.g., \{ \}, there are only two 
  options to be had.
These are embodied in the if-condition \macname{ifstripgrouping} 
  (default \macname{stripgroupingfalse}).
Regardless of which condition is set, the tokens within the explicit
  group are still passed to the Group directive for processing.

\medskip
Permutations of the following code are used in the subsequent examples.
Group stripping, brought about by \macname{stripgroupingtrue},
  involves removing the grouping braces from around the group.
The choice of \macname{processtoks} vs.\@ \macname{addcytoks}
  affects whether the tokens inside the group are recommitted
  to \TokCycle{} for processing, or are merely sent to the
  \macname{cytoks} token list in their original unprocessed form.

\medskip
Note that, in these examples, underdots and visible spaces
  will only appear on characters and spaces that have been directed 
  to the Character and Space directives, respectively.
Without \macname{processtoks}, that will not occur to tokens
  \textit{inside} of groups.

\begin{exampleB}[listing only,lefthand width = \dimexpr\textwidth-19pt]
{Code permutations on group stripping and inner-group token processing}
\stripgroupingfalse  OR  \stripgroupingtrue
\tokcycle{\addcytoks{\underdot{#1}}}
         {\processtoks{#1}}  OR  {\addcytoks{#1}}}
         {\addcytoks{#1}}
         {\addcytoks{\textvisiblespace}}
{This \fbox{is a \fbox{token}} test.}
\the\cytoks
\end{exampleB}


\begin{exampleB}[text only,  colback=white]%
{\macname{stripgroupingfalse \string\processtoks} }
\stripgroupingfalse% RETAIN GROUPING (PACKAGE DEFAULT)
\tokcycle{\addcytoks{\underdot{#1}}}
         {\processtoks{#1}}% GROUP TOKENS ARE PROCESSED
         {\addcytoks{#1}}
         {\addcytoks{\textvisiblespace}}{%
This \fbox{is a \fbox{token}} test.}
\the\cytoks
\end{exampleB} 

\begin{exampleB}[text only,  colback=white]%
{\macname{stripgroupingfalse \string\addcytoks} }
\tokcycle{\addcytoks{\underdot{#1}}}
         {\addcytoks{#1}}% GROUP TOKENS OUTPUT DIRECTLY
         {\addcytoks{#1}}
         {\addcytoks{\textvisiblespace}}{%
This \fbox{is a \fbox{token}} test.}
\the\cytoks
\end{exampleB}

\begin{exampleB}[text only,  colback=white]%
{\macname{stripgroupingtrue \string\processtoks} }
\stripgroupingtrue% DANGEROUS AS IT REMOVES GROUPING FROM ARGUMENTS
\tokcycle{\addcytoks{{\underdot{#1}}}}% EXTRA GROUPING TO COMPENSATE
         {\processtoks{#1}}% GROUP TOKENS PROCESSED
         {\addcytoks{#1}}
         {\addcytoks{\textvisiblespace}}{%
This \fbox{is a \fbox{token}} test.}
\the\cytoks
\end{exampleB}

\begin{exampleB}[text only,  colback=white]%
{\macname{stripgroupingtrue \string\addcytoks} }
\stripgroupingtrue% DANGEROUS AS IT REMOVES GROUPING FROM ARGUMENTS
\tokcycle{\addcytoks{\underdot{#1}}}
         {\addcytoks{#1}}% GROUP TOKENS OUTPUT DIRECTLY
         {\addcytoks{#1}}
         {\addcytoks{\textvisiblespace}}{%
This \fbox{is a \fbox{token}} test.}
\the\cytoks
\end{exampleB} 

Note that the content of groups can be altogether eliminated if 
  \textit{neither} \macname{processtoks\{\#1\}} nor 
  \macname{addcytoks\{\#1\}} are used in the Group directive.



\endgroup

\subsubsection{Group nesting}

\begingroup

\begin{exampleC}[]{The \macname{reducecolor} and \macname{restorecolor}
  macros}
\newcounter{colorindex}
\newcommand\restorecolor{\setcounter{colorindex}{100}}
\newcommand\reducecolor[1]{%
  \color{red!\thecolorindex!cyan}%
  \addtocounter{colorindex}{-#1}%
  \ifnum\thecolorindex<1\relax\setcounter{colorindex}{1}\fi}
\end{exampleC}

\begin{exampleA}[lefthand width=6cm]{Group nesting is no impediment to
  tokcycle}
\restorecolor
\tokcycle
  {\addcytoks{(#1)}}
  {\addcytoks{\reducecolor{11}}%
   \addcytoks{[}\processtoks{#1}%
   \addcytoks{]}}
  {\addcytoks{#1}}
  {}{%
  {1{{3{{5{{7{{9{1{}0}}8}}6}}4}}2}}}
\the\cytoks
\end{exampleA}
Note, above, that \TokCycle{} does not rely on an argument-based nesting
  algorithm that would otherwise be limited to 9 embedded groups.
\endgroup

\subsubsection{The use of \macname{groupedcytoks} for more sophisticated
  group processing}

\begingroup

\begin{sloppypar}
By default, \TokCycle{} processes groups such that whatever additions to the
  \macname{cytoks} token list you accomplish in the Group directive will be 
  encased in an explicit grouped scope.
This is the token-cycle behavior with the default \macname{stripgroupingfalse} 
  declaration.
However, for more sophisticated tasks associated with the processing of
  group content, one may override the default (by way of 
  \macname{stripgroupingtrue}) and manually dictate the groupings associated 
  with the Group directive, with the use of \macname{groupedcytoks\{...\}}.
\end{sloppypar}

\medskip In the following example, tasks A and D are performed \textit{outside}
  of the explicit grouping otherwise introduced with \macname{groupedcytoks},
  whereas tasks B and C fall inside of that explicit group.
The fact that, in the output, \texttt{d} is not italic confirms the 
  fact that task D occurs after the conclusion of the explicit \macname{cytoks} 
  group that encompasses the italic `bxc'.
The fact that none of \texttt{a}, \texttt{b}, \texttt{c}, nor \texttt{d} are
  encased in an \macname{fbox} indicates that they were not processed through
  the Character directive, but arose from direct additions to \macname{cytoks},
  by way of their tasks.

\begin{exampleA}[lefthand width=10cm]{Use of the \macname{groupedcytoks}
  macro}
\stripgroupingtrue
\Characterdirective{\addcytoks{\fbox{#1}}}
\Groupdirective{\taskA%
  \groupedcytoks{\taskB\processtoks{#1}\taskC}%
  \taskD}
\def\taskA{\addcytoks{\bgroup\LARGE a}}
\def\taskB{\addcytoks{\itshape b}}
\def\taskC{\addcytoks{c}}
\def\taskD{\addcytoks{d\egroup}}

\tokcyclexpress{x\textbf{x}x}
\the\cytoks
\end{exampleA}

The final disposition of the \macname{cytoks} token list shows the effects of
  \macname{stripgroupingtrue} and \macname{groupedcytoks} more explicitly:

\altdecytoks

Without \macname{stripgroupingtrue}, all tasks, A,B,C, and D, would have
  been contained within the explicit \texttt{\{...\}} group.

\endgroup



\subsection{Direct use of \TokCycle}

The \TokCycle{} macros and pseudo-environments
  (in regular or \texttt{xpress} form) may be invoked 
  directly from the document, without
  being first encapsulated within a separate macro or environment.

\subsubsection{Modifying counters as part of the Character
  directive}

\begingroup

\begin{exampleA}[lefthand width=8.5cm]{Using a period token (.) to
  reset a changing color every sentence}
\restorecolor
\tokencycle
  {\addcytoks{\bgroup\reducecolor{3}#1\egroup}%
   \ifx.#1\addcytoks{\restorecolor}\fi}
  {\processtoks{#1}}
  {\addcytoks{#1}}
  {\addcytoks{#1}}%
This right \textit{here is a sentence in italic}.  
And \textbf{here we have another sentence in bold}.

{\scshape Now in a new paragraph, the sentence 
is long.} Now, it is short.
\endtokencycle
\end{exampleA}

\endgroup

\subsection{Macro encapsulation of \TokCycle}

\subsubsection{Spacing out text}

\begingroup

\begin{exampleC}[]{The \macname{spaceouttext} macro}
\newcommand\spaceouttext[2]{%
  \tokcycle
    {\addcytoks{##1\nobreak\hspace{#1}}}%
    {\processtoks{##1}}
    {\addcytoks{##1}}%
    {\addcytoks{##1\hspace{#1}}}
    {#2}%
  \the\cytoks\unskip}
\end{exampleC}

\begin{exampleA}[lefthand width=6cm]{\macname{spaceouttext} demo}
\spaceouttext{3pt plus 3pt}{This 
  \textit{text \textbf{is} 
  very} spaced out}. Back 
  to regular text.

\spaceouttext{1.5pt}{This 
  \textit{text \textbf{is} 
  somewhat} spaced out}. 
  Back to regular text.
\end{exampleA}

Note that embedded macros such as \macname{textit} and \macname{textbf}
  do not adversely affect the capability of the \macname{spaceouttext}
  macro.
\endgroup


\subsubsection{Alternate presentation of detokenized content}

\begingroup
This macro attempts to give a more natural presentation of 
  \macname{detokenize}'d material.
It is \textbf{not} to be confused as a replacement for
  \macname{detokenize}.
In certain applications, it may offer a more pleasingly formatted
  typesetting of detokenized material.

\medskip It is an unusual application of \TokCycle{} in that it does not
  actually use the \macname{cytoks} token list to collect
  its output.
This is only possible because all macros in the input stream
  are detokenized, rather than executed.

\medskip

\begin{exampleC}[]{The \macname{altdetokenize }\ macro}
\newif\ifmacro
\newcommand\altdetokenize[1]{\begingroup\stripgroupingtrue\macrofalse
  \stripimplicitgroupingcase{-1}%
  \tokcycle
    {\ifmacro\def\tmp{##1}\ifcat\tmp A\else\unskip\allowbreak\fi\macrofalse\fi
     \detokenize{##1}\ifx##1\bgroup\unskip\fi\ifx##1\egroup\unskip\fi}
    {\ifmacro\unskip\macrofalse\fi\{\processtoks{##1}\ifmacro\unskip\fi\}\allowbreak}
    {\tctestifx{\\##1}{\\}{\ifmacro\unskip\allowbreak\fi
     \allowbreak\detokenize{##1}\macrotrue}}
    { \hspace{0pt plus 3em minus .3ex}}
    {#1}%
  \unskip
\endgroup}
\end{exampleC}

\let\mac\relax
\begin{exampleA}[lefthand width=6.3cm]
  {\macname{altdetokenize} demo}
\string\altdetokenize: \\
\texttt{\altdetokenize{a\mac a \mac2 {\mac}\mac{a\mac\mac}\mac}}!

versus \string\detokenize: \\ 
   \texttt{\detokenize{a\mac a \mac2 {\mac}\mac{a\mac\mac}\mac}}!
\end{exampleA}
\endgroup


\subsubsection{Capitalize all words, including compound and 
  parenthetical words\label{s:cap}}

\begingroup

\begin{exampleC}[]{The \macname{Titlecase} and \texttt{\string\nextcap} macros}
\newcommand\TitleCase[1]{%
  \def\capnext{T}% <- INITIAL ENTRY
  \tokcycle
    {\nextcap{##1}}
    {\def\capnext{T}\processtoks{##1}}% <- GROUP ENTRY
    {\addcytoks{##1}}
    {\addcytoks{##1}\def\capnext{T}}% <-CAT-10 SPACE
    {#1}%
  \the\cytoks
}
\newcommand\nextcap[1]{%
       \edef\tmp{#1}%
       \tctestifx{-#1}{\def\capnext{T}}{}% <- TEST FOR HYPHEN
       \tctestifcon{\if T\capnext}%
         {\tctestifcon{\ifcat\tmp A}% <- TEST FOR NEXT CAT-11
           {\addcytoks{\uppercase{#1}}\def\capnext{F}}%
           {\addcytoks{#1}}}%
         {\addcytoks{#1}}%
}
\end{exampleC}

\begin{exampleA}[]{A demo of \macname{Titlecase} showing raw (escaped)
  input and processed output}
\TitleCase{%
|here, {\bfseries\today{}, is [my]}
  really-big-test  
  (\textit{capitalizing} words).|

 here, {\bfseries\today{}, is [my]} 
  really-big-test 
  (\textit{capitalizing} words).}
\end{exampleA}

As it is currently set up, a future-capitalization of the next catcode-11 token will be triggered when any of the following is encountered in the input stream:
\begin{itemize}
\item    The initial entry into the routine

\item    a catcode-10 space token

\item    a hyphen \texttt{-}

\item    upon entry into a group \texttt{\{...\}}
\end{itemize}

Obviously, additional tests could be added.

\endgroup

\subsubsection{Scaling rule dimensions}
\begingroup

\ddbend This example only applies if one can guarantee that
  the input stream will contain only text and rules...

\begin{exampleC}[]{The \macname{growdim} macro}
\newcommand\growdim[2]{%
\tokcycle{\addcytoks{##1}}
         {\addcytoks{#1\dimexpr##1}}
         {\addcytoks{##1}}
         {\addcytoks{##1}}{%
    #2}%
\the\cytoks}
\end{exampleC}

\begin{exampleA}[]{Using \TokCycle{} to change \macname{rule} dimensions}
\growdim{2}{This rule is exactly 4pt: 
  \rule|{4pt}{4pt}| , whereas this
  rule is 2x bigger than 4pt: 
  \rule{4pt}{4pt} .}\par
\growdim{4}{This rule is exactly 5pt: 
  \rule|{5pt}{5pt}| , whereas this
  rule is 4x bigger than 5pt: 
  \rule{5pt}{5pt} .}
\end{exampleA}

\endgroup

\subsubsection{String search, including non-regex material\label{s:searchA}}

\begingroup

\begin{exampleC}[]{The \macname{findinstring} macro for string searches}
\newcommand\findinstring[2]{\begingroup%
  \stripgroupingtrue
  \setcounter{runcount}{0}%
  \tokcycle
    {\nextctltok{##1}}
    {\nextctltok{\opengroup}\processtoks{##1}\nextctltok{\closegroup}}
    {\nextctltok{##1}}
    {\nextctltok{\tcspace}}
    {#1}%
  \edef\numlet{\theruncount}%
  \expandafter\def\expandafter\searchword\expandafter{\the\cytoks}%
%
  \aftertokcycle{\matchfound}%
  \setcounter{runcount}{0}%
  \def\matchfound{F}%
  \tokcycle
    {\nextcmptok{##1}}
    {\nextcmptok{\opengroup}\processtoks{##1}\nextcmptok{\closegroup}}
    {\nextcmptok{##1}}
    {\nextcmptok{\tcspace}}
    {#2}%
\endgroup}
\newcounter{runcount}
\makeatletter
\newcommand\rotcytoks[1]{\cytoks\expandafter\expandafter\expandafter{%
  \expandafter\tc@gobble\the\cytoks#1}}
\makeatother
\newcommand\testmatch[1]{\ifx#1\searchword\gdef\matchfound{T}\fi}%
\newcommand\rotoradd[2]{\stepcounter{runcount}%
  \ifnum\theruncount>\numlet\relax#1\else#2\fi
  \expandafter\def\expandafter\tmp\expandafter{\the\cytoks}}
\newcommand\nextcmptok[1]{\rotoradd{\rotcytoks{#1}}{\addcytoks{#1}}\testmatch{\tmp}}
\newcommand\nextctltok[1]{\stepcounter{runcount}\addcytoks{#1}}
\end{exampleC}

\begin{exampleA}[lefthand width=11.5cm]{Demo of the 
  \macname{findinstring} macro}
1. \findinstring{this}{A test of the times}
   \findinstring{the} {A test of the times}\par
2. \findinstring{This is}{Here, This is a test}
   \findinstring{Thisis} {Here, This is a test}\par
3. \findinstring{the}        {This is the\bfseries{} test}
   \findinstring{he\bfseries}{This is the\bfseries{} test}\par
4. \findinstring{a{bc}} {gf{vf{a{b c}g}gh}hn}
   \findinstring{a{b c}}{gf{vf{a{b c}g}gh}hn}\par
5. \findinstring{a\notmymac{b c}}{gf{vf{a\mymac{b c}g}gh}hn}
   \findinstring{a\mymac{b c}}   {gf{vf{a\mymac{b c}g}gh}hn}\par
6. \findinstring{\textit{Italic}}{this is an \textit{italic} test}
   \findinstring{\textit{italic}}{this is an \textit{italic} test}
\end{exampleA}

\endgroup

\subsubsection{Counting the significant digits in a number}

\begingroup

The problem of counting the significant digits in a number is an interesting
  one, in that leading zeros are not significant, trailing zeros are sometimes
  significant, but zeros in the middle of the number are significant. 
In a problem like this, the \macname{cytoks} token list is not used to
  carry a transformation of the input tokens, but only to carry a record
  of errant tokens from the input (as seen from the helper macro
  \macname{throwerr}).
If \macname{the\textbackslash cytoks} is anything other than empty when the
  macro completes, the macro will set the significant-digit counter 
  \texttt{sigd} to a value of -1 to signify an error condition.

\medskip
The macro expects its input to comprise digits in the 0--9 range, an [optional]
  single decimal point, and ignorable spaces.  Any other token will throw
  an error.

\medskip
The main work of the \macname{sigdigits} macro is to use the counters
  \texttt{sigd} to count significant digits and \texttt{trailingz} to
  tabulate the number of trailing-zeros with which to decrement
  \texttt{sigd}.

\begin{exampleC}[]{The \macname{sigdigits} macro for counting significant digits}
\newcounter{sigd}
\newcounter{trailingz}
\newif\iffounddot
\newif\ifzerosig
\newcommand\sigdigits[1]{%
  \setcounter{sigd}{0}% SIGNIFICANT DIGIT COUNT
  \setcounter{trailingz}{0}% TRAILING ZERO COUNT
  \founddotfalse% MADE T WHEN DECIMAL HAS BEEN 1ST LOCATED
  \zerosigfalse% MADE T WHEN ZERO BECOMES SIGNIFICANT
  \tokcycle% CYCLE THROOUGH EACH TOKEN
  {\tctestifx{.##1}%
   {\iffounddot\throwerr\fi\founddottrue}% IF .
   {\tctestifnum{`##1>`/}%
    {\tctestifnum{`##1<`:}%
     {\tctestifnum{##1>0}%
      {\stepcounter{sigd}\zerosigtrue\setcounter{trailingz}{0}}% IF 1-9
      {\ifzerosig\stepcounter{sigd}\fi\stepcounter{trailingz}}% IF 0
     }%
     {\throwerr}% IF ASCII > `9
    }%
    {\throwerr}% IF ASCII < `0
   }%
  }% APPLY ABOVE LOGIC FOR CHAR TOKENS
  {\throwerr}% IF BRACES
  {\throwerr}% IF CONTROL SEQUENCE
  {}% IGNORE SPACES
  {#1}% THE ARGUMENT
  \iffounddot\else\addtocounter{sigd}{-\thetrailingz}\fi% TRAILING ZEROS
  \expandafter\ifx\expandafter\relax\detokenize\expandafter{\the\cytoks}%
  \relax\else\setcounter{sigd}{-1}\fi% CHECK FOR INVALID INPUT
  \thesigd
}
\newcommand\throwerr{\addcytoks{##1}}% ADD INVALID TOKS TO \cytoks
\end{exampleC}

\begin{exampleA}[lefthand width=8.0cm]{Example use of the \macname{sigdigits}
  macro}
1) \sigdigits{12.3}\\
2) \sigdigits{0.123}\\
3) \sigdigits{1.2.3}\\
4) \sigdigits{1.3\today}\\
5) \sigdigits{321.345 678}\\
6) \sigdigits{000321.305}\\
7) \sigdigits{.000 300 345}\\
8) \sigdigits{0003x1.345}\\
9) \sigdigits{123000}\\
A) \sigdigits{123.000}\\
B) \sigdigits{0003;345}
\end{exampleA}

\endgroup


\subsection{Creating your own \TokCycle-based environments}

The \macname{tokcycleenvironment} macro allows users to define
  their own \TokCycle{} environments.  
The more recently introduced \macname{xtokcycleenvironment} macro extends 
  that capability to allow initialization and postprocessing when defining
  a named \TokCycle{} environment.
Here are some examples of both types.

\subsubsection{``Removing'' spaces, but still breakable/hyphenatable}

\begingroup

\begin{exampleC}[]{The \macname{spaceBgone} environment}
\tokcycleenvironment\spaceBgone
    {\addcytoks{##1}}
    {\processtoks{##1}}
    {\addcytoks{##1}}
    {\addcytoks{\hspace{.2pt plus .2pt minus .8pt}}}%
\end{exampleC}

\begin{exampleA}[lefthand width=6.0cm]{Example of using the \macname{spaceBgone}
  environment}
\spaceBgone
  Here we have a \textit{test} of 
  whether the spaces are removed.  
  We are choosing to use the 
  tokencycle environment.

  We are also testing the use of 
  paragraph breaks in the 
  environment.
\endspaceBgone
\end{exampleA}

\endgroup

\subsubsection{Remapping text}

\begin{minipage}[t]{\textwidth}
\begingroup

\begin{exampleC}[]{The \macname{remaptext} environment with
  supporting macros}
\tokcycleenvironment\remaptext
    {\addcytoks[x]{\tcremap{##1}}}
    {\processtoks{##1}}
    {\addcytoks{##1}}
    {\addcytoks{##1}}
\newcommand*\tcmapto[2]{\expandafter\def\csname tcmapto#1\endcsname{#2}}
\newcommand*\tcremap[1]{\ifcsname tcmapto#1\endcsname
  \csname tcmapto#1\expandafter\endcsname\else\expandafter#1\fi}
\tcmapto am   \tcmapto bf   \tcmapto cz   \tcmapto de   \tcmapto ey
\tcmapto fl   \tcmapto gx   \tcmapto hb   \tcmapto ic   \tcmapto jn
\tcmapto ki   \tcmapto lr   \tcmapto mh   \tcmapto nt   \tcmapto ok
\tcmapto ps   \tcmapto qa   \tcmapto ro   \tcmapto sq   \tcmapto tw
\tcmapto uj   \tcmapto vp   \tcmapto wd   \tcmapto xg   \tcmapto yu
\tcmapto zv
\end{exampleC}

\begin{exampleA}[lefthand width=8.5cm]{Demo of \macname{remaptext}}
\remaptext
What can't we \textit{accomplish} if we try?

Let us be of good spirit and put our minds to it!
\endremaptext
\end{exampleA}

Because \macname{tcremap} is expandable, the original text is totally absent 
  from the processed output:

\altdecytoks

\endgroup
\end{minipage}

\bigskip
\begingroup

This approach can be used, for example, to temporarily remap Latin into Greek in 
  math mode.
In the example given below, only several of the Latin letters are remapped
  for demonstration purposes, but others can be added.
Also, remember that one can use the \verb+|...|+ delimiters to escape back to
  Latin within the environment.

\begin{exampleC}[]{The \macname{greek} environment with
  supporting macros}
\tokcycleenvironment\greek%     NEW TOKCYCLE ENVIRONMENT:
{\addcytoks[4]{\tcremap{##1}}}% HOW TO TREAT CHARACTERS
{\processtoks{##1}}%            HOW TO TREAT GROUP CONTENTS
{\addcytoks{##1}}%              HOW TO TREAT MACROS
{\addcytoks{##1}}%              HOW TO TREAT SPACES
\newcommand*\tcmapto[2]{\expandafter\def\csname tcmapto#1\endcsname{#2}}
\newcommand*\tcremap[1]{\ifcsname tcmapto#1\endcsname
  \csname tcmapto#1\expandafter\endcsname\else\expandafter#1\fi}
\tcmapto a\alpha \tcmapto b\beta \tcmapto e\epsilon 
\tcmapto g\gamma \tcmapto p\pi
\end{exampleC}

\tcmapto a\alpha \tcmapto b\beta \tcmapto e\epsilon 
\tcmapto g\gamma \tcmapto p\pi

\begin{exampleA}[lefthand width=8.5cm]{Demo of \macname{greek}}
\[
  y = 
  \greek a^2b\frac{2e}{2 + p^|p| + g}\endgreek 
  + x
\]
\end{exampleA}

\endgroup

\subsubsection{Creating an ``extended'' \TokCycle{} environment}

\begingroup
The \macname{xtokcycleenvironment} macro extends the capability of
  \macname{tokcycleenvironment} by adding two arguments that correspond,
  respectively, to initialization code and ``close-out'' code that is run 
  after the token cycle is complete (but before it is typeset).
Let's say I wanted an environment that capitalizes instances of the letter
  `\texttt{t}', but I want it to tell me how many
  letter \texttt{t}'s are affected before typesetting the result.
Furthermore, I want it always to set the result in red and add two  
  exclamation points to the end of the environment output.

\begin{exampleC}[]{The \macname{capTive} extended-environment definition}
\newcounter{Tcount}
\xtokcycleenvironment\capTive% ENVIRONMENT NAME
{\tctestifx{t##1}{\stepcounter{Tcount}\addcytoks{T}}{\addcytoks{##1}}}% CHAR. DIRECTIVE
{\processtoks{##1}}% GROUP DIRECTIVE
{\addcytoks{##1}}% MACRO DIRECTIVE
{\addcytoks{##1}}% SPACE DIRECTIVE
{\setcounter{Tcount}{0}\color{red}\tcafterenv{\ Here}}% INITIALIZATION CODE
{\theTcount{} t's capitalized: \addcytoks{!!}}% CLOSE-OUT CODE
\end{exampleC}

\begin{exampleA}[lefthand width=7.9cm]{Demo of \macname{capTive}
  environment}
Before \capTive the cytoks \footnotesize token list\endcapTive After
\end{exampleA}

In the initialization code, the \texttt{Tcount} counter is reset and the color
  of what follows is made red.
It also makes use of the specialized \macname{tcafterenv} macro that can
  \textbf{only be used in \macname{xtokcycle\-environment} definitions}.
This macro indicates code to execute \textit{after} the \texttt{capTive}
  environment scope is exited.
This invocation typesets the word `Here'.
We see that in the output, it occurs at normal size and in black, because
  it is no longer subject to the color and fontsize that was left inside
  the environment.
The \macname{tcafterenv} macro is unique in that it is an appending, rather
  than a defining, macro.
Therefore, multiple invocations of it will append multiple code segments,
  each of which will be executed upon environment exit.
It may be invoked in any of the directives, as well as the initialization and
  close-out code segments.

\medskip
For the close-out code, because it is executed after the token cycle is 
  complete, but before it is typeset, the updated value of \texttt{Tcount}
  is available.
Anything typeset directly in the close-out code will occur before the
  \macname{cytoks} token-list output is typeset. 
Thus, the ``...t's capitalized.'' phrase is typeset before \macname{cytoks}
  itself, even as \macname{theTcount} is accurate.
The \macname{addcytoks} occurring in the close-out code is placed at the
  end of \macname{cytoks} and thus takes on the \macname{footnotesize}
  declaration that is still in force.
\endgroup

\begingroup
\medskip
Next, we consider a \TokCycle{} extended environment that counts words and
  letters.
We try to build some features into the code so that, for example, spaces
  and punctuation do not count as letters.
Further, we try to build the logic so that the following cases would
  count as two words, not one: ``here...now'', ``Case(number)''.

\medskip
We provide two modes of output: one that provides an ending summary, and
  the other that keeps a running count.
As with other \TokCycle{} environments and macros, portions can be
  exempted from the count (for example macro arguments) by using the 
  escape delimiters provided.
An even more elaborate version of this environment can be found at
\texttt{https://tex.stackexchange.com/questions/\allowbreak
  44618/dynamically-count-and-return-number-of-words-in-a-section/587567\#587567},%
\hfil in\-cluding a version that runs
  in Plain \TeX.

\begin{exampleC}[]{The \macname{countem} extended-environment definition
  and supporting macros}
\newcounter{wordcount}
\newcounter{lettercount}
\newif\ifinword
\newif\ifrunningcount
\newcommand\dumpword{%
  \addcytoks[1]{\accumword}%
  \tctestifcon\ifinword{\stepcounter{wordcount}%
    \ifrunningcount\addcytoks[x]{$^{\thewordcount,\thelettercount}$}\fi}{}%
  \inwordfalse\def\accumword{}}
\makeatletter
\newcommand\addletter[1]{%
  \tctestifcatnx A#1{\stepcounter{lettercount}\inwordtrue}{\dumpword}%
  \tc@defx\accumword{\accumword#1}}
\makeatother

\xtokcycleenvironment\countem
  {\addletter{##1}}
  {\processtoks{##1}\dumpword}
  {\dumpword\addcytoks{##1}}
  {\dumpword\addcytoks{##1}}
  {\def\accumword{}\setcounter{wordcount}{0}\setcounter{lettercount}{0}}
  {\dumpword\ifrunningcount\else\tcafterenv{\par(Wordcount=\thewordcount,
    Lettercount=\thelettercount)}\fi}
\end{exampleC}

\begin{exampleA}[lefthand width=5.6cm]{Demo of the two modes of 
  \macname{countem}}
\countem 
This is a test.

But...punctuation does not count.
\endcountem

\bigskip\runningcounttrue
\countem 
This is a test.

But...punctuation does not count.
\endcountem
\end{exampleA}

\endgroup

\subsection{Truncation of input}

\begingroup

\TokCycle{} has several facilities for truncating input, either
  to the end of the current group or to the end of the input stream.
The basic commands are \macname{truncategroup} and \macname{truncatecycle},
  which can be part of the Character, Macro, or Space directives (see the
  package documentation for truncation from the Group directive).

\medskip
These commands may be issued directly or they may be placed as
  one fork of a conditional test.
If the conditional test is the occurrence of a particular token in the
  input stream, special conditional shortcuts have been formulated:
  \macname{truncategroupiftokis} and \macname{truncatecycleiftokis}.
Both of these commands take two arguments: the first is the comparison
  token against which to compare the tokens of the input stream, and the
  second is the directive to follow for tokens that fail the 
  comparison test.
If the input stream token matches the comparitor, the relevant 
  truncation command is executed.

\medskip
The description below shows the truncations to a given input text,
  resulting from several different forms of truncating directives.
In the first case, the token cycle is to be truncated if a space
  is found in the input stream.
Comparing to the input text, we see that the space occurs after the
  word ``until'', and that is indeed where the \TokCycle{} output
  ceases.

\medskip
In the second case, the truncation is limited to the current group,
  rather than the remainder of the input stream.
Again, the space following ``until'' is found, and the words
  ``certain token'' are excised from the input stream until the
  end-of-group is located.
The cycle continues successfully with ``-is'' until the next space
  is found before ``located''.
Since this space is found in the top grouping level of the input,
  the remainder of the input stream is thereafter truncated.

\medskip
In the third case, the cycle is to be truncated in the event the
  letter `a' is found in the input stream.
Examining the input text, the first `a' is in the word ``certain'' and
  so the input is truncated after the string ``cert'' is digested.

\medskip
The final case, calls for group truncation if an `a' is found in the
  input stream.
As before, the first `a' is found after ``cert''.
However, in the group case, only the remaining group content, consisting
  of ``ain token'', is discarded.
At group end, the cycle successfully resumes until the `a' in
  ``located'' is reached.
Thus, ``-is loc'' is also added to the output stream.

\def\thetext{Continue-\textit{until certain token}-is located.}

\newcommand\rundemowith[1]{%
  {\footnotesize\ttfamily\altdetokenize{#1}}: 
  \resettokcycle#1\expandafter\tokencyclexpress\thetext\endtokencyclexpress
}

\begin{exampleB}[text only, righthand width=0.01cm,  colback=white]%
{Example: Effects of various truncation directives}
{\footnotesize\ttfamily Input text}: \expandafter\altdetokenize\expandafter
 {\thetext}

\rundemowith{\Spacedirective{\truncatecycle}}

\rundemowith{\Spacedirective{\truncategroup}}

\rundemowith{\Characterdirective{\truncatecycleiftokis{a}{\addcytoks{#1}}}}

\rundemowith{\Characterdirective{\truncategroupiftokis{a}{\addcytoks{#1}}}}
\end{exampleB}

Note how the macro function, in this case \macname{textit}, is not
  disrupted by the truncation.
Even as tokens are truncated from the input stream, group closures
  are retained so that the final output is group-balanced.
For example, a detokenization of the final case reveals this to be
  the case:

\altdecytoks

\endgroup

\subsection{Look-ahead features}

The whole concept of the \TokCycle{} package is to examine the input stream
  one token at a time and use the directives to process the tokens.
Occasionally, however, there are tasks that involve several adjacent tokens.
In the example of section~\ref{s:cap}, for instance, in order to capitalize
  words, each space token triggers an action on the character that follows.
To accomplish this without any look-ahead features, the Space directive sets
  a flag, \verb|\def\capnext{T}|, in order to communicate with a the Character
  directive about a subsequent token.
That is a perfectly valid approach to communicate conditional action.

\medskip
However, \TokCycle{} also provides look-ahead features, to avoid the necessity
  of communicating with future tokens in the cycle by way of flag settings.
These tools allow a directive to directly ``peek'' ahead at the input stream 
  (without disturbing it) and, if desired, push and pop tokens to and from 
  the input stream.
The package manual should be consulted for a full list of macros provided to
  facilitate look-ahead capability.
But here are some examples to look at.

\begingroup

\subsubsection{Count in advance that which follows}

Specify the point values for questions and let \TokCycle{} perform the cumulative 
  tallies in advance, using a single-pass compilation.

\begin{exampleC}[]{The \texttt{pointtracker} environment to count point values
  in advance}
\newcounter{pointcount}
\newcommand\addtopoints[1]{(\textit{#1 point}%
  \ifnum#1=1\relax\else\textit{s}\fi)}
\NewEnviron{pointtracker}[2][points]{%
  \par\bigskip\resettokcycle
  \setcounter{pointcount}{0}%
  \Macrodirective{\addcytoks{##1}\tctestifx{\addtopoints##1}{\sumpoints}{}}%
  \def\tmp{\tokencyclexpress{\large\bfseries#2: \thepointcount\ #1}}%
  \expandafter\tmp\BODY\endtokencyclexpress
}
\def\sumpoints{\tcpop\Q\addtocounter{pointcount}{\Q}\tcpushgroup{\Q}}
\end{exampleC}

\begin{exampleA}[lefthand width=6.2cm]{Demo of the pointtracker environment}
\begin{pointtracker}[total points]{\Large Science Test}
\begin{pointtracker}{Advanced Geology}
  \begin{itemize}
    \item Count the fingers on your left hand. Are there more than 9?
          \addtopoints{1}
    \item Draw a rectangle with five edges. \addtopoints{3}
  \end{itemize}
\end{pointtracker}
\begin{pointtracker}{Meteorology}
  \begin{itemize}
    \item How many borgs does it take to brew a Danish beer?
          \addtopoints{2}
    \item What is the meaning of life? \addtopoints{4}
  \end{itemize}
\end{pointtracker}
\end{pointtracker}
\end{exampleA}

Note that this example has several neat features.
The points for Geology, Meteorology, and the Test total are not specified,
  but calculated.
They are calculated based on content that appears later in the environment.
Traditionally, multiple compilations would be required with external data
  written to the aux file, but that does not occur here---there is only
  a single compilation.
Finally, becaue we are nesting the \TokCycle{} part of \texttt{pointtracker} 
  inside of a \macname{NewEnviron}, we see that the \texttt{pointtracker} 
  environment can be nested, without adverse effect.

\endgroup

\subsubsection{Modify the arguments of every instance of a particular macro}

\begingroup

This example, through the use of the \macname{scalerule} macro, shows how
  the \macname{rule} arguments, including the optional argument, can be
  popped off the input stream, adjusted, and placed back in the stream.

\begin{exampleC}[]{The \macname{scalerule} macro to scale all
  \macname{rule} arguments}
\newcommand\scalerule[1]{%
  \tcpeek\zA
  \ifx[\zA\tcpopuntil]\opt\fi% IF PRESENT, POP OPTIONAL ARG
  \tcpop\ArgA% POP ARG1
  \tcpop\ArgB% POP ARG2
  \tcpushgroup[x]{#1\dimexpr\ArgB}% PUSH BACK IN REVERSE (LIFO) FASHION
  \tcpushgroup[x]{#1\dimexpr\ArgA}
  \ifx[\zA\tcpush[x]{\expandafter\scaleopt\opt{#1}}\fi
}
\def\scaleopt[#1]#2{[#2\dimexpr#1]}
\end{exampleC}

\begin{exampleA}[lefthand width=9.2cm]{Scale every \macname{rule} argument}
\resettokcycle
\settcEscapechar{!}% SO AS NOT TO INTERFERE WITH `|' TOKS IN tabular
\Macrodirective{\addcytoks{#1}\ifx\rule#1\scalerule{2}\fi}
\tokencyclexpress 
The rules appearing in the following input stream are literally
!\rule[-2pt]{1.5ex}{1.5ex}! and !\rule{2ex}{3pt}!:

My environment can include all kinds of rules 
  \rule[-2pt]{1.5ex}{1.5ex} and other macros, such as \today{} and
\begin{tabular}{c|c}
23 & 454\\\hline
x & y
\end{tabular}
but each rule \rule{2ex}{3pt} is grown by a factor of two.
\endtokencyclexpress
\end{exampleA}
\settcEscapechar{|}

\endgroup


\subsubsection{Protect arguments of specified macro from Character
   directive modification}

\begingroup
Tokcycle provides the escape character $|$ to delimit tokens to be protected
  from processing by \TokCycle{} directives.  
But that requires the input stream to be adjusted to include these delimiters.  
Here's an alternative, not requiring input stream adjustment.  
The Macro directive protects all \macname{rule} arguments against contamination 
  by the Character directive.

\medskip
When a \macname{rule} is encountered, \macname{protectruleargs} is called
  to pop the rule arguments from the input stream and place them directly
  in the \macname{cytoks} token list, out of reach from the Character directive.


\begin{exampleC}[]{The \macname{protectruleargs} macro to prevent Character directive
  contamination of arguments}
\newcommand\protectruleargs[1]{\ifx\rule#1%
  \tcpeek\zA
  \ifx[\zA\tcpopuntil]\opt
  \addcytoks[1]{\opt}\fi% IF OPTIONAL ARG PRESENT, POP AND SAVE TO \cytoks
  \tcpopliteral\ArgA% MUST POP ARG 1 WITH BRACES
  \addcytoks[1]{\ArgA}%
  \tcpopliteral\ArgB%  MUST POP ARG 2 WITH BRACES
  \addcytoks[1]{\ArgB}%
  \fi
}
\end{exampleC}

Here, every character is typeset with a slash suffix.
If this action were to be imposed to \macname{rule} argument characters, 
  it would destroy their integrity.
Fortunately, when the Macro directive detects a \macname{rule}, it can
  take evasive action.

\begin{exampleA}[lefthand width=9.1cm]{Protect every \macname{rule} argument
  from Character directive contamination}
\resettokcycle
\Characterdirective{\addcytoks{#1\textup{/}\allowbreak}}
\Macrodirective{\addcytoks{#1}\protectruleargs{#1}}
\tokencyclexpress 
My \textit{environment} modifies each character token, but rule
  \rule[-4pt]{1.5ex}{1.5ex} arguments \rule{2ex}{3pt} are protected.
\endtokencyclexpress
\end{exampleA}
\endgroup


\begingroup

\subsubsection{Find a string of character tokens}

Earlier in this manuscript, in section~\ref{s:searchA}, a token cycle
  was developed to search a token stream for a string match.
Here, we do something similar, except we use the new ``look ahead'' features
  of \TokCycle{} to achieve it.
In this case, however, the search string cannot cross space or group
  boundaries.
The \macname{matchnextchar} macro demonstrates a use of \macname{tcpopappto},
  which is one of the newly introduced \TokCycle{} commands; instead of 
  popping an argument from the input stream \textit{into} a macro, it pops it 
  and \textit{appends} it to a macro.

\begin{exampleC}[]{The \macname{findstring} macro to perform a look{-}ahead string
  search}
\newcommand\findstring[4]{% {CURRENT TOK}{MATCH STRING}{SUCCESS OP}{FAIL CMDS}
  \foundstringfalse% DEFAULT CONDITION
  \def\poptoks{}% INITIALIZATION. IF MATCH FAILS, MUST TO RESTORE POPPED TOKENS
  \expandafter\matchnextchar\ifx#1#2\relax\relax\fi\empty\relax
  \iffoundstring\addcytoks{#3{#2}}\else\tcpush{\poptoks}#4\fi
}
\def\matchnextchar#1#2\relax{\tctestifx{#1\empty}{}{% NO MATCH FROM 1ST TOKEN
  \tctestifx{\relax#1}{%
    \foundstringtrue% NOTHING LEFT TO COMPARE; MATCH FOUND
  }{%
    \tcpeek\Q% WITHOUT POPPING...
    \tctestifx{\Q\bgroup}{}{% PEEK FOR GROUPS OR...
      \tctestifx{\Q\tcsptoken}{}{% SPACES THAT INDICATE MATCH FAILURE
        \tcpopappto\poptoks% POP TOKEN AND APPEND TO \poptoks
        \expandafter\tctestifx\expandafter{\Q#1}{%
          \matchnextchar#2\relax% STILL MATCHING; KEEP GOING
        }{}%
      }%
    }%
  }%
}}
\end{exampleC}

\begin{exampleA}[lefthand width=8cm]{Search for the string ``red''}
\resettokcycle
\Characterdirective{\findstring{#1}{red}%
  {\textcolor{purple}}{\addcytoks{#1}}}
\tokencyclexpress 
Can I \textit{find red in the text}, even in the 
  MIDredDLE of words and groups?
\endtokencyclexpress
\end{exampleA}

\endgroup


\subsubsection{Eliminate \textit{prior} spaces and pars before a particular
  macro}

The goal here is to eliminate spaces and paragraphs that occur 
  \textit{prior} to the occurrence of the macro \macname{foo}, which 
  sets a \macname{bullet}.
Looking backwards is not part of the \TeX{} approach.
Nonetheless, the problem can, with a token cycle, be turned on its head,
  such that all occurrences of spaces and \macname{par} can be made 
  to look for a future instance of \macname{foo}.

\medskip
Here, if a space or \macname{par} is detected, \macname{foocheck} is called.
  It peeks at the token that follows the space or \macname{par}.
If the peeked argument is a \macname{par} or \macname{foo} itself, it discards 
  the current space or \macname{par}.

\begingroup

\begin{exampleC}[]{The \macname{dofoo} environment to remove prior spaces and
  paragraphs before \macname{foo}}
\newcommand\foo{$\bullet$}
\newcommand\foocheck[1]{\tcpeek\z\ifx\foo\z\else
  \ifx\par\z\else\addcytoks{#1}\fi\fi}
\tokcycleenvironment\dofoo
  {\addcytoks{##1}}
  {\processtoks{##1}}
  {\ifx\par##1\foocheck{##1}\else\addcytoks{##1}\fi}
  {\foocheck{##1}}
\end{exampleC}

\begin{exampleA}[lefthand width=7cm]{Remove spaces and paragraphs before 
  \macname{foo}}
\dofoo
Lorem ipsum dolor sit amet. (No foo)

Lorem ipsum dolor sit amet. \foo 

Lorem ipsum dolor sit amet.\foo 

Lorem ipsum dolor sit amet.
\foo 

Lorem ipsum dolor sit amet.

\foo 
\enddofoo
\end{exampleA}
\endgroup


\subsubsection{Replace := with \macname{coloneqq} (\texttt{mathtools} 
  package required)}

In most cases, creating a macro to signify a composite symbol makes the most 
  sense.
However, sometimes you don't realize that until you've typed in a lot of code
  that fails to use such a macro.
In such a situation, \TokCycle{} can help.

\medskip
In the \texttt{mathtools} package, there is a symbol, \macname{coloneqq},
  a colon followed by an equal sign, in which the colon has been
  vertically adjusted to be symmetric with respect to the \texttt{=} sign.
The adjustment is slight, but noticeable.
A token cycle can be set up to look for instances of the \texttt{:} character,
  peek ahead to see if it is followed by an \texttt{=} character and, if so,
  replace the pair with \macname{coloneqq}.
However, the process is further complicated, if one is a user of
\macname{usepackage[french]\{babel\}}, where the \texttt{:} character is is made
  an active character.

\medskip
Therefore, in this case, not only does \texttt{:} need to be located by
  the Character directive (in the normal case), but it also need be searched
  for by the Macro directive, in the event that
  \macname{usepackage[french]\{babel\}} is being employed.
In the example below, there are two such colons that satisfy the criterion for 
  replacement.

\begingroup

\begin{exampleC}[]{The \macname{coleqchek} macro and the \macname{subcoloneqq}
  environment}
\newcommand\coleqchek[1]{\tcpeek\z
  \ifx=\z\tcpop\z\addcytoks{\coloneqq}\else\addcytoks{#1}\fi}
\tokcycleenvironment\subcoloneqq
{\tctestifx{:##1}{\coleqchek{##1}}{\addcytoks{##1}}}% <- IF : A CHARACTER
{\processtoks{##1}}
{\tctestifcon{\if\detokenize{:}\detokenize{##1}}% <- IF : AN ACTIVE MACRO
  {\coleqchek{##1}}{\addcytoks{##1}}}
{\addcytoks{##1}}
\end{exampleC}

\begin{exampleA}[lefthand width=6cm]{replace {:=} with \macname{coloneqq}} 
\subcoloneqq
\LARGE Compare: $::=$

$a := b$ vs 
  $a \ordinarycolon= b$ vs 
  $a:b$.
\endsubcoloneqq
\end{exampleA}

\endgroup

\let\svtilde~
\let~\\
\section{Advanced topics: implicit and active tokens, catcode~changes}
\let~\svtilde

\subsection{Trap active characters (catcode 13)}

%\begin{minipage}[t]{\textwidth}
\begingroup
Active characters in the \TokCycle{} input stream are processed in
  their original form.
Their active substitutions arising from \macname{def}s 
  only occur \textit{afterwards}, when
  the \TokCycle{} output is typeset.
They may be identified with the \macname{ifactivetok} test.
If \macname{let} to a character, they may be identified in the Character
  directive;
If \macname{let} to a control sequence or defined via \macname{def},
  they may be identified in the Macro directive.
For information on how to process active spaces, please refer to 
  section~\ref{s:spc}.
\let\svt T
\Characterdirective{\tctestifcon\ifactivetok
  {\addcytoks{\fbox{#1-chr}}}{\addcytoks{#1}}}
\Macrodirective{\tctestifcon\ifactivetok
  {\addcytoks{\fbox{#1-mac}}}{\addcytoks{#1}}}

\begin{exampleA}[lefthand width=7.8cm]{Processing active characters}
\resettokcycle
\tokencyclexpress 
1. This is a test!!\endtokencyclexpress

2. \catcode`!=\active
\def !{?}%
\tokencyclexpress 
This is a test!!\endtokencyclexpress

3. 
\Characterdirective{\tctestifcon\ifactivetok
 {\addcytoks{\fbox{#1-chr}}}{\addcytoks{#1}}}%
\Macrodirective{\tctestifcon\ifactivetok
 {\addcytoks{\fbox{#1-mac}}}{\addcytoks{#1}}}%
\tokencyclexpress 
This is a test!!\endtokencyclexpress

4. \catcode`T=\active
\let T+%
\tokencyclexpress 
This is a test!!\endtokencyclexpress

5. \detokenize\expandafter{\the\cytoks}
\end{exampleA}

%%%

\ddbend If the input stream is pre-\textit{expanded}, any active 
  substitutions that are expandable (i.e., those involving \macname{def} 
  as well as those \macname{let} to something expandable) 
  are made before reaching \TokCycle{} processing.  
\svt hey are, thus, no longer detected as active, unless 
  \macname{noexpand} is applied before the pre-expansion.
In this example, the `\texttt{!}' that is \textit{not} subject to
  a \macname{noexpand} is converted to a `\texttt{?}' prior to 
  reaching \TokCycle{} processing (and thus, not detected as 
  \macname{active}).  
However, the `\texttt{T}' is not pre-converted to a `\texttt{+}', 
  because it is implicit, and not a definition:

\catcode`!=\active
\def !{?}
\catcode`T=\active
\let T+
\begin{exampleA}[lefthand width=7.0cm]{Expanded input stream acts 
  upon active \macname{def}ed characters unless \macname{noexpand} is applied}
\expandedtokcyclexpress{This is a test!\noexpand!}
\the\cytoks\par
\detokenize\expandafter{\the\cytoks}
\end{exampleA}

\begingroup
\catcode`T=11
\catcode`!=12
However, pre-tokenization does not suffer this behavior.  
The first `\texttt{!}' is tokenized as active during
  its absorption into \macname{tmp}, as shown in the next example:
\endgroup
\begin{exampleA}[lefthand width=7.8cm]{Pre-tokenized input stream
  does not affect active characters}
\def\tmp{This is a test!!}
\expandafter\tokcyclexpress\expandafter{\tmp}
\the\cytoks\par
\detokenize\expandafter{\the\cytoks}
\end{exampleA}

%%%
\endgroup
%\end{minipage}

\begingroup
\ddbend One aspect of \TeX{} to remember is that catcodes
  are assigned at tokenization; however, for active characters,
  the substitution assignment is evaluated only upon execution.
So, if a cat-13 token is placed into a \macname{def}, it will
  remain active even if the catcode of that character code is
  later changed.
But if the cat-13 active definition is changed prior to the 
  execution of the \macname{def}'ed token, the revised
  token assignment will apply.

\medskip
The following example demonstrates this concept, while showing,
  without changing the input in any way, that \TokCycle{} 
  can properly digest active and implicit grouping (cat-1,2) characters:

\begin{exampleA}[lefthand width=8cm]{Active and implicit grouping
  tokens digestible by \TokCycle}
\catcode`Y=13
\catcode`Z=13
\let Y{
\let Z}
\let\Y{
\let\Z}
\def\tmp{\textit YabcZ de\Y\itshape f\Zg}%

\def Y{\bgroup[NEW]}% APPLIES AT EXECUTION
\catcode`Y=11% DOES NOT AFFECT Y IN \tmp

\expandafter\tokcyclexpress\expandafter{\tmp}
\the\cytoks

\detokenize\expandafter{\the\cytoks}
\end{exampleA}
\endgroup

\subsection{Digest/discern Unicode characters in pdflatex\label{s:unicode}}

When using the lualatex or xelatex engines, the presence of Unicode characters
  poses no problem.
In the context of a token cycle, each such character is digested and passed as 
  an individual token to the Character directive.

\medskip
In pdflatex, however, which digests input one byte at a time, Unicode characters
  are represented in UTF-8 encoding as multi-byte sequences of two to four bytes 
  in length.
These tokens are made active and the leading bits of the first byte can be used
  to decipher the length of the Unicode character encoding.
Since tokens in pdflatex are composed of single bytes, a token cycle in the
  context of pdflatex only gets to digest one byte at a time of a given Unicode
  character.
The key to digesting and decoding Unicode characters therefore, is to look 
  for active tokens coming into the Macro directive.
If such a byte is found, its slot should be determined.
Slots 192--223 indicate a 2-byte Unicode character and so one additional byte
  needs to be absorbed to compose the full Unicode character.
If the first byte resides in slots 224--239, a 3-byte encoding is called for,
  so that two additional bytes need to be absorbed to reconstitute the full
  character.
Finally, if the slot of the active byte exceeds 239, a 4-byte encoding is called
  for and three additional bytes must be absorbed to reformulate the Unicode 
  character.
The following code shows exactly how this is done using an example.

\begin{exampleC}[]{Setting up a token cycle to digest/discern Unicode characters
  in pdflatex}
% PREAMBLE SETUP FOR NEEDED UNICODE TOKENS
\DeclareUnicodeCharacter{1D60}{$\varphi$}
\DeclareUnicodeCharacter{1D131}{$\sharp$}
%
\newif\ifUnicode
\resettokcycle
\Macrodirective{%
  \ifactivetok\digestactivechar{#1}%
    \ifUnicode\addcytoks[1]{\expandafter\makered\expandafter{\tcactivechar}}%
      \else\addcytoks{#1}\fi
  \else
    \addcytoks{#1}%
  \fi}
\newcommand\tcdigestbyte{\tcpopappto\tcactivechar}
\newcommand\digestactivechar[1]{\Unicodefalse
  \def\tcactivechar{#1}%
  \ifnum`#1>239 \Unicodetrue\tcdigestbyte\tcdigestbyte\tcdigestbyte\else
  \ifnum`#1>223 \Unicodetrue\tcdigestbyte\tcdigestbyte\else
  \ifnum`#1>191 \Unicodetrue\tcdigestbyte\fi\fi\fi}
\newcommand\makered{\textcolor{red}}
\end{exampleC}

\begingroup
\begin{exampleD}[]{Executing a pdflatex token cycle able to digest/discern 
  Unicode characters}
\small
\newif\ifUnicode
\resettokcycle
\Macrodirective{%
  \ifactivetok\digestactivechar{#1}%
    \ifUnicode\addcytoks[1]{\expandafter\makered\expandafter{\tcactivechar}}%
      \else\addcytoks{#1}\fi
  \else
    \addcytoks{#1}%
  \fi}
\newcommand\tcdigestbyte{\tcpopappto\tcactivechar}
\newcommand\digestactivechar[1]{\Unicodefalse
  \def\tcactivechar{#1}%
  \ifnum`#1>239 \Unicodetrue\tcdigestbyte\tcdigestbyte\tcdigestbyte\else
  \ifnum`#1>223 \Unicodetrue\tcdigestbyte\tcdigestbyte\else
  \ifnum`#1>191 \Unicodetrue\tcdigestbyte\fi\fi\fi}
\newcommand\makered{\textcolor{red}}
\begingroup
\Macrodirective{%
  \ifactivetok\digestactivechar{#1}%
    \ifUnicode\addcytoks{\begingroup\fontencoding{T2A}\selectfont}%
       \addcytoks[1]{\expandafter{\tcactivechar}\endgroup}
    \else\ifx~#1\addcytoks{\string#1}\else\addcytoks{#1\mbox{}}\fi\fi
  \else
    \addcytoks{\string#1}
  \fi}
\obeylines\obeyspaces
\ttfamily
\string\tokencyclexpress \tokencyclexpress On \today, we are running input through a token cycle 
that highlights Unicode characters in red:

Testing an active tilde: (~) and a Euro sign: €.

Accented Latin Characters:  
á, é, ó, ú, ü, ñ, ç, à, è, ò, ù, â, ê, ô, û, ã, 
õ, ä, ö, ü, ß, œ.

Cyrillic Characters:  
А, Б, В, Г, Д, Е, Ё, Ж, З, И, Й, К, Л, М, Н, О, П, 
Р, С, Т, У, Ф, Х, Ц, Ч, Ш, Щ, Ъ, Ы, Ь, Э, Ю, Я.

Пример текста на кириллице: Здравствуйте, Latin, как дела?

Higher level (3, 4-byte) Unicode (unsupported by font):
ᵠ, and 𝄱
\endtokencyclexpress\string\endtokencyclexpress\endgroup

\vspace{-7pt}\hrulefill
\fontencoding{T2A}\selectfont
%\includegraphics{UNICODE DECODE}

\tokencyclexpress On \today, we are running input through a token cycle 
that highlights Unicode characters in red:

Testing an active tilde: (~) and a Euro sign: €.

Accented Latin Characters:  
á, é, ó, ú, ü, ñ, ç, à, è, ò, ù, â, ê, ô, û, ã, 
õ, ä, ö, ü, ß, œ.

Cyrillic Characters:  
А, Б, В, Г, Д, Е, Ё, Ж, З, И, Й, К, Л, М, Н, О, П, 
Р, С, Т, У, Ф, Х, Ц, Ч, Ш, Щ, Ъ, Ы, Ь, Э, Ю, Я.

Пример текста на кириллице: Здравствуйте, Latin, как дела?

Higher level (3, 4-byte) Unicode (unsupported by font):
ᵠ, and 𝄱
\endtokencyclexpress
\end{exampleD}

\endgroup

\subsection{Trap catcode 6 (explicit \& implicit) tokens}

\begingroup

\let\myhash#

\medskip

Typically, cat-6 tokens (like \texttt{\#}) are used to designate the
  following digit (1-9) as a parameter.
Since they are unlikely to be used in that capacity inside a 
  \TokCycle{} input stream, the package behavior is to convert them
  into something cat-12 and set the if-condition \macname{catSIXtrue}.
In this manner, \macname{ifcatSIX} can be used inside the
  Character directive to convert cat-6 tokens into something of
  the user's choosing.

\medskip
As to this cat-12 conversion, explicit cat-6 characters are converted
  into the same character with cat-12.  
On the other hand, implicit cat-6 control sequences (e.g., \verb|\let\myhash#|) 
  are converted into a fixed-name macro, \macname{implicitsixtok}, 
  whose cat-12 substitution text is a \macname{string} of the original
  implicit-macro name.

\begingroup
\resettokcycle
\Characterdirective{\ifcatSIX
  \addcytoks{\fbox{#1}}
  \else\addcytoks{#1}\fi}

%\tokencyclexpress This# isQ \textit{a Q# test\myhash}!\endtokencyclexpress

\begin{exampleA}[lefthand width=6.5cm]{Treatment of cat-6 tokens}
\resettokcycle
\Characterdirective{\ifcatSIX
  \addcytoks{\fbox{#1}}
  \else\addcytoks{#1}\fi}
\let\myhash#
\tokcyclexpress{This# isQ 
  \textit{a Q# test\myhash}!}
\the\cytoks\bigskip\par
\detokenize\expandafter{\the\cytoks}
\end{exampleA}

%\tokcyclexpress{This# isQ \textit{a Q# t\,e\, s\,t\myhash}!}\the\cytoks{}
%with 1-character macros

%%%
%\expandedtokcyclexpress{This# isQ \noexpand\textit{a Q# test\myhash}!}\the\cytoks
%{} PRE-EXPANDED
%%%


%\tokencyclexpress This# isQ \textit{a Q# test}!\endtokencyclexpress

%\Characterdirective{\ifcatSIX\addcytoks{\fbox{#1}}\else\addcytoks{#1}\fi}

\begin{exampleA}[lefthand width=6.5cm]{Multiple explicit cat-6 tokens are not 
  a problem}
\catcode`Q=6
\tokcyclexpress{This# isQ 
  \textit{a Q# test\myhash}!}
\the\cytoks
\end{exampleA}

\catcode`Q=11
\hrulefill
\endgroup

\ddbend For what is, perhaps, a rare situation, one can even process input 
  streams that contain cat-6 macro parameters.
A package macro, \macname{whennotprocessingparameter\#1\{<}%
  \textit{directive when not a parameter}\verb|>}|, can be
  used inside of the Character directive to intercept parameters.
In this example, a macro is defined and then executed, subject to
  token replacements brought about by the expandable Character directive.

\begin{exampleA}[lefthand width=7cm]{Preserving parameters (e.g.
  \texttt{\#1, \#2}) in the \TokCycle{} input stream}
\Characterdirective{%
  \whennotprocessingparameter#1{%
    \addcytoks[x]{\vowelcap{#1}}}}
\tokcyclexpress{%
  \def\zQ#1#2{[one:#1](two:#2)}
  This is a \zQ big test.

  \renewcommand\zQ[2]{\ifx t#1[#1]\fi(#2)}
  This is a \zQ test.}
\the\cytoks
\end{exampleA}

\altdecytoks

\endgroup

\subsection{Trap implicit tokens in general}

\begingroup

Implicit control sequences (assigned via \macname{let} to characters) 
  were already mentioned in the context of cat-6.
However, implicit control sequences can be of any valid catcode (except
  for cat-0, which we instead call macros or primitives).
The condition \macname{ifimplicittok} is used to flag such
  tokens for special processing, as well as active tokens that
  are \macname{let} to anything unexpandable.

In the next example, implicit, cat-6 and implicit-cat-6 tokens may
  all be differentiated, shown here with a multiplicity of 
  \macname{fbox}es.

\fboxsep=1.5pt

\begin{exampleA}[lefthand width=8cm]{Implicit\ensuremath{{}={}}%
  single box\char44 \ cat-6\ensuremath{{}={}}double box\char44 \ %
  implicit-cat-6\ensuremath{{}={}}triple box}
\catcode`Q=\active \let QN
\let\littlet=t
\let\littlel=l
\let\svhash#
\Characterdirective{\ifimplicittok
  \ifcatSIX\addcytoks{\fbox{\fbox{\fbox{#1}}}}%
  \else\addcytoks{\fbox{#1}}\fi\else\ifcatSIX
  \addcytoks{\fbox{\fbox{#1}}}\else
  \addcytoks{#1}\fi\fi}

\tokencyclexpress We wi\littlel\littlel# 
  \textit{ make a \littlet est #} \littlet

This \textit{is a \textbf{big}} \littlet est.

Qext pa#agraph ending with implicit cat six 
  \svhash.\endtokencyclexpress
\end{exampleA}

In the following example, we use both control sequences and active characters
 in \macname{def} and \macname{let} capacities, to demonstrate how 
  \TokCycle{} digests things.
Implicit tokens (tokens \macname{let} to characters) are shown in a box,
  with both the token name and the implicit value (note that tokens 
  \macname{let} to macros and primitives are not considered implicit).
Active tokens processed through the character directive are followed with
  a \dag, whereas those processed through the macro directive are followed
  with a \ddag.


\begin{exampleA}[lefthand width=7.5cm]{Non-active vs{.} active \macname{def} 
  \& \macname{let}}
\Characterdirective{\ifimplicittok
  \addcytoks{\fbox{\detokenize{#1}:#1}}%
  \else\addcytoks{#1}\fi\ifactivetok
  \addcytoks{\rlap{\dag}}\fi\addcytoks{~\,}}
\Macrodirective{\ifimplicittok
  \addcytoks{\fbox{\detokenize{#1}}}%
  \else\addcytoks{#1}\fi\ifactivetok
  \addcytoks{\rlap{\ddag}}\fi
  \ifx\par#1\else\addcytoks{~\,}\fi}

\def\A{a}
\let\B i
\let\C\today
\let\D\relax
\def\E{\relax}
\catcode`V=13 \def V{a}
\catcode`W=13 \let Ww
\catcode`X=13 \let X\today
\catcode`Y=13 \let Y\relax
\catcode`Z=13 \def Z{\relax}
\tokcyclexpress{\A\B\C\D\E ab\par VWXYZab}
\the\cytoks
\end{exampleA}


\ddbend If the input stream is subject to pre-expansion, one
  will require \macname{noexpand} for macros where no pre-expansion
  is desired.\medskip

\ddbend If the input stream is provided pre-tokenized via 
  \macname{def}, \TeX{} convention requires cat-6 tokens to appear 
  in the input stream as duplicate, e.g. \texttt{\#\#}.


\subsection{Using the \TokCycle{} traps to understand a token's nature}

With the use of all the \TokCycle{} traps, one can do a great deal to 
  understand the nature of the more arcane tokens found in an input stream.
We already saw in section \ref{s:unicode} how the \macname{ifactivetok}
  trap can be used to decipher multi-byte Unicode tokens in pdflatex.
In the example below, we define various tokens outside of \TokCycle{}, and then
  pass them, successively, to a token cycle to see what can be discerned about
  their nature and if the result matches what we know externally about how each 
  token was created.

\medskip
First, we define the \TokCycle{} macro \macname{identAI} that is used to test
  the token which is passed as the argument.
Traps employed include \macname{ifactivetok}, \macname{ifimplicittok},
  \macname{ifactivetokunexpandable}, and \macname{ifcatSIX}.

\begin{exampleC}[]{Setting up a token cycle to discern the characteristics of
  a token}
\newcommand\identAI[1]{\begingroup\color{red}
  \tokcycle
  {\findAI{Character}{##1}}
  {\processtoks{##1}}
  {\findAI{Macro}{##1}}
  {\findAI{Space}{##1}}
  {#1}\endgroup\par}
\newcommand\findAI[2]{%
  \ifactivetok
    \ifimplicittok\showtok{#1}{#2}{active and implicit}%
    \else\showtok{#1}{#2}{active}\fi
  \else
    \ifimplicittok\showtok{#1}{#2}{implicit}\else
    \showtok{#1}{#2}{conventional}\fi
  \fi}
\newcommand\showtok[3]{
  \ifcatSIX
    #1 \expandafter\string#2 is #3, of catcode-6%
  \else
    #1 \string#2 is #3,
    \ifimplicittok let to ``#2''%
    \else
      \ifactivetokunexpandable but unexpandable%
      \else replaces with ``\expandafter\string#2''\fi
    \fi%
  \fi.}
\def\lettok#1#2{\let#1= #2\empty}
\end{exampleC}

Once the above macros are set up, we define the active tilde token (\texttt{\string~})
  in a variety of ways and pass it, successsively, to \macname{identAI}.
Then, we define the macro \macname{z} in the same variety of ways and perform the 
  tests on successive incarnations of \macname{z}.
Finally, we pass a catcode-6 \string# to \macname{identAI} just to see how it
  reacts.

\medskip
Note that the \macname{ifactivetokunexpandable} trap only applies to active tokens.
Therefore, for non-active tokens that are likewise unexpandable, such as when 
  \macname{z} is let to \macname{relax}, the \macname{identAI} macro instead 
  indicates that the analyzed  token (\macname{z}) and its replacement code 
  are identical.  
This, of course, is another way to say ``unexpandable''.

\medskip
In the output below, the code is shown at the top, and in the output shown at the 
  bottom, the setup external to \macname{identAI} is shown in black, while the 
  output of the \macname{identAI} token cycle is shown in red.
The first word of the \macname{identAI} output, either ``Character'', ``Macro'',
  or ``Space'', indicates the particular \TokCycle{} directive to which the 
  token was delivered for examination.
As we can see, the token cycle, when presented with a wide variety of token types,
  including combinations of active, implicit, and unexpandable, is able to 
  discern the conditions under which the token was created.


\begin{exampleD}[]{Discerning the characteristics of unknown tokens (token cycle 
  output in red)}
\small
\newcommand\identAI[1]{\begingroup\color{red}
  \tokcycle
  {\findAI{Character}{##1}}
  {\processtoks{##1}}
  {\findAI{Macro}{##1}}
  {\findAI{Space}{##1}}
  {#1}\endgroup\par}
\newcommand\findAI[2]{%
  \ifactivetok
    \ifimplicittok\showtok{#1}{#2}{active and implicit}%
    \else\showtok{#1}{#2}{active}\fi
  \else
    \ifimplicittok\showtok{#1}{#2}{implicit}\else
    \showtok{#1}{#2}{conventional}\fi
  \fi}
\newcommand\showtok[3]{
  \ifcatSIX
    #1 \expandafter\string#2 is #3, of catcode-6%
  \else
    #1 \string#2 is #3,
    \ifimplicittok let to ``#2''%
    \else
      \ifactivetokunexpandable but unexpandable%
      \else replaces with ``\expandafter\string#2''\fi
    \fi%
  \fi.}
\def\lettok#1#2{\let#1= #2\empty}
\begin{verbatim}
\def\SayFoo{Foo!}
\lettok~{Q}\string~ let to Q:                       \identAI{~}
\def~{Q}\string~ def'ed to Q:                       \identAI{~}
\lettok~{\relax}\string~ let to \string\relax:      \identAI{~}
\def~{\relax}\string~ def'ed to \string\relax:      \identAI{~}
\lettok~{\SayFoo}\string~ let to \string\SayFoo:    \identAI{~}
\def~{\SayFoo}\string~ def'ed to \string\SayFoo:    \identAI{~}
\lettok~{ }\string~ let to space tok:               \identAI{~}
\def~{ }\string~ def'ed to space tok:               \identAI{~}
\lettok~{#}\string~\ let to \string#:               \identAI{~}
\lettok\z{Q}\string\z\ let to Q:                    \identAI{\z}
\def\z{Q}\string\z\ def'ed to Q:                    \identAI{\z}
\lettok\z{\relax}\string\z\ let to \string\relax:   \identAI{\z}
\def\z{\relax}\string\z\ def'ed to \string\relax:   \identAI{\z}
\lettok\z{\SayFoo}\string\z\ let to \string\SayFoo: \identAI{\z}
\def\z{\SayFoo}\string\z\ def'ed to \string\SayFoo: \identAI{\z}
\lettok\z{ }\string\z\ let to space tok:            \identAI{\z}
\def\z{ }\string\z\ def'ed to space tok:            \identAI{\z}
\lettok\z{#}\string\z\ let to \string#:             \identAI{\z}
\string# itself:                                    \identAI{#}
\end{verbatim}
\vspace{-15pt}\hrulefill

\def\SayFoo{Foo!}
\lettok~{Q}\string~ let to Q:                       \identAI{~}
\def~{Q}\string~ def'ed to Q:                       \identAI{~}
\lettok~{\relax}\string~ let to \string\relax:      \identAI{~}
\def~{\relax}\string~ def'ed to \string\relax:      \identAI{~}
\lettok~{\SayFoo}\string~ let to \string\SayFoo:    \identAI{~}
\def~{\SayFoo}\string~ def'ed to \string\SayFoo:    \identAI{~}
\lettok~{ }\string~ let to space tok:               \identAI{~}
\def~{ }\string~ def'ed to space tok:               \identAI{~}
\lettok~{#}\string~\ let to \string#:               \identAI{~}
\lettok\z{Q}\string\z\ let to Q:                    \identAI{\z}
\def\z{Q}\string\z\ def'ed to Q:                    \identAI{\z}
\lettok\z{\relax}\string\z\ let to \string\relax:   \identAI{\z}
\def\z{\relax}\string\z\ def'ed to \string\relax:   \identAI{\z}
\lettok\z{\SayFoo}\string\z\ let to \string\SayFoo: \identAI{\z}
\def\z{\SayFoo}\string\z\ def'ed to \string\SayFoo: \identAI{\z}
\lettok\z{ }\string\z\ let to space tok:            \identAI{\z}
\def\z{ }\string\z\ def'ed to space tok:            \identAI{\z}
\lettok\z{#}\string\z\ let to \string#:             \identAI{\z}
\string# itself:                                    \identAI{#}
\end{exampleD}


\subsection{Changing grouping tokens (catcodes 1,2)}

\begingroup

Changing grouping tokens (catcodes 1,2) may require something more,
  if the output stream is to be detokenized.  
In the following examples, pay attention to the
  detokenized grouping around the argument to \macname{fbox}.

\medskip
As we will see, the issues raised here only affect the situation
  when detokenization of the output stream is required.
\medskip

\begin{exampleA}[]{\TokCycle{} defaults grouping tokens to braces:}
\tokencycle
 {\addcytoks{(#1)}}
 {\processtoks{#1}}
 {\addcytoks{#1}}
 {\addcytoks{ }}
This \fbox{is a} test.
\endtokencycle\medskip

\detokenize\expandafter{\the\cytoks}
\end{exampleA}

One can make brackets cat-1,2, redefining bgroup/egroup to [ ].
However, while one can now use brackets in input stream, braces 
  will still appear in the detokenized \TokCycle{} output stream:

\begin{exampleA}[lefthand width=6.5cm]
{\TokCycle{} will not automatically change its grouping tokens}
\catcode`\[=1
\catcode`\]=2
\let\bgroup[
\let\egroup]
\tokencycle
 {\addcytoks{(#1)}}
 {\processtoks{#1}}
 {\addcytoks{#1}}
 {\addcytoks{ }}
This \fbox[is a] test.
\endtokencycle\medskip

\detokenize\expandafter{\the\cytoks}
\end{exampleA}

If it is necessary to reflect revised grouping tokens in the 
  output stream, the \macname{settcgrouping} macro is 
  to be used.

\begin{exampleA}[lefthand width=6.5cm]
{Redefine \TokCycle{} grouping tokens as angle
  brackets using \macname{settcGrouping}}
\catcode`\<=1
\catcode`\>=2
\catcode`\{=12
\catcode`\}=12
\let\bgroup<
\let\egroup>
\settcGrouping<<#1>>
\tokencycle
 <\addcytoks<(#1)>>
 <\processtoks<#1>>
 <\addcytoks<#1>>
 <\addcytoks< >>
This \fbox<is a> test.
\endtokencycle\medskip

\detokenize\expandafter<\the\cytoks>
\end{exampleA}

Angle brackets are now seen in the above detokenization.
Until subsequently changed, cat-1,2 angle brackets now appear in 
  detokenized \TokCycle{} groups, even if other cat-1,2 tokens were
  used in the input stream.
Bottom line: 
\begin{itemize}
\item adding, deleting, or changing catcode 1,2 explicit 
  grouping tokens, e.g., \{\}, (in conjunction with their 
  associated implicit  \macname{bgroup}\macname{egroup}) 
  tokens will not affect \TokCycle's ability to digest proper 
  grouping of the input stream, regardless of which tokens 
  are catcode 1,2 at the moment.

\item The grouping tokens used in \TokCycle's output 
  default to \verb|{}| braces (with cat-1,2), but can be 
  changed deliberately  using \macname{settcGrouping}.

\item The package, currently, has no way to reproduce in the
   output stream the actual grouping tokens that occur in the 
  input stream, but one should ask, for the particular
  application, if it really matters, as long as the the 
  proper catcodes-1,2 are preserved?

\end{itemize}

\endgroup

\subsection{Catcode 10 space tokens\label{s:spc}}

\begingroup

Here we demonstrate that \TokCycle{} can handle arbitrary redesignation
  of tokens to cat-10, as well as implicit space tokens (both implicit
  macro spaces and active-implicit character spaces).

\ddbend While it should seem natural, we note that implicit
  space tokens are directed to the Space directive rather than
  the Character directive.
However, \macname{ifimplicittok} may still be used to 
  differentiate an explicit space from an implicit one.


\ddbend
If the implicit space is \textit{also} an active character, 
  \macname{ifactivetok} is also set, for the user's benefit.
Likewise, \macname{ifactivechar} is also checked, to see
  if the charcode of the active space is still, indeed, active.
While \verb|#1| may be used to represent the space in the space directive,
  a special technique may be required to recover the detokenized name of the 
  active space character.
In particular, if the active token is an implicit space, but the charcode
  of that token is no longer active, \verb|#1| will, for this case, 
  contain a generic implicit space token, \macname{tcsptoken}.
However, for all active space tokens, the name of the associated active 
  character in the input stream will be defined as a cat-12 token in 
  \macname{theactivespace}.

\medskip
Note in the following examples that cat-10 tokens do \textit{not}
  get under-dots.
The next three examples all use the same input, but with different
catcode settings for the space and the underscore.

\fboxsep=1pt

\begin{exampleA}[lefthand width=10cm]{space cat-10{,} underscore cat-12}
\catcode`\_=12 %
\catcode`\ =10 %

\tokencycle{\addcytoks{\underdot{#1}}}%
{\processtoks{#1}}%
{\addcytoks{#1}}%
{\addcytoks{#1}}%
\fbox{a_c d} b_g\itshape f\upshape\endtokencycle
\end{exampleA}
%
\begin{exampleA}[lefthand width=10cm]{space cat-10{,} underscore cat-10}
\catcode`\_=10 %
\catcode`\ =10 %

\tokencycle{\addcytoks{\underdot{#1}}}%
{\processtoks{#1}}%
{\addcytoks{#1}}%
{\addcytoks{#1}}%
\fbox{a_c d} b_g\itshape f\upshape\endtokencycle
\end{exampleA}

%

\begin{exampleA}[lefthand width=10cm]{space cat-12{,} underscore cat-10}
\catcode`\_=10 %
\catcode`\ =12 %

\tokencycle{\addcytoks{\underdot{#1}}}%
{\processtoks{#1}}%
{\addcytoks{#1}}%
{\addcytoks{#1}}%
\fbox{a_c d} b_g\itshape f\upshape\endtokencycle
\end{exampleA}

The next two examples introduce implicit and active-implicit spaces.
In the first example, functionally identical to the prior example, 
  we see that \TokCycle{} can digest and direct such 
  tokens to the Space directive, here in the form of \macname{z}.

%%%
\resettokcycle
\Characterdirective{\addcytoks{\underdot{#1}}}

\begin{exampleA}[lefthand width=10cm]{Implicit spaces also work}
\resettokcycle
\Characterdirective{\addcytoks{\underdot{#1}}}
\def\:{\let\z= } \: %
\catcode`\_=10 %
\catcode`\ =12 %

\tokencyclexpress
\fbox{a\z{}c d} b_g\itshape f\upshape
\endtokencyclexpress
\end{exampleA}

In the second example, an active implicit space token is created, \texttt{Q},
  and stored in a definition, \macname{tmp}.
A \macname{string} is applied by the token cycle at one point to the
  space tokens and we see that the proper implicit tokens are decoded, whether
  they are active or macro.

\medskip
The one case deserving special note is the final case of the example,
  in which the catcode of \texttt{Q}, the active character, is restored
  to a value of 12, before the previously tokenized, active-implicit
  \texttt{Q} is passed to the token cycle.
In such a case, where future incantations of \texttt{Q} are no longer active,
  then the active-implicit space token that gets passed to the 
  Space directive (by way of \macname{tmp}) is taken as a generic 
  active-implicit \macname{tcsptoken}, instead of the original 
  active-implicit token (\texttt{Q}).

\medskip
Nonetheless, the original string of the active-implicit token (that is, a
  cat-12 \texttt{Q}) is preserved in \macname{theactivespace}.
The reason for this behavior is that the absorption of spaces in \TokCycle{}
  is a destructive process, in which the spaces are absorbed as strings,
  so that a proper interpretation of their implicitness can be ascertained.
With the character no longer active, it would be more difficult to 
  recreate an active-implicit version of \textit{that} token to
  pass to the Space directive.
Thus, a generic active-implicit space token is, instead, employed.


\begin{exampleA}[lefthand width=9.05cm]{Active Implicit spaces work{,} too}
\resettokcycle
\def\:{\let\z= } \: %
\catcode`Q=\active %
\def\:{\let Q= } \: %
\catcode`\_=10 %

\def\tmp{xQx x_x\z{}x}
\expandafter\tokencyclexpress\tmp\endtokencyclexpress

\Spacedirective{\addcytoks{\textcolor{cyan}\bgroup}%
  \addcytoks[x]{(\string#1\ifactivetok
    \ifimplicittok\ifactivechar\else\noexpand
    \textcolor{red}{:\theactivespace}\fi\fi\fi)}%
  \addcytoks{\egroup}}

\medskip
\expandafter\tokencyclexpress\tmp\endtokencyclexpress

\medskip
\catcode`Q=12 
\expandafter\tokencyclexpress\tmp\endtokencyclexpress

\end{exampleA}
\endgroup


\subsection{Changes to catcode 0}

\begingroup

\begin{exampleA}[]{Cat-0 changes are not a hindrance to \TokCycle}
\let\littlet=t
\catcode`\! 0 !catcode`!\ 12
!Characterdirective{!ifimplicittok
  !addcytoks{!fbox{#1}}!else!ifcatSIX
  !addcytoks{!fbox{!fbox{#1}}}
  !else!addcytoks{#1}!fi!fi}
!tokencyclexpress Here, {!scshape!bgroup 
  on !today!itshape{} we are !egroup 
  !littlet es!littlet ing} cat-0 
  changes{!bgroup}!egroup
!endtokencyclexpress!medskip

!detokenize!expandafter{!the!cytoks}
\end{exampleA}

\endgroup


\end{document}

