texlive[63368] Master/texmf-dist: functional (22may22)
commits+karl at tug.org
commits+karl at tug.org
Sun May 22 22:22:48 CEST 2022
Revision: 63368
http://tug.org/svn/texlive?view=revision&revision=63368
Author: karl
Date: 2022-05-22 22:22:48 +0200 (Sun, 22 May 2022)
Log Message:
-----------
functional (22may22)
Modified Paths:
--------------
trunk/Master/texmf-dist/doc/latex/functional/functional.pdf
trunk/Master/texmf-dist/doc/latex/functional/functional.tex
trunk/Master/texmf-dist/tex/latex/functional/functional.sty
Modified: trunk/Master/texmf-dist/doc/latex/functional/functional.pdf
===================================================================
(Binary files differ)
Modified: trunk/Master/texmf-dist/doc/latex/functional/functional.tex
===================================================================
--- trunk/Master/texmf-dist/doc/latex/functional/functional.tex 2022-05-22 20:22:34 UTC (rev 63367)
+++ trunk/Master/texmf-dist/doc/latex/functional/functional.tex 2022-05-22 20:22:48 UTC (rev 63368)
@@ -3,7 +3,7 @@
\documentclass[oneside]{book}
\usepackage[a4paper,margin=2.5cm]{geometry}
-\newcommand*{\myversion}{2022F}
+\newcommand*{\myversion}{2022G}
\newcommand*{\mydate}{Version \myversion\ (\the\year-\mylpad\month-\mylpad\day)}
\newcommand*{\mylpad}[1]{\ifnum#1<10 0\the#1\else\the#1\fi}
@@ -162,13 +162,13 @@
\begin{minipage}{0.55\textwidth}
\begin{codehigh}
\IgnoreSpacesOn
-\PrgNewFunction \MathSquare { m } {
- \IntSet \lTmpaInt {\IntEval {#1 * #1}}
- \Return {\Value \lTmpaInt}
+\prgNewFunction \mathSquare { m } {
+ \intSet \lTmpaInt {\intEval {#1 * #1}}
+ \prgReturn {\expValue \lTmpaInt}
}
\IgnoreSpacesOff
-\MathSquare{5}
-\MathSquare{\MathSquare{5}}
+\mathSquare{5}
+\mathSquare{\mathSquare{5}}
\end{codehigh}
\end{minipage}%
\begin{minipage}{0.45\textwidth}
@@ -185,23 +185,23 @@
\end{minipage}
%\IgnoreSpacesOn
-%\PrgNewFunction \MathSquare { m }{
-% \IntSet \lTmpaInt { \IntEval { #1 * #1 } }
-% \Return { \Value \lTmpaInt }
+%\prgNewFunction \mathSquare { m }{
+% \intSet \lTmpaInt { \intEval { #1 * #1 } }
+% \prgReturn { \expValue \lTmpaInt }
%}
%\IgnoreSpacesOff
-%\MathSquare{5}
-%\MathSquare{\MathSquare{5}}
+%\mathSquare{5}
+%\mathSquare{\mathSquare{5}}
%\IgnoreSpacesOn
-%\PrgNewFunction \MathCubic { m }
+%\prgNewFunction \mathCubic { m }
% {
-% \IntSet \lTmpaInt { \IntEval { #1 * #1 * #1 } }
-% \Return { \Value \lTmpaInt }
+% \intSet \lTmpaInt { \intEval { #1 * #1 * #1 } }
+% \prgReturn { \expValue \lTmpaInt }
% }
%\IgnoreSpacesOff
-%\MathCubic{2}
-%\MathCubic{\MathCubic{2}}
+%\mathCubic{2}
+%\mathCubic{\mathCubic{2}}
Both examples calculate first the square of $5$ and produce $25$,
then calculate the square of $25$ and produce $625$.
@@ -210,11 +210,11 @@
which means composition of functions works like othe programming languages
such as \verb!Lua! or \verb!JavsScript!.
-You can define new functions with \cs{PrgNewFunction} command.
+You can define new functions with \cs{prgNewFunction} command.
To make composition of functions work as expected,
every function \emph{must not} insert directly any token to the input stream.
Instead, a function \emph{must} pass the result (if any) to \verb!functional! package
-with \cs{Return} command. And \verb!functional! package is responsible for
+with \cs{prgReturn} command. And \verb!functional! package is responsible for
inserting result tokens to the input stream at the appropriate time.
To remove space tokens inside function code in defining functions,
@@ -224,21 +224,21 @@
At the end of this section,
we will compare our factorial example with a similar \verb!Lua! example:
-\begin{minipage}{0.65\textwidth}
+\begin{minipage}{0.68\textwidth}
\begin{codehigh}
\IgnoreSpacesOn
-\PrgNewFunction \Fact { m } {
- \IntCompareTF {#1} = {0} {
- \Return {1}
+\prgNewFunction \mathFact { m } {
+ \intCompareTF {#1} = {0} {
+ \prgReturn {1}
}{
- \Return {\IntEval{#1*\Fact{\IntEval{#1-1}}}}
+ \prgReturn {\intEval{#1*\mathFact{\intEval{#1-1}}}}
}
}
\IgnoreSpacesOff
-\Fact{4}
+\mathFact{4}
\end{codehigh}
\end{minipage}%
-\begin{minipage}{0.35\textwidth}
+\begin{minipage}{0.32\textwidth}
\begin{code}
-- define a function --
function Fact (n)
@@ -254,11 +254,11 @@
\end{minipage}
%\IgnoreSpacesOn
-%\PrgNewFunction \Factorial { m } {
-% \IntCompareTF {#1} = {0} {
-% \Return {1}
+%\prgNewFunction \Factorial { m } {
+% \intCompareTF {#1} = {0} {
+% \prgReturn {1}
% }{
-% \Return { \IntMathMult {#1} { \Factorial { \IntMathSub{#1}{1} } } }
+% \prgReturn { \intMathMult {#1} { \Factorial { \intMathSub{#1}{1} } } }
% }
%}
%\IgnoreSpacesOff
@@ -277,19 +277,19 @@
\begin{codehigh}
\Functional{scoping=true}
\IgnoreSpacesOn
-\IntSet \lTmpaInt {1}
-\IntVarLog \lTmpaInt % ---- 1
-\PrgNewFunction \SomeFun { } {
- \IntSet \lTmpaInt {2}
- \IntVarLog \lTmpaInt % ---- 2
- \IntCompareTF {1} > {0} {
- \IntSet \lTmpaInt {3}
- \IntVarLog \lTmpaInt % ---- 3
+\intSet \lTmpaInt {1}
+\intVarLog \lTmpaInt % ---- 1
+\prgNewFunction \someFun { } {
+ \intSet \lTmpaInt {2}
+ \intVarLog \lTmpaInt % ---- 2
+ \intCompareTF {1} > {0} {
+ \intSet \lTmpaInt {3}
+ \intVarLog \lTmpaInt % ---- 3
}{ }
- \IntVarLog \lTmpaInt % ---- 2
+ \intVarLog \lTmpaInt % ---- 2
}
-\SomeFun
-\IntVarLog \lTmpaInt % ---- 1
+\someFun
+\intVarLog \lTmpaInt % ---- 1
\IgnoreSpacesOff
\end{codehigh}
\end{minipage}%
@@ -319,7 +319,7 @@
The difference is that \verb!functional! package provides only one function for setting
both local and global varianbles of the same type,
by checking leading letters of their names. So for integer variables, you can write
-\verb!\IntSet\lTmpaInt{1}! and \verb!\IntSet\gTmpbInt{2}!.
+\verb!\intSet\lTmpaInt{1}! and \verb!\intSet\gTmpbInt{2}!.
The previous example will produce different result
if we change variable from \verb!\lTmpaInt! to \verb!\gTmpaInt!.
@@ -328,19 +328,19 @@
\begin{codehigh}
\Functional{scoping=true}
\IgnoreSpacesOn
-\IntSet \gTmpaInt {1}
-\IntVarLog \gTmpaInt % ---- 1
-\PrgNewFunction \SomeFun { } {
- \IntSet \gTmpaInt {2}
- \IntVarLog \gTmpaInt % ---- 2
- \IntCompareTF {1} > {0} {
- \IntSet \gTmpaInt {3}
- \IntVarLog \gTmpaInt % ---- 3
+\intSet \gTmpaInt {1}
+\intVarLog \gTmpaInt % ---- 1
+\prgNewFunction \someFun { } {
+ \intSet \gTmpaInt {2}
+ \intVarLog \gTmpaInt % ---- 2
+ \intCompareTF {1} > {0} {
+ \intSet \gTmpaInt {3}
+ \intVarLog \gTmpaInt % ---- 3
}{ }
- \IntVarLog \gTmpaInt % ---- 3
+ \intVarLog \gTmpaInt % ---- 3
}
-\SomeFun
-\IntVarLog \gTmpaInt % ---- 3
+\someFun
+\intVarLog \gTmpaInt % ---- 3
\IgnoreSpacesOff
\end{codehigh}
\end{minipage}%
@@ -376,48 +376,48 @@
% FIXME: spaces at the first line will be removed
%\begin{codehigh}[]
-% [I] \MathSquare{5}
-% [I] \IntEval{5*5}
-% [I] \Expand{\int_eval:n {5*5}}
+% [I] \mathSquare{5}
+% [I] \intEval{5*5}
+% [I] \expWhole{\int_eval:n {5*5}}
% [O] 25
-% [I] \Return{25}
+% [I] \prgReturn{25}
% [O] 25
% [O] 25
-% [I] \IntSet\lTmpaInt {25}
+% [I] \intSet\lTmpaInt {25}
% [O]
-% [I] \Value\lTmpaInt
+% [I] \expValue\lTmpaInt
% [O] 25
-% [I] \Return{25}
+% [I] \prgReturn{25}
% [O] 25
% [O] 25
%\end{codehigh}
\begin{codehigh}[]
-[I] \MathSquare{5}
- [I] \IntEval{5*5}
- [I] \Expand{\int_eval:n {5*5}}
+[I] \mathSquare{5}
+ [I] \intEval{5*5}
+ [I] \expWhole{\int_eval:n {5*5}}
[O] 25
- [I] \Return{25}
+ [I] \prgReturn{25}
[O] 25
[O] 25
- [I] \IntSet{\lTmpaInt }{25}
+ [I] \intSet{\lTmpaInt }{25}
[O]
- [I] \Value{\lTmpaInt }
+ [I] \expValue{\lTmpaInt }
[O] 25
- [I] \Return{25}
+ [I] \prgReturn{25}
[O] 25
[O] 25
-[I] \MathSquare{25}
- [I] \IntEval{25*25}
- [I] \Expand{\int_eval:n {25*25}}
+[I] \mathSquare{25}
+ [I] \intEval{25*25}
+ [I] \expWhole{\int_eval:n {25*25}}
[O] 625
- [I] \Return{625}
+ [I] \prgReturn{625}
[O] 625
[O] 625
- [I] \IntSet{\lTmpaInt }{625}
+ [I] \intSet{\lTmpaInt }{625}
[O]
- [I] \Value{\lTmpaInt }
+ [I] \expValue{\lTmpaInt }
[O] 625
- [I] \Return{625}
+ [I] \prgReturn{625}
[O] 625
[O] 625
\end{codehigh}
@@ -444,8 +444,8 @@
\end{code}
\end{minipage}
-Within \verb!functional! package, there is only one command (\cs{PrgNewFunction})
-for defining new functions, which is good for normal users.
+Within \verb!functional! package, there is only one command (\cs{prgNewFunction})
+for defining new functions, which is good for regular users.
The created functions are always protected and accept \verb!\par! in their arguments.
Since \verb!functional! package gets the results of functions by evaluation
@@ -481,31 +481,31 @@
Within \verb!functional! package, there are only three variants
(\verb!c!, \verb!e!, \verb!V!) are provided, and these variants are defined
-as functions (\cs{Name}, \cs{Expand}, \cs{Value}, respetively),
-which are easier to use for normal users.
+as functions (\cs{expName}, \cs{expWhole}, \cs{expValue}, respetively),
+which are easier to use for regular users.
\begin{demohigh}
\newcommand\test{uvw}
-\Name{test}
+\expName{test}
\end{demohigh}
\begin{demohigh}
\newcommand\test{uvw}
-\Expand{111\test222}
+\expWhole{111\test222}
\end{demohigh}
\begin{demohigh}
-\IntSet\lTmpaInt{123}
-\Value\lTmpaInt
+\intSet\lTmpaInt{123}
+\expValue\lTmpaInt
\end{demohigh}
The most interesting feature is that you can compose these functions.
For example, you can easily get the \verb!v! variant of \verb!expl3! by
-simply composing \cs{Name} and \cs{Value} functions:
+simply composing \cs{expName} and \cs{expValue} functions:
\begin{demohigh}
-\IntSet\lTmpaInt{123}
-\Value{\Name{lTmpaInt}}
+\intSet\lTmpaInt{123}
+\expValue{\expName{lTmpaInt}}
\end{demohigh}
\chapter{Functional Progarmming (\texttt{Prg})}
@@ -512,14 +512,14 @@
\section{Defining Functions and Conditionals}
-\begin{function}{\PrgNewFunction}
+\begin{function}{\prgNewFunction}
\begin{syntax}
-\cs{PrgNewFunction} \meta{function} \Arg{argument specification} \Arg{code}
+\cs{prgNewFunction} \meta{function} \Arg{argument specification} \Arg{code}
\end{syntax}
Creates protected \meta{function} for evaluating the \meta{code}.
Within the \meta{code}, the parameters (\verb|#1|, \verb|#2|,
\emph{etc.}) will be replaced by those absorbed by the function.
-The returned value \emph{must} be passed with \cs{Return} function.
+The returned value \emph{must} be passed with \cs{prgReturn} function.
The definition is global and an error results if the
\meta{function} is already defined.\par
The \Arg{argument specification} in a list of letters,
@@ -534,103 +534,103 @@
%\hline
\end{tabular}\par}
The argument manipulation for argument type \texttt{M} or \texttt{m}
-is: if the argument starts with a function defined with \cs{PrgNewFunction},
+is: if the argument starts with a function defined with \cs{prgNewFunction},
the argument will be evaluated and replaced with the returned value.
\end{function}
-\begin{function}{\PrgSetEqFunction}
+\begin{function}{\prgSetEqFunction}
\begin{syntax}
-\cs{PrgSetEqFunction} \meta{function_1} \meta{function_2}
+\cs{prgSetEqFunction} \meta{function_1} \meta{function_2}
\end{syntax}
Sets \meta{function_1} as an alias of \meta{function_2}.
\end{function}
-\begin{function}{\PrgNewConditional}
+\begin{function}{\prgNewConditional}
\begin{syntax}
-\cs{PrgNewConditional} \meta{function} \Arg{argument specification} \Arg{code}
+\cs{prgNewConditional} \meta{function} \Arg{argument specification} \Arg{code}
\end{syntax}
Creates protected conditional \meta{function} for evaluating the \meta{code}.
The returned value of the \meta{function} \emph{must} be either |\cTrueBool|
-or |\cFalseBool| and be passed with \cs{Return} function..
+or |\cFalseBool| and be passed with \cs{prgReturn} function..
The definition is global and an error results if the \meta{function} is already defined.
\par
-Assume the \meta{function} is |\FooIfBar|, then another three functions
-are also created at the same time: |\FooIfBarT|, |\FooIfBarF|, and |\FooIfBarTF|.
+Assume the \meta{function} is |\fooIfBar|, then another three functions
+are also created at the same time: |\fooIfBarT|, |\fooIfBarF|, and |\fooIfBarTF|.
They have extra arguments which are \Arg{true code} or/and \Arg{false code}.
For example, if you write
\begin{codehigh}
-\PrgNewConditional \FooIfBar {Mm} {code with return value \cTrueBool or \cFalseBool}
+\prgNewConditional \fooIfBar {Mm} {code with return value \cTrueBool or \cFalseBool}
\end{codehigh}
Then the following four functions are created:
\begin{itemize}
- \item |\FooIfBar| \meta{arg_1} \Arg{arg_2}
- \item |\FooIfBarT| \meta{arg_1} \Arg{arg_2} \Arg{true code}
- \item |\FooIfBarF| \meta{arg_1} \Arg{arg_2} \Arg{false code}
- \item |\FooIfBarTF| \meta{arg_1} \Arg{arg_2} \Arg{true code} \Arg{false code}
+ \item |\fooIfBar| \meta{arg_1} \Arg{arg_2}
+ \item |\fooIfBarT| \meta{arg_1} \Arg{arg_2} \Arg{true code}
+ \item |\fooIfBarF| \meta{arg_1} \Arg{arg_2} \Arg{false code}
+ \item |\fooIfBarTF| \meta{arg_1} \Arg{arg_2} \Arg{true code} \Arg{false code}
\end{itemize}
\end{function}
\section{Returning Values and Printing Tokens}
-Just like \LuaTeX, \pkg{functional} package also provides \cs{Return} and \cs{Print} functions.
+Just like \LuaTeX, \pkg{functional} package also provides \cs{prgReturn} and \cs{prgPrint} functions.
-\begin{function}{\Return}
+\begin{function}{\prgReturn}
\begin{syntax}
-\cs{Return} \Arg{tokens}
+\cs{prgReturn} \Arg{tokens}
\end{syntax}
Returns \meta{tokens} as result of current function or conditional.
-This function is normally used in the \meta{code} of \cs{PrgNewFunction}
-or \cs{PrgNewConditional}, and it \emph{must} be the last function evaluated in the \meta{code}.
+This function is normally used in the \meta{code} of \cs{prgNewFunction}
+or \cs{prgNewConditional}, and it \emph{must} be the last function evaluated in the \meta{code}.
If it is missing, the return value of the last function evaluated in the \meta{code}
is returned. Therefore, the following two examples produce the same output:
\begin{codehigh}
\IgnoreSpacesOn
-\PrgNewFunction \MathSquare { m } {
- \IntSet \lTmpaInt {\IntEval {#1 * #1}}
- \Return {\Value \lTmpaInt}
+\prgNewFunction \mathSquare { m } {
+ \intSet \lTmpaInt {\intEval {#1 * #1}}
+ \prgReturn {\expValue \lTmpaInt}
}
\IgnoreSpacesOff
-\MathSquare{5}
+\mathSquare{5}
\end{codehigh}
\begin{codehigh}
\IgnoreSpacesOn
-\PrgNewFunction \MathSquare { m } {
- \IntSet \lTmpaInt {\IntEval {#1 * #1}}
- \Value \lTmpaInt
+\prgNewFunction \mathSquare { m } {
+ \intSet \lTmpaInt {\intEval {#1 * #1}}
+ \expValue \lTmpaInt
}
\IgnoreSpacesOff
-\MathSquare{5}
+\mathSquare{5}
\end{codehigh}
\pkg{Functional} package takes care of return values,
and only print them to the input stream if the outer most functions are evaluated.
\end{function}
-\begin{function}{\Print}
+\begin{function}{\prgPrint}
\begin{syntax}
-\cs{Print} \Arg{tokens}
+\cs{prgPrint} \Arg{tokens}
\end{syntax}
Prints \meta{tokens} directly to the input stream.
-If there is no function defined with \cs{PrgNewFunction} in \meta{tokens},
-you can omit \cs{Print} and write only \meta{tokens}.
-But if there is any function defined with \cs{PrgNewFunction} in \meta{tokens},
-you \emph{have to} use \cs{Print} function.
+If there is no function defined with \cs{prgNewFunction} in \meta{tokens},
+you can omit \cs{prgPrint} and write only \meta{tokens}.
+But if there is any function defined with \cs{prgNewFunction} in \meta{tokens},
+you \emph{have to} use \cs{prgPrint} function.
\end{function}
\section{Running Code with Anonymous Functions}
-\begin{function}{\Do}
+\begin{function}{\prgDo}
\begin{syntax}
-\cs{Do} \Arg{code}
+\cs{prgDo} \Arg{code}
\end{syntax}
Treats \meta{code} as an anonymous function without arguments and evaluates it.
\end{function}
-\begin{function}{\PrgRunOneArgCode,\PrgRunTwoArgCode,\PrgRunThreeArgCode,\PrgRunFourArgCode}
+\begin{function}{\prgRunOneArgCode,\prgRunTwoArgCode,\prgRunThreeArgCode,\prgRunFourArgCode}
\begin{syntax}
-\cs{PrgRunOneArgCode} \Arg{arg_1} \Arg{code}
-\cs{PrgRunTwoArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{code}
-\cs{PrgRunThreeArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{arg_3} \Arg{code}
-\cs{PrgRunFourArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{arg_3} \Arg{arg_4} \Arg{code}
+\cs{prgRunOneArgCode} \Arg{arg_1} \Arg{code}
+\cs{prgRunTwoArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{code}
+\cs{prgRunThreeArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{arg_3} \Arg{code}
+\cs{prgRunFourArgCode} \Arg{arg_1} \Arg{arg_2} \Arg{arg_3} \Arg{arg_4} \Arg{code}
\end{syntax}
Treats \meta{code} as an anonymous function with one to four arguments respectively,
and evaluates it. In evaluating the \meta{code}, \pkg{functional} package first evaluates
@@ -642,9 +642,9 @@
\section{Expanding Tokens}
-\begin{function}{\Name}
+\begin{function}{\expName}
\begin{syntax}
-\cs{Name} \Arg{control sequence name}
+\cs{expName} \Arg{control sequence name}
\end{syntax}
Expands the \meta{control sequence name} until only characters
remain, then converts this into a control sequence and returns it.
@@ -660,28 +660,28 @@
%\end{texnote}
\end{function}
-\begin{function}{\Value}
+\begin{function}{\expValue}
\begin{syntax}
-\cs{Value} \meta{variable}
+\cs{expValue} \meta{variable}
\end{syntax}
Recovers the content of a \meta{variable} and returns the value.
An error is raised if the variable does not exist or if it is invalid.
-Note that it is the same as \cs{TlUse} for \meta{tl var}, or \cs{IntUse} for \meta{int var}.
+Note that it is the same as \cs{tlUse} for \meta{tl var}, or \cs{intUse} for \meta{int var}.
\end{function}
-\begin{function}{\Expand}
+\begin{function}{\expWhole}
\begin{syntax}
-\cs{Expand} \Arg{tokens}
+\cs{expWhole} \Arg{tokens}
\end{syntax}
Expands the \meta{tokens} exhaustively and returns the result.
\end{function}
-\begin{function}{\UnExpand}
+\begin{function}{\unExpand}
\begin{syntax}
-\cs{UnExpand} \Arg{tokens}
+\cs{unExpand} \Arg{tokens}
\end{syntax}
-Prevents expansion of the \meta{tokens} inside the argument of \cs{Expand} function.
-The argument of \cs{UnExpand} \emph{must} be surrounded by braces.
+Prevents expansion of the \meta{tokens} inside the argument of \cs{expWhole} function.
+The argument of \cs{unExpand} \emph{must} be surrounded by braces.
%\begin{texnote}
%This is the \eTeX{} \tn{unexpanded} primitive. In an
%|x|-expanding definition (\cs{cs_new:Npx}), \cs{exp_not:n}~|{#1}|
@@ -692,14 +692,14 @@
%\end{texnote}
\end{function}
-\begin{function}{\OnlyName}
+\begin{function}{\onlyName}
\begin{syntax}
-\cs{OnlyName} \Arg{tokens}
+\cs{onlyName} \Arg{tokens}
\end{syntax}
Expands the \meta{tokens} until only characters remain, and then
converts this into a control sequence.
Further expansion of this control sequence is then inhibited
-inside the argument of \cs{Expand} function.
+inside the argument of \cs{expWhole} function.
%\begin{texnote}
%Protected macros that appear in a \texttt{c}-type argument are
%expanded despite being protected; \cs{exp_not:n} also has no
@@ -709,26 +709,26 @@
%\end{texnote}
\end{function}
-\begin{function}{\OnlyValue}
+\begin{function}{\onlyValue}
\begin{syntax}
-\cs{OnlyValue} \meta{variable}
+\cs{onlyValue} \meta{variable}
\end{syntax}
Recovers the content of the \meta{variable}, then prevents expansion
-of this material inside the argument of \cs{Expand} function.
+of this material inside the argument of \cs{expWhole} function.
\end{function}
\section{Using Tokens}
-\begin{function}{\UseOne,\GobbleOne}
+\begin{function}{\useOne,\gobbleOne}
\begin{syntax}
-\cs{UseOne} \Arg{argument}
-\cs{GobbleOne} \Arg{argument}
+\cs{useOne} \Arg{argument}
+\cs{gobbleOne} \Arg{argument}
\end{syntax}
-The function \cs{UseOne} absorbs one argument and returns it.
+The function \cs{useOne} absorbs one argument and returns it.
%\begin{texnote}
%The \cs{UseOne} function is equivalent to \LaTeXe{}'s \tn{@firstofone}.
%\end{texnote}
-\cs{GobbleOne} absorbs one argument and returns nothing.
+\cs{gobbleOne} absorbs one argument and returns nothing.
%\begin{texnote}
%These are equivalent to \LaTeXe{}'s \tn{@gobble}, \tn{@gobbbletwo},
%\emph{etc.}
@@ -735,19 +735,19 @@
%\end{texnote}
For example
\begin{demohigh}
-\UseOne{abc}\GobbleOne{ijk}\UseOne{xyz}
+\useOne{abc}\gobbleOne{ijk}\useOne{xyz}
\end{demohigh}
\end{function}
-\begin{function}{\UseGobble,\GobbleUse}
+\begin{function}{\useGobble,\gobbleUse}
\begin{syntax}
-\cs{UseGobble} \Arg{arg_1} \Arg{arg_2}
-\cs{GobbleUse} \Arg{arg_1} \Arg{arg_2}
+\cs{useGobble} \Arg{arg_1} \Arg{arg_2}
+\cs{gobbleUse} \Arg{arg_1} \Arg{arg_2}
\end{syntax}
These functions absorb two arguments.
-The function \cs{UseGobble} discards the second argument,
+The function \cs{useGobble} discards the second argument,
and returns the content of the first argument.
-\cs{GobbleUse} discards the first argument,
+\cs{gobbleUse} discards the first argument,
and returns the content of the second argument.
%\begin{texnote}
%These are equivalent to \LaTeXe{}'s \tn{@firstoftwo} and
@@ -755,7 +755,7 @@
%\end{texnote}
For example
\begin{demohigh}
-\UseGobble{abc}{uvw}\GobbleUse{abc}{uvw}
+\useGobble{abc}{uvw}\gobbleUse{abc}{uvw}
\end{demohigh}
\end{function}
@@ -767,8 +767,8 @@
Constants that represent \verb|true| and \verb|false|, respectively. Used to
implement predicates. For example
\begin{demohigh}
-\BoolVarIfTF \cTrueBool {\Return{True!}} {\Return{False!}}
-\BoolVarIfTF \cFalseBool {\Return{True!}} {\Return{False!}}
+\boolVarIfTF \cTrueBool {\prgReturn{True!}} {\prgReturn{False!}}
+\boolVarIfTF \cFalseBool {\prgReturn{True!}} {\prgReturn{False!}}
\end{demohigh}
\end{variable}
@@ -800,13 +800,13 @@
more tightly than \verb"||"). In addition to this, parentheses can be
used to isolate sub-expressions. For example,
\begin{codehigh}
-\IntCompare {1} = {1} &&
+\intCompare {1} = {1} &&
(
- \IntCompare {2} = {3} ||
- \IntCompare {4} < {4} ||
- \StrIfEq {abc} {def}
+ \intCompare {2} = {3} ||
+ \intCompare {4} < {4} ||
+ \strIfEq {abc} {def}
) &&
-! \IntCompare {2} = {4}
+! \intCompare {2} = {4}
\end{codehigh}
is a valid boolean expression.
@@ -816,9 +816,9 @@
\section{Creating and Setting Booleans}
-\begin{function}{\BoolNew}
+\begin{function}{\boolNew}
\begin{syntax}
-\cs{BoolNew} \meta{boolean}
+\cs{boolNew} \meta{boolean}
\end{syntax}
Creates a new \meta{boolean} or raises an error if the
name is already taken. The declaration is global. The
@@ -825,9 +825,9 @@
\meta{boolean} is initially \texttt{false}.
\end{function}
-\begin{function}{\BoolConst}
+\begin{function}{\boolConst}
\begin{syntax}
-\cs{BoolConst} \meta{boolean} \Arg{boolexpr}
+\cs{boolConst} \meta{boolean} \Arg{boolexpr}
\end{syntax}
Creates a new constant \meta{boolean} or raises an error if the name
is already taken. The value of the \meta{boolean} is set globally to
@@ -834,81 +834,81 @@
the result of evaluating the \meta{boolexpr}.
For example
\begin{codehigh}
-\BoolConst \cFooSomeBool {\IntCompare{3}>{2}}
-\BoolVarLog \cFooSomeBool
+\boolConst \cFooSomeBool {\intCompare{3}>{2}}
+\boolVarLog \cFooSomeBool
\end{codehigh}
\end{function}
-\begin{function}{\BoolSet}
+\begin{function}{\boolSet}
\begin{syntax}
-\cs{BoolSet} \meta{boolean} \Arg{boolexpr}
+\cs{boolSet} \meta{boolean} \Arg{boolexpr}
\end{syntax}
Evaluates the \meta{boolean expression} and sets the \meta{boolean} variable to
the logical truth of this evaluation.
For example
\begin{codehigh}
-\BoolSet \lTmpaBool {\IntCompare{3}<{4}}
-\BoolVarLog \lTmpaBool
+\boolSet \lTmpaBool {\intCompare{3}<{4}}
+\boolVarLog \lTmpaBool
\end{codehigh}
\begin{codehigh}
-\BoolSet \lTmpaBool {\IntCompare{3}<{4} && \StrIfEq{abc}{uvw}}
-\BoolVarLog \lTmpaBool
+\boolSet \lTmpaBool {\intCompare{3}<{4} && \strIfEq{abc}{uvw}}
+\boolVarLog \lTmpaBool
\end{codehigh}
\end{function}
-\begin{function}{\BoolSetTrue}
+\begin{function}{\boolSetTrue}
\begin{syntax}
-\cs{BoolSetTrue} \meta{boolean}
+\cs{boolSetTrue} \meta{boolean}
\end{syntax}
Sets \meta{boolean} logically \texttt{true}.
\end{function}
-\begin{function}{\BoolSetFalse}
+\begin{function}{\boolSetFalse}
\begin{syntax}
-\cs{BoolSetFalse} \meta{boolean}
+\cs{boolSetFalse} \meta{boolean}
\end{syntax}
Sets \meta{boolean} logically \texttt{false}.
\end{function}
-\begin{function}{\BoolSetEq}
+\begin{function}{\boolSetEq}
\begin{syntax}
-\cs{BoolSetEq} \meta{boolean_1} \meta{boolean_2}
+\cs{boolSetEq} \meta{boolean_1} \meta{boolean_2}
\end{syntax}
Sets \meta{boolean_1} to the current value of \meta{boolean_2}.
For example
\begin{codehigh}
-\BoolSetTrue \lTmpaBool
-\BoolSetEq \lTmpbBool \lTmpaBool
-\BoolVarLog \lTmpbBool
+\boolSetTrue \lTmpaBool
+\boolSetEq \lTmpbBool \lTmpaBool
+\boolVarLog \lTmpbBool
\end{codehigh}
\end{function}
\section{Viewing Booleans}
-\begin{function}{\BoolLog}
+\begin{function}{\boolLog}
\begin{syntax}
-\cs{BoolLog} \Arg{boolean expression}
+\cs{boolLog} \Arg{boolean expression}
\end{syntax}
Writes the logical truth of the \meta{boolean expression} in the log file.
\end{function}
-\begin{function}{\BoolVarLog}
+\begin{function}{\boolVarLog}
\begin{syntax}
-\cs{BoolVarLog} \meta{boolean}
+\cs{boolVarLog} \meta{boolean}
\end{syntax}
Writes the logical truth of the \meta{boolean} in the log file.
\end{function}
-\begin{function}{\BoolShow}
+\begin{function}{\boolShow}
\begin{syntax}
-\cs{BoolShow} \Arg{boolean expression}
+\cs{boolShow} \Arg{boolean expression}
\end{syntax}
Displays the logical truth of the \meta{boolean expression} on the terminal.
\end{function}
-\begin{function}{\BoolVarShow}
+\begin{function}{\boolVarShow}
\begin{syntax}
-\cs{BoolVarShow} \meta{boolean}
+\cs{boolVarShow} \meta{boolean}
\end{syntax}
Displays the logical truth of the \meta{boolean} on the terminal.
\end{function}
@@ -915,101 +915,101 @@
\section{Booleans and Conditionals}
-\begin{function}{\BoolIfExist,\BoolIfExistT,\BoolIfExistF,\BoolIfExistTF}
+\begin{function}{\boolIfExist,\boolIfExistT,\boolIfExistF,\boolIfExistTF}
\begin{syntax}
-\cs{BoolIfExist} \meta{boolean}
-\cs{BoolIfExistT} \meta{boolean} \Arg{true code}
-\cs{BoolIfExistF} \meta{boolean} \Arg{false code}
-\cs{BoolIfExistTF} \meta{boolean} \Arg{true code} \Arg{false code}
+\cs{boolIfExist} \meta{boolean}
+\cs{boolIfExistT} \meta{boolean} \Arg{true code}
+\cs{boolIfExistF} \meta{boolean} \Arg{false code}
+\cs{boolIfExistTF} \meta{boolean} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{boolean} is currently defined. This does not
check that the \meta{boolean} really is a boolean variable.
For example
\begin{demohigh}
-\BoolIfExistTF \lTmpaBool {\Return{Yes}} {\Return{No}}
-\BoolIfExistTF \lFooUndefinedBool {\Return{Yes}} {\Return{No}}
+\boolIfExistTF \lTmpaBool {\prgReturn{Yes}} {\prgReturn{No}}
+\boolIfExistTF \lFooUndefinedBool {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarIf,\BoolVarIfT,\BoolVarIfF,\BoolVarIfTF}
+\begin{function}{\boolVarIf,\boolVarIfT,\boolVarIfF,\boolVarIfTF}
\begin{syntax}
-\cs{BoolVarIf} \meta{boolean}
-\cs{BoolVarIfT} \meta{boolean} \Arg{true code}
-\cs{BoolVarIfF} \meta{boolean} \Arg{false code}
-\cs{BoolVarIfTF} \meta{boolean} \Arg{true code} \Arg{false code}
+\cs{boolVarIf} \meta{boolean}
+\cs{boolVarIfT} \meta{boolean} \Arg{true code}
+\cs{boolVarIfF} \meta{boolean} \Arg{false code}
+\cs{boolVarIfTF} \meta{boolean} \Arg{true code} \Arg{false code}
\end{syntax}
Tests the current truth of \meta{boolean}, and continues evaluation
based on this result. For example
\begin{demohigh}
-\BoolSetTrue \lTmpaBool
-\BoolVarIfTF \lTmpaBool {\Return{True!}} {\Return{False!}}
-\BoolSetFalse \lTmpaBool
-\BoolVarIfTF \lTmpaBool {\Return{True!}} {\Return{False!}}
+\boolSetTrue \lTmpaBool
+\boolVarIfTF \lTmpaBool {\prgReturn{True!}} {\prgReturn{False!}}
+\boolSetFalse \lTmpaBool
+\boolVarIfTF \lTmpaBool {\prgReturn{True!}} {\prgReturn{False!}}
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarNot,\BoolVarNotT,\BoolVarNotF,\BoolVarNotTF}
+\begin{function}{\boolVarNot,\boolVarNotT,\boolVarNotF,\boolVarNotTF}
\begin{syntax}
-\cs{BoolVarNot} \meta{boolean}
-\cs{BoolVarNotT} \meta{boolean} \Arg{true code}
-\cs{BoolVarNotF} \meta{boolean} \Arg{false code}
-\cs{BoolVarNotTF} \meta{boolean} \Arg{true code} \Arg{false code}
+\cs{boolVarNot} \meta{boolean}
+\cs{boolVarNotT} \meta{boolean} \Arg{true code}
+\cs{boolVarNotF} \meta{boolean} \Arg{false code}
+\cs{boolVarNotTF} \meta{boolean} \Arg{true code} \Arg{false code}
\end{syntax}
Evaluates \meta{true code} if \meta{boolean} is \verb!false!,
and \meta{false code} if \meta{boolean} is \verb!true!.
For example
\begin{demohigh}
-\BoolVarNotTF {\IntCompare{3}>{2}} {\Return{Yes}} {\Return{No}}
+\boolVarNotTF {\intCompare{3}>{2}} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarAnd,\BoolVarAndT,\BoolVarAndF,\BoolVarAndTF}
+\begin{function}{\boolVarAnd,\boolVarAndT,\boolVarAndF,\boolVarAndTF}
\begin{syntax}
-\cs{BoolVarAnd} \meta{boolean_1} \meta{boolean_2}
-\cs{BoolVarAndT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
-\cs{BoolVarAndF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
-\cs{BoolVarAndTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
+\cs{boolVarAnd} \meta{boolean_1} \meta{boolean_2}
+\cs{boolVarAndT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
+\cs{boolVarAndF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
+\cs{boolVarAndTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
\end{syntax}
Implements the \enquote{And} operation between two booleans,
hence is \texttt{true} if both are \texttt{true}.
%Contrarily to the infix operator \verb|&&|,
%The \meta{boolean_2} is only evaluated if it is needed to determine the result of
-%\cs{BoolVarAnd}.
+%\cs{boolVarAnd}.
For example
\begin{demohigh}
-\BoolVarAndTF {\IntCompare{3}>{2}} {\IntCompare{3}>{4}} {\Return{Yes}} {\Return{No}}
+\boolVarAndTF {\intCompare{3}>{2}} {\intIfOdd{6}} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarOr,\BoolVarOrT,\BoolVarOrF,\BoolVarOrTF}
+\begin{function}{\boolVarOr,\boolVarOrT,\boolVarOrF,\boolVarOrTF}
\begin{syntax}
-\cs{BoolVarOr} \meta{boolean_1} \meta{boolean_2}
-\cs{BoolVarOrT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
-\cs{BoolVarOrF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
-\cs{BoolVarOrTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
+\cs{boolVarOr} \meta{boolean_1} \meta{boolean_2}
+\cs{boolVarOrT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
+\cs{boolVarOrF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
+\cs{boolVarOrTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
\end{syntax}
Implements the \enquote{Or} operation between two booleans,
hence is \texttt{true} if either one is \texttt{true}.
%Contrarily to the infix operator \verb"||",
%The \meta{boolean_2} is only evaluated if it is needed to determine the result of
-%\cs{BoolVarOr}.
+%\cs{boolVarOr}.
For example
\begin{demohigh}
-\BoolVarOrTF {\IntCompare{3}>{2}} {\IntCompare{3}>{4}} {\Return{Yes}} {\Return{No}}
+\boolVarOrTF {\intCompare{3}>{2}} {\intIfOdd{6}} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarXor,\BoolVarXorT,\BoolVarXorF,\BoolVarXorTF}
+\begin{function}{\boolVarXor,\boolVarXorT,\boolVarXorF,\boolVarXorTF}
\begin{syntax}
-\cs{BoolVarXor} \meta{boolean_1} \meta{boolean_2}
-\cs{BoolVarXorT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
-\cs{BoolVarXorF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
-\cs{BoolVarXorTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
+\cs{boolVarXor} \meta{boolean_1} \meta{boolean_2}
+\cs{boolVarXorT} \meta{boolean_1} \meta{boolean_2} \Arg{true code}
+\cs{boolVarXorF} \meta{boolean_1} \meta{boolean_2} \Arg{false code}
+\cs{boolVarXorTF} \meta{boolean_1} \meta{boolean_2} \Arg{true code} \Arg{false code}
\end{syntax}
Implements an \enquote{exclusive or} operation between two booleans.
For example
\begin{demohigh}
-\BoolVarXorTF {\IntCompare{3}>{2}} {\IntCompare{3}>{4}} {\Return{Yes}} {\Return{No}}
+\boolVarXorTF {\intCompare{3}>{2}} {\intIfOdd{6}} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
@@ -1017,9 +1017,9 @@
Loops using either boolean expressions or stored boolean values.
-\begin{function}{\BoolVarDoUntil}
+\begin{function}{\boolVarDoUntil}
\begin{syntax}
-\cs{BoolVarDoUntil} \meta{boolean} \Arg{code}
+\cs{boolVarDoUntil} \meta{boolean} \Arg{code}
\end{syntax}
Places the \meta{code} in the input stream for \TeX{} to process,
and then checks the logical value of the \meta{boolean}. If it is
@@ -1028,22 +1028,22 @@
\texttt{true}.
\begin{demohigh}
\IgnoreSpacesOn
-\BoolSetFalse \lTmpaBool
-\IntZero \lTmpaInt
-\ClistClear \lTmpaClist
-\BoolVarDoUntil \lTmpaBool {
- \IntIncr \lTmpaInt
- \ClistPutRight \lTmpaClist {\Value\lTmpaInt}
- \IntCompareT {\lTmpaInt} = {10} {\BoolSetTrue \lTmpaBool}
+\boolSetFalse \lTmpaBool
+\intZero \lTmpaInt
+\clistClear \lTmpaClist
+\boolVarDoUntil \lTmpaBool {
+ \intIncr \lTmpaInt
+ \clistPutRight \lTmpaClist {\expValue\lTmpaInt}
+ \intCompareT {\lTmpaInt} = {10} {\boolSetTrue \lTmpaBool}
}
-\ClistVarJoin \lTmpaClist {:}
+\clistVarJoin \lTmpaClist {:}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarDoWhile}
+\begin{function}{\boolVarDoWhile}
\begin{syntax}
-\cs{BoolVarDoWhile} \meta{boolean} \Arg{code}
+\cs{boolVarDoWhile} \meta{boolean} \Arg{code}
\end{syntax}
Places the \meta{code} in the input stream for \TeX{} to process,
and then checks the logical value of the \meta{boolean}. If it is
@@ -1052,22 +1052,22 @@
\texttt{false}.
\begin{demohigh}
\IgnoreSpacesOn
-\BoolSetTrue \lTmpaBool
-\IntZero \lTmpaInt
-\ClistClear \lTmpaClist
-\BoolVarDoWhile \lTmpaBool {
- \IntIncr \lTmpaInt
- \ClistPutRight \lTmpaClist {\Value\lTmpaInt}
- \IntCompareT {\lTmpaInt} = {10} {\BoolSetFalse \lTmpaBool}
+\boolSetTrue \lTmpaBool
+\intZero \lTmpaInt
+\clistClear \lTmpaClist
+\boolVarDoWhile \lTmpaBool {
+ \intIncr \lTmpaInt
+ \clistPutRight \lTmpaClist {\expValue\lTmpaInt}
+ \intCompareT {\lTmpaInt} = {10} {\boolSetFalse \lTmpaBool}
}
-\ClistVarJoin \lTmpaClist {:}
+\clistVarJoin \lTmpaClist {:}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarUntilDo}
+\begin{function}{\boolVarUntilDo}
\begin{syntax}
-\cs{BoolVarUntilDo} \meta{boolean} \Arg{code}
+\cs{boolVarUntilDo} \meta{boolean} \Arg{code}
\end{syntax}
This function firsts checks the logical value of the \meta{boolean}.
If it is \texttt{false} the \meta{code} is placed in the input stream
@@ -1076,22 +1076,22 @@
until the \meta{boolean} is \texttt{true}.
\begin{demohigh}
\IgnoreSpacesOn
-\BoolSetFalse \lTmpaBool
-\IntZero \lTmpaInt
-\ClistClear \lTmpaClist
-\BoolVarUntilDo \lTmpaBool {
- \IntIncr \lTmpaInt
- \ClistPutRight \lTmpaClist {\Value\lTmpaInt}
- \IntCompareT {\lTmpaInt} = {10} {\BoolSetTrue \lTmpaBool}
+\boolSetFalse \lTmpaBool
+\intZero \lTmpaInt
+\clistClear \lTmpaClist
+\boolVarUntilDo \lTmpaBool {
+ \intIncr \lTmpaInt
+ \clistPutRight \lTmpaClist {\expValue\lTmpaInt}
+ \intCompareT {\lTmpaInt} = {10} {\boolSetTrue \lTmpaBool}
}
-\ClistVarJoin \lTmpaClist {:}
+\clistVarJoin \lTmpaClist {:}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\BoolVarWhileDo}
+\begin{function}{\boolVarWhileDo}
\begin{syntax}
-\cs{BoolVarWhileDo} \meta{boolean} \Arg{code}
+\cs{boolVarWhileDo} \meta{boolean} \Arg{code}
\end{syntax}
This function firsts checks the logical value of the \meta{boolean}.
If it is \texttt{true} the \meta{code} is placed in the input stream
@@ -1100,15 +1100,15 @@
until the \meta{boolean} is \texttt{false}.
\begin{demohigh}
\IgnoreSpacesOn
-\BoolSetTrue \lTmpaBool
-\IntZero \lTmpaInt
-\ClistClear \lTmpaClist
-\BoolVarWhileDo \lTmpaBool {
- \IntIncr \lTmpaInt
- \ClistPutRight \lTmpaClist {\Value\lTmpaInt}
- \IntCompareT {\lTmpaInt} = {10} {\BoolSetFalse \lTmpaBool}
+\boolSetTrue \lTmpaBool
+\intZero \lTmpaInt
+\clistClear \lTmpaClist
+\boolVarWhileDo \lTmpaBool {
+ \intIncr \lTmpaInt
+ \clistPutRight \lTmpaClist {\expValue\lTmpaInt}
+ \intCompareT {\lTmpaInt} = {10} {\boolSetFalse \lTmpaBool}
}
-\ClistVarJoin \lTmpaClist {:}
+\clistVarJoin \lTmpaClist {:}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
@@ -1119,13 +1119,13 @@
functions to deal with lists of tokens. Token lists may be present
directly in the argument to a function:
\begin{codehigh}
-\TlFoo {a collection of \tokens}
+\tlFoo {a collection of \tokens}
\end{codehigh}
or may be stored in a so-called \enquote{token list variable}, which
have the suffix \texttt{Tl}: a token list variable can also be used as
the argument to a function, for example
\begin{codehigh}
-\TlVarFoo \lSomeTl
+\tlVarFoo \lSomeTl
\end{codehigh}
In both cases, functions are available to test and manipulate the lists
of tokens, and these have the module prefix \texttt{Tl}.
@@ -1136,7 +1136,7 @@
A token list (explicit, or stored in a variable) can be seen either
as a list of \enquote{items},
-or a list of \enquote{tokens}. An item is whatever \cs{UseOne} would
+or a list of \enquote{tokens}. An item is whatever \cs{useOne} would
grab as its argument: a single non-space token or a brace group,
with optional leading explicit space characters (each item is thus
itself a token list). A token is either a normal \texttt{N} argument,
@@ -1171,7 +1171,7 @@
%will \emph{not} match the simple text input \verb|-NoValue-|, \emph{i.e.}
%that
%\begin{demohigh}
-%\TlIfEqTF {\TlUse\cNoValueTl} {-NoValue-} {Result{Yes}} {\Return{No}}
+%\tlIfEqTF {\tlUse\cNoValueTl} {-NoValue-} {Result{Yes}} {\prgReturn{No}}
%\end{demohigh}
%The \cs{cNoValueTl} marker is intended for
%use in creating document-level interfaces, where it serves as an indicator
@@ -1195,33 +1195,33 @@
\section{Creating and Using Token Lists}
-\begin{function}{\TlNew}
+\begin{function}{\tlNew}
\begin{syntax}
-\cs{TlNew} \meta{tl var}
+\cs{tlNew} \meta{tl var}
\end{syntax}
Creates a new \meta{tl var} or raises an error if the
name is already taken. The declaration is global. The
\meta{tl~var} is initially empty.
\begin{codehigh}
-\TlNew \lFooSomeTl
+\tlNew \lFooSomeTl
\end{codehigh}
\end{function}
-\begin{function}{\TlConst}
+\begin{function}{\tlConst}
\begin{syntax}
-\cs{TlConst} \meta{tl var} \Arg{token list}
+\cs{tlConst} \meta{tl var} \Arg{token list}
\end{syntax}
Creates a new constant \meta{tl var} or raises an error
if the name is already taken. The value of the
\meta{tl var} is set globally to the \meta{token list}.
\begin{codehigh}
-\TlConst \cFooSomeTl {abc}
+\tlConst \cFooSomeTl {abc}
\end{codehigh}
\end{function}
-\begin{function}{\TlUse}
+\begin{function}{\tlUse}
\begin{syntax}
-\cs{TlUse} \meta{tl~var}
+\cs{tlUse} \meta{tl~var}
\end{syntax}
Recovers the content of a \meta{tl~var} and returns the value.
An error is raised if the variable
@@ -1228,13 +1228,13 @@
does not exist or if it is invalid. Note that it is possible to use
a \meta{tl~var} directly without an accessor function.
\begin{codehigh}
-\TlUse \lTmpbTl
+\tlUse \lTmpbTl
\end{codehigh}
\end{function}
-\begin{function}{\TlToStr}
+\begin{function}{\tlToStr}
\begin{syntax}
-\cs{TlToStr} \Arg{token list}
+\cs{tlToStr} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string}, returning the
resulting character tokens. A \meta{string}
@@ -1241,7 +1241,7 @@
is a series of tokens with category code $12$ (other) with the exception
of spaces, which retain category code $10$ (space).
\begin{demohigh}
-\TlToStr {12\abc34}
+\tlToStr {12\abc34}
\end{demohigh}
%This function requires only a single expansion.
%Its argument \emph{must} be braced.
@@ -1274,9 +1274,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlVarToStr}
+\begin{function}{\tlVarToStr}
\begin{syntax}
-\cs{TlVarToStr} \meta{tl var}
+\cs{tlVarToStr} \meta{tl var}
\end{syntax}
Converts the content of the \meta{tl var} to a string, returning the
resulting character tokens. A \meta{string}
@@ -1283,43 +1283,43 @@
is a series of tokens with category code $12$ (other) with the exception
of spaces, which retain category code $10$ (space).
\begin{demohigh}
-\TlSet \lTmpaTl {12\abc34}
-\TlVarToStr \lTmpaTl
+\tlSet \lTmpaTl {12\abc34}
+\tlVarToStr \lTmpaTl
\end{demohigh}
\end{function}
\section{Viewing Token Lists}
-\begin{function}{\TlLog}
+\begin{function}{\tlLog}
\begin{syntax}
-\cs{TlLog} \Arg{token list}
+\cs{tlLog} \Arg{token list}
\end{syntax}
Writes the \meta{token list} in the log file. See also
-\cs{TlShow} which displays the result in the terminal.
+\cs{tlShow} which displays the result in the terminal.
\begin{codehigh}
-\TlLog {123\abc456}
+\tlLog {123\abc456}
\end{codehigh}
\end{function}
-\begin{function}{\TlVarLog}
+\begin{function}{\tlVarLog}
\begin{syntax}
-\cs{TlVarLog} \meta{tl var}
+\cs{tlVarLog} \meta{tl var}
\end{syntax}
Writes the content of the \meta{tl var} in the log file. See also
-\cs{TlVarShow} which displays the result in the terminal.
+\cs{tlVarShow} which displays the result in the terminal.
\begin{codehigh}
-\TlSet \lTmpaTl {123\abc456}
-\TlVarLog \lTmpaTl
+\tlSet \lTmpaTl {123\abc456}
+\tlVarLog \lTmpaTl
\end{codehigh}
\end{function}
-\begin{function}{\TlShow}
+\begin{function}{\tlShow}
\begin{syntax}
-\cs{TlShow} \Arg{token list}
+\cs{tlShow} \Arg{token list}
\end{syntax}
Displays the \meta{token list} on the terminal.
\begin{codehigh}
-\TlShow {123\abc456}
+\tlShow {123\abc456}
\end{codehigh}
%\begin{texnote}
%This is similar to the \eTeX{} primitive \tn{showtokens}, wrapped
@@ -1327,14 +1327,14 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlVarShow}
+\begin{function}{\tlVarShow}
\begin{syntax}
-\cs{TlVarShow} \meta{tl var}
+\cs{tlVarShow} \meta{tl var}
\end{syntax}
Displays the content of the \meta{tl var} on the terminal.
\begin{codehigh}
-\TlSet \lTmpaTl {123\abc456}
-\TlVarShow \lTmpaTl
+\tlSet \lTmpaTl {123\abc456}
+\tlVarShow \lTmpaTl
\end{codehigh}
%\begin{texnote}
%This is similar to the \TeX{} primitive \tn{show}, wrapped to a
@@ -1344,91 +1344,91 @@
\section{Setting Token List Variables}
-\begin{function}{\TlSet}
+\begin{function}{\tlSet}
\begin{syntax}
-\cs{TlSet} \meta{tl~var} \Arg{tokens}
+\cs{tlSet} \meta{tl~var} \Arg{tokens}
\end{syntax}
Sets \meta{tl~var} to contain \meta{tokens},
removing any previous content from the variable.
\begin{demohigh}
-\TlSet \lTmpiTl {\IntMathMult{4}{5}}
-\TlUse \lTmpiTl
+\tlSet \lTmpiTl {\intMathMult{4}{5}}
+\tlUse \lTmpiTl
\end{demohigh}
\end{function}
-\begin{function}{\TlSetEq}
+\begin{function}{\tlSetEq}
\begin{syntax}
-\cs{TlSetEq} \meta{tl var_1} \meta{tl var_2}
+\cs{tlSetEq} \meta{tl var_1} \meta{tl var_2}
\end{syntax}
Sets the content of \meta{tl var_1} equal to that of \meta{tl var_2}.
\begin{demohigh}
-\TlSet \lTmpaTl {abc}
-\TlSetEq \lTmpbTl \lTmpaTl
-\TlUse \lTmpbTl
+\tlSet \lTmpaTl {abc}
+\tlSetEq \lTmpbTl \lTmpaTl
+\tlUse \lTmpbTl
\end{demohigh}
\end{function}
-\begin{function}{\TlClear}
+\begin{function}{\tlClear}
\begin{syntax}
-\cs{TlClear} \meta{tl~var}
+\cs{tlClear} \meta{tl~var}
\end{syntax}
Clears all entries from the \meta{tl~var}.
\begin{demohigh}
-\TlSet \lTmpjTl {One}
-\TlClear \lTmpjTl
-\TlSet \lTmpjTl {Two}
-\TlUse \lTmpjTl
+\tlSet \lTmpjTl {One}
+\tlClear \lTmpjTl
+\tlSet \lTmpjTl {Two}
+\tlUse \lTmpjTl
\end{demohigh}
\end{function}
-\begin{function}{\TlClearNew}
+\begin{function}{\tlClearNew}
\begin{syntax}
-\cs{TlClearNew} \meta{tl var}
+\cs{tlClearNew} \meta{tl var}
\end{syntax}
Ensures that the \meta{tl var} exists globally by applying
-\cs{TlNew} if necessary, then applies \cs{TlClear} to leave
+\cs{tlNew} if necessary, then applies \cs{tlClear} to leave
the \meta{tl var} empty.
\begin{codehigh}
-\TlClearNew \lFooSomeTl
+\tlClearNew \lFooSomeTl
\end{codehigh}
\end{function}
-\begin{function}{\TlConcat}
+\begin{function}{\tlConcat}
\begin{syntax}
-\cs{TlConcat} \meta{tl var_1} \meta{tl var_2} \meta{tl var_3}
+\cs{tlConcat} \meta{tl var_1} \meta{tl var_2} \meta{tl var_3}
\end{syntax}
Concatenates the content of \meta{tl var_2} and \meta{tl var_3}
together and saves the result in \meta{tl var_1}. The \meta{tl var_2}
is placed at the left side of the new token list.
\begin{demohigh}
-\TlSet \lTmpbTl {con}
-\TlSet \lTmpcTl {cat}
-\TlConcat \lTmpaTl \lTmpbTl \lTmpcTl
-\TlUse \lTmpaTl
+\tlSet \lTmpbTl {con}
+\tlSet \lTmpcTl {cat}
+\tlConcat \lTmpaTl \lTmpbTl \lTmpcTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlPutLeft}
+\begin{function}{\tlPutLeft}
\begin{syntax}
-\cs{TlPutLeft} \meta{tl~var} \Arg{tokens}
+\cs{tlPutLeft} \meta{tl~var} \Arg{tokens}
\end{syntax}
Appends \meta{tokens} to the left side of the current content of \meta{tl~var}.
\begin{demohigh}
-\TlSet \lTmpkTl {Functional}
-\TlPutLeft \lTmpkTl {Hello}
-\TlUse \lTmpkTl
+\tlSet \lTmpkTl {Functional}
+\tlPutLeft \lTmpkTl {Hello}
+\tlUse \lTmpkTl
\end{demohigh}
\end{function}
-\begin{function}{\TlPutRight}
+\begin{function}{\tlPutRight}
\begin{syntax}
-\cs{TlPutRight} \meta{tl~var} \Arg{tokens}
+\cs{tlPutRight} \meta{tl~var} \Arg{tokens}
\end{syntax}
Appends \meta{tokens} to the right side of the current content of \meta{tl~var}.
\begin{demohigh}
-\TlSet \lTmpkTl {Functional}
-\TlPutRight \lTmpkTl {World}
-\TlUse \lTmpkTl
+\tlSet \lTmpkTl {Functional}
+\tlPutRight \lTmpkTl {World}
+\tlUse \lTmpkTl
\end{demohigh}
\end{function}
@@ -1438,9 +1438,9 @@
no recursion into brace groups (more precisely, within a group defined by
a categroy code $1$/$2$ pair).
-\begin{function}{\TlVarReplaceOnce}
+\begin{function}{\tlVarReplaceOnce}
\begin{syntax}
-\cs{TlVarReplaceOnce} \meta{tl var} \Arg{old tokens} \Arg{new tokens}
+\cs{tlVarReplaceOnce} \meta{tl var} \Arg{old tokens} \Arg{new tokens}
\end{syntax}
Replaces the first (leftmost) occurrence of \meta{old tokens} in the
\meta{tl var} with \meta{new tokens}. \meta{Old tokens}
@@ -1448,15 +1448,15 @@
(more precisely, explicit character tokens with category code $1$
(begin-group) or $2$ (end-group), and tokens with category code $6$).
\begin{demohigh}
-\TlSet \lTmpaTl {1{bc}2bc3}
-\TlVarReplaceOnce \lTmpaTl {bc} {xx}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {1{bc}2bc3}
+\tlVarReplaceOnce \lTmpaTl {bc} {xx}
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlVarReplaceAll}
+\begin{function}{\tlVarReplaceAll}
\begin{syntax}
-\cs{TlVarReplaceAll} \meta{tl var} \Arg{old tokens} \Arg{new tokens}
+\cs{tlVarReplaceAll} \meta{tl var} \Arg{old tokens} \Arg{new tokens}
\end{syntax}
Replaces all occurrences of \meta{old tokens} in the
\meta{tl var} with \meta{new tokens}. \meta{Old tokens}
@@ -1465,17 +1465,17 @@
(begin-group) or $2$ (end-group), and tokens with category code $6$).
As this function
operates from left to right, the pattern \meta{old tokens}
-may remain after the replacement (see \cs{TlVarRemoveAll} for an example).
+may remain after the replacement (see \cs{tlVarRemoveAll} for an example).
\begin{demohigh}
-\TlSet \lTmpaTl {1{bc}2bc3}
-\TlVarReplaceAll \lTmpaTl {bc} {xx}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {1{bc}2bc3}
+\tlVarReplaceAll \lTmpaTl {bc} {xx}
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlVarRemoveOnce}
+\begin{function}{\tlVarRemoveOnce}
\begin{syntax}
-\cs{TlVarRemoveOnce} \meta{tl var} \Arg{tokens}
+\cs{tlVarRemoveOnce} \meta{tl var} \Arg{tokens}
\end{syntax}
Removes the first (leftmost) occurrence of \meta{tokens} from the
\meta{tl var}. \meta{Tokens} cannot contain \verb|{|, \verb|}| or \verb|#|
@@ -1482,15 +1482,15 @@
(more precisely, explicit character tokens with category code $1$
(begin-group) or $2$ (end-group), and tokens with category code $6$).
\begin{demohigh}
-\TlSet \lTmpaTl {1{bc}2bc3}
-\TlVarRemoveOnce \lTmpaTl {bc}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {1{bc}2bc3}
+\tlVarRemoveOnce \lTmpaTl {bc}
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlVarRemoveAll}
+\begin{function}{\tlVarRemoveAll}
\begin{syntax}
-\cs{TlVarRemoveAll} \meta{tl var} \Arg{tokens}
+\cs{tlVarRemoveAll} \meta{tl var} \Arg{tokens}
\end{syntax}
Removes all occurrences of \meta{tokens} from the
\meta{tl var}. \meta{Tokens} cannot contain \verb|{|, \verb|}| or \verb|#|
@@ -1500,21 +1500,21 @@
operates from left to right, the pattern \meta{tokens}
may remain after the removal, for instance,
\begin{demohigh}
-\TlSet \lTmpaTl {abbccd}
-\TlVarRemoveAll \lTmpaTl {bc}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {abbccd}
+\tlVarRemoveAll \lTmpaTl {bc}
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlTrimSpaces}
+\begin{function}{\tlTrimSpaces}
\begin{syntax}
-\cs{TlTrimSpaces} \Arg{token list}
+\cs{tlTrimSpaces} \Arg{token list}
\end{syntax}
Removes any leading and trailing explicit space characters
(explicit tokens with character code $32$ and category code $10$)
from the \meta{token list} and returns the result.
\begin{demohigh}
-Foo\TlTrimSpaces { 12 34 }Bar
+Foo\tlTrimSpaces { 12 34 }Bar
\end{demohigh}
%\begin{texnote}
%The result is returned within \tn{unexpanded}, which means that the token
@@ -1523,52 +1523,52 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlVarTrimSpaces}
+\begin{function}{\tlVarTrimSpaces}
\begin{syntax}
-\cs{TlVarTrimSpaces} \meta{tl var}
+\cs{tlVarTrimSpaces} \meta{tl var}
\end{syntax}
Sets the \meta{tl var} to contain the result of removing any leading
and trailing explicit space characters (explicit tokens with
character code $32$ and category code $10$) from its contents.
\begin{demohigh}
-\TlSet \lTmpaTl { 12 34 }
-\TlVarTrimSpaces \lTmpaTl
-Foo\TlUse \lTmpaTl Bar
+\tlSet \lTmpaTl { 12 34 }
+\tlVarTrimSpaces \lTmpaTl
+Foo\tlUse \lTmpaTl Bar
\end{demohigh}
\end{function}
\section{Working with the Content of Token Lists}
-\begin{function}{\TlCount}
+\begin{function}{\tlCount}
\begin{syntax}
-\cs{TlCount} \Arg{tokens}
+\cs{tlCount} \Arg{tokens}
\end{syntax}
Counts the number of \meta{items} in \meta{tokens} and returns this information.
Unbraced tokens count as one element as do each token group (\verb|{|$\cdots$\verb|}|).
-This process ignores any unprotected spaces within \meta{tokens}. %See also \cs{TlVarCount}.
+This process ignores any unprotected spaces within \meta{tokens}. %See also \cs{tlVarCount}.
%This function requires three expansions, giving an \meta{integer denotation}.
\begin{demohigh}
-\TlCount {12\abc34}
+\tlCount {12\abc34}
\end{demohigh}
\end{function}
-\begin{function}{\TlVarCount}
+\begin{function}{\tlVarCount}
\begin{syntax}
-\cs{TlVarCount} \meta{tl var}
+\cs{tlVarCount} \meta{tl var}
\end{syntax}
Counts the number of \meta{items} in the \meta{tl var} and returns this information.
Unbraced tokens count as one element as do each token group (\verb|{|$\cdots$\verb|}|).
-This process ignores any unprotected spaces within the \meta{tl var}. %See also \cs{TlCount}.
+This process ignores any unprotected spaces within the \meta{tl var}. %See also \cs{tlCount}.
%This function requires three expansions, giving an \meta{integer denotation}.
\begin{demohigh}
-\TlSet \lTmpaTl {12\abc34}
-\TlVarCount \lTmpaTl
+\tlSet \lTmpaTl {12\abc34}
+\tlVarCount \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlHead}
+\begin{function}{\tlHead}
\begin{syntax}
-\cs{TlHead} \Arg{token list}
+\cs{tlHead} \Arg{token list}
\end{syntax}
Returns the first \meta{item} in the \meta{token list},
discarding the rest of the \meta{token list}.
@@ -1576,17 +1576,17 @@
(explicit tokens with character code $32$ and category code $10$)
are discarded; for example
\begin{demohigh}
-\fbox {1\TlHead{ abc }2}
-\fbox {1\TlHead{ abc }2}
+\fbox {1\tlHead{ abc }2}
+\fbox {1\tlHead{ abc }2}
\end{demohigh}
If the \enquote{head} is a brace group, rather than a single token,
the braces are removed, and so
\begin{codehigh}
-\TlHead { { ab} c }
+\tlHead { { ab} c }
\end{codehigh}
yields \verb*| ab|.
-A blank \meta{token list} (see \cs{TlIfBlank}) results in
-\cs{TlHead} returning nothing.
+A blank \meta{token list} (see \cs{tlIfBlank}) results in
+\cs{tlHead} returning nothing.
%\begin{texnote}
%The result is returned within \cs{exp_not:n}, which means that the token
%list does not expand further when appearing in an \texttt{x}-type
@@ -1594,9 +1594,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlVarHead}
+\begin{function}{\tlVarHead}
\begin{syntax}
-\cs{TlVarHead} \meta{tl var}
+\cs{tlVarHead} \meta{tl var}
\end{syntax}
Returns the first \meta{item} in the \meta{tl var},
discarding the rest of the \meta{tl var}.
@@ -1603,14 +1603,14 @@
All leading explicit space characters (explicit tokens with character code $32$
and category code $10$) are discarded.
\begin{demohigh}
-\TlSet \lTmpaTl {HELLO}
-\TlVarHead \lTmpaTl
+\tlSet \lTmpaTl {HELLO}
+\tlVarHead \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlTail}
+\begin{function}{\tlTail}
\begin{syntax}
-\cs{TlTail} \Arg{token list}
+\cs{tlTail} \Arg{token list}
\end{syntax}
Discards all leading explicit space characters
(explicit tokens with character code $32$ and category code $10$)
@@ -1617,14 +1617,14 @@
and the first \meta{item} in the \meta{token list}, and returns the
remaining tokens. Thus for example
\begin{codehigh}
-\TlTail { a {bc} d }
+\tlTail { a {bc} d }
\end{codehigh}
and
\begin{codehigh}
-\TlTail { a {bc} d }
+\tlTail { a {bc} d }
\end{codehigh}
-both return \verb*| {bc} d |. A blank \meta{token list} (see \cs{TlIfBlank})
-results in \cs{TlTail} returning nothing.
+both return \verb*| {bc} d |. A blank \meta{token list} (see \cs{tlIfBlank})
+results in \cs{tlTail} returning nothing.
%\begin{texnote}
%The result is returned within \cs{exp_not:n}, which means that the
%token list does not expand further when appearing in an \texttt{x}-type
@@ -1632,9 +1632,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlVarTail}
+\begin{function}{\tlVarTail}
\begin{syntax}
-\cs{TlVarTail} \meta{tl var}
+\cs{tlVarTail} \meta{tl var}
\end{syntax}
Discards all leading explicit space characters
(explicit tokens with character code $32$ and category code $10$)
@@ -1641,15 +1641,15 @@
and the first \meta{item} in the \meta{tl var}, and returns the
remaining tokens.
\begin{demohigh}
-\TlSet \lTmpaTl {HELLO}
-\TlVarTail \lTmpaTl
+\tlSet \lTmpaTl {HELLO}
+\tlVarTail \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\TlItem,\TlVarItem}
+\begin{function}{\tlItem,\tlVarItem}
\begin{syntax}
-\cs{TlItem} \Arg{token list} \Arg{integer expression}
-\cs{TlVarItem} \meta{tl var} \Arg{integer expression}
+\cs{tlItem} \Arg{token list} \Arg{integer expression}
+\cs{tlVarItem} \meta{tl var} \Arg{integer expression}
\end{syntax}
Indexing items in the \meta{token list} from $1$ on the left, this
function evaluates the \meta{integer expression} and returns the
@@ -1658,7 +1658,7 @@
the right of the token list, starting at $-1$ for the right-most item.
If the index is out of bounds, then the function returns nothing.
\begin{demohigh}
-\TlItem {abcd} {3}
+\tlItem {abcd} {3}
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -1668,17 +1668,17 @@
%\end{texnote}
\end{function}
-\begin{function}{\TlRandItem,\TlVarRandItem}
+\begin{function}{\tlRandItem,\tlVarRandItem}
\begin{syntax}
-\cs{TlRandItem} \Arg{token list}
-\cs{TlVarRandItem} \meta{tl var}
+\cs{tlRandItem} \Arg{token list}
+\cs{tlVarRandItem} \meta{tl var}
\end{syntax}
Selects and returns a pseudo-random item of the \meta{token list}.
If the \meta{token list} is blank, the result is empty.
%This is not available in older versions of \XeTeX{}.
\begin{demohigh}
-\TlRandItem {abcdef}
-\TlRandItem {abcdef}
+\tlRandItem {abcdef}
+\tlRandItem {abcdef}
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -1694,9 +1694,9 @@
local assignments made by the \meta{function} or \meta{code} discussed
below remain in effect after the loop.
-%\begin{function}{\TlMapFunction}
+%\begin{function}{\tlMapFunction}
%\begin{syntax}
-%\cs{TlMapFunction} \Arg{token list} \meta{function}
+%\cs{tlMapFunction} \Arg{token list} \meta{function}
%\end{syntax}
%Applies \meta{function} to every \meta{item} in the \meta{token list},
%The \meta{function} receives one argument for each iteration.
@@ -1705,9 +1705,9 @@
%\texttt{n}-type arguments.
%\end{function}
%
-%\begin{function}{\TlVarMapFunction}
+%\begin{function}{\tlVarMapFunction}
%\begin{syntax}
-%\cs{TlVarMapFunction} \meta{tl var} \meta{function}
+%\cs{tlVarMapFunction} \meta{tl var} \meta{function}
%\end{syntax}
%Applies \meta{function} to every \meta{item} in the \meta{tl var}.
%The \meta{function} receives one argument for each iteration.
@@ -1716,9 +1716,9 @@
%\texttt{n}-type arguments.
%\end{function}
-\begin{function}{\TlMapInline}
+\begin{function}{\tlMapInline}
\begin{syntax}
-\cs{TlMapInline} \Arg{token list} \Arg{inline function}
+\cs{tlMapInline} \Arg{token list} \Arg{inline function}
\end{syntax}
Applies the \meta{inline function} to every \meta{item} stored within the
\meta{token list}. The \meta{inline function} should consist of code which
@@ -1725,18 +1725,18 @@
receives the \meta{item} as \verb|#1|.
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\TlMapInline {one} {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\tlMapInline {one} {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\TlVarMapInline}
+\begin{function}{\tlVarMapInline}
\begin{syntax}
-\cs{TlVarMapInline} \meta{tl var} \Arg{inline function}
+\cs{tlVarMapInline} \meta{tl var} \Arg{inline function}
\end{syntax}
Applies the \meta{inline function} to every \meta{item} stored within the
\meta{tl var}. The \meta{inline function} should consist of code which
@@ -1743,20 +1743,20 @@
receives the \meta{item} as \verb|#1|.
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\TlSet \lTmpkTl {one}
-\TlVarMapInline \lTmpkTl {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\tlSet \lTmpkTl {one}
+\tlVarMapInline \lTmpkTl {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\TlMapTokens,\TlVarMapTokens}
+%\begin{function}{\tlMapTokens,\tlVarMapTokens}
%\begin{syntax}
-%\cs{TlMapTokens} \Arg{tokens} \Arg{code}
-%\cs{TlVarMapTokens} \meta{tl var} \Arg{code}
+%\cs{tlMapTokens} \Arg{tokens} \Arg{code}
+%\cs{tlVarMapTokens} \meta{tl var} \Arg{code}
%\end{syntax}
%Analogue of \cs{tl_map_function:NN} which maps several tokens
%instead of a single function. The \meta{code} receives each \meta{item} in
@@ -1771,9 +1771,9 @@
%\cs{tl_map_inline:Nn} is typically faster but is not expandable.
%\end{function}
-\begin{function}{\TlMapVariable}
+\begin{function}{\tlMapVariable}
\begin{syntax}
-\cs{TlMapVariable} \Arg{token list} \meta{variable} \Arg{code}
+\cs{tlMapVariable} \Arg{token list} \meta{variable} \Arg{code}
\end{syntax}
Stores each \meta{item} of the \meta{token list} in turn in the
(token list) \meta{variable} and applies the \meta{code}. The
@@ -1783,18 +1783,18 @@
\meta{tl var}, or its original value if the \meta{tl var} is blank.
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\TlMapVariable {one} \lTmpiTl {
- \TlPutRight \lTmpaTl {\Expand {[\lTmpiTl]}}
+\tlClear \lTmpaTl
+\tlMapVariable {one} \lTmpiTl {
+ \tlPutRight \lTmpaTl {\expWhole {[\lTmpiTl]}}
}
-\Return{\TlUse\lTmpaTl}
+\prgReturn{\tlUse\lTmpaTl}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\TlVarMapVariable}
+\begin{function}{\tlVarMapVariable}
\begin{syntax}
-\cs{TlVarMapVariable} \meta{tl var} \meta{variable} \Arg{code}
+\cs{tlVarMapVariable} \meta{tl var} \meta{variable} \Arg{code}
\end{syntax}
Stores each \meta{item} of the \meta{tl var} in turn in the (token
list) \meta{variable} and applies the \meta{code}. The \meta{code}
@@ -1804,19 +1804,19 @@
or its original value if the \meta{tl var} is blank.
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\TlSet \lTmpkTl {one}
-\TlVarMapVariable \lTmpkTl \lTmpiTl {
- \TlPutRight \lTmpaTl {\Expand {[\lTmpiTl]}}
+\tlClear \lTmpaTl
+\tlSet \lTmpkTl {one}
+\tlVarMapVariable \lTmpkTl \lTmpiTl {
+ \tlPutRight \lTmpaTl {\expWhole {[\lTmpiTl]}}
}
-\Return{\TlUse\lTmpaTl}
+\prgReturn{\tlUse\lTmpaTl}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\TlMapBreak}
+%\begin{function}{\tlMapBreak}
%\begin{syntax}
-%\cs{TlMapBreak}
+%\cs{tlMapBreak}
%\end{syntax}
%Used to terminate a tl map function before all
%entries in the \meta{token list variable} have been processed. This
@@ -1839,9 +1839,9 @@
%\end{texnote}
%\end{function}
%
-%\begin{function}{\TlMapBreakDo}
+%\begin{function}{\tlMapBreakDo}
%\begin{syntax}
-%\cs{TlMapBreakDo} \Arg{code}
+%\cs{tlMapBreakDo} \Arg{code}
%\end{syntax}
%Used to terminate a tl map function before all
%entries in the \meta{token list variable} have been processed, inserting
@@ -1867,59 +1867,59 @@
\section{Token List Conditionals}
-\begin{function}{\TlIfExist,\TlIfExistT,\TlIfExistF,\TlIfExistTF}
+\begin{function}{\tlIfExist,\tlIfExistT,\tlIfExistF,\tlIfExistTF}
\begin{syntax}
-\cs{TlIfExist} \meta{tl var}
-\cs{TlIfExistT} \meta{tl var} \Arg{true code}
-\cs{TlIfExistF} \meta{tl var} \Arg{false code}
-\cs{TlIfExistTF} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{tlIfExist} \meta{tl var}
+\cs{tlIfExistT} \meta{tl var} \Arg{true code}
+\cs{tlIfExistF} \meta{tl var} \Arg{false code}
+\cs{tlIfExistTF} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{tl var} is currently defined. This does not
check that the \meta{tl var} really is a token list variable.
\begin{demohigh}
-\TlIfExistTF \lTmpaTl {\Return{Yes}} {\Return{No}}
-\TlIfExistTF \lFooUndefinedTl {\Return{Yes}} {\Return{No}}
+\tlIfExistTF \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
+\tlIfExistTF \lFooUndefinedTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\TlIfEmpty,\TlIfEmptyT,\TlIfEmptyF,\TlIfEmptyTF}
+\begin{function}{\tlIfEmpty,\tlIfEmptyT,\tlIfEmptyF,\tlIfEmptyTF}
\begin{syntax}
-\cs{TlIfEmpty} \Arg{token list}
-\cs{TlIfEmptyT} \Arg{token list} \Arg{true code}
-\cs{TlIfEmptyF} \Arg{token list} \Arg{false code}
-\cs{TlIfEmptyTF} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{tlIfEmpty} \Arg{token list}
+\cs{tlIfEmptyT} \Arg{token list} \Arg{true code}
+\cs{tlIfEmptyF} \Arg{token list} \Arg{false code}
+\cs{tlIfEmptyTF} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token list} is entirely empty
(\emph{i.e.}~contains no tokens at all). For example
\begin{demohigh}
-\TlIfEmptyTF {abc} {\Return{Empty}} {\Return{NonEmpty}}
-\TlIfEmptyTF {} {\Return{Empty}} {\Return{NonEmpty}}
+\tlIfEmptyTF {abc} {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\tlIfEmptyTF {} {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\TlVarIfEmpty,\TlVarIfEmptyT,\TlVarIfEmptyF,\TlVarIfEmptyTF}
+\begin{function}{\tlVarIfEmpty,\tlVarIfEmptyT,\tlVarIfEmptyF,\tlVarIfEmptyTF}
\begin{syntax}
-\cs{TlVarIfEmpty} \meta{tl~var}
-\cs{TlVarIfEmptyT} \meta{tl~var} \Arg{true code}
-\cs{TlVarIfEmptyF} \meta{tl~var} \Arg{false code}
-\cs{TlVarIfEmptyTF} \meta{tl~var} \Arg{true code} \Arg{false code}
+\cs{tlVarIfEmpty} \meta{tl~var}
+\cs{tlVarIfEmptyT} \meta{tl~var} \Arg{true code}
+\cs{tlVarIfEmptyF} \meta{tl~var} \Arg{false code}
+\cs{tlVarIfEmptyTF} \meta{tl~var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token list variable} is entirely empty
(\emph{i.e.}~contains no tokens at all). For example
\begin{demohigh}
-\TlSet \lTmpaTl {abc}
-\TlVarIfEmptyTF \lTmpaTl {\Return{Empty}} {\Return{NonEmpty}}
-\TlClear \lTmpaTl
-\TlVarIfEmptyTF \lTmpaTl {\Return{Empty}} {\Return{NonEmpty}}
+\tlSet \lTmpaTl {abc}
+\tlVarIfEmptyTF \lTmpaTl {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\tlClear \lTmpaTl
+\tlVarIfEmptyTF \lTmpaTl {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\TlIfBlank,\TlIfBlankT,\TlIfBlankF,\TlIfBlankTF}
+\begin{function}{\tlIfBlank,\tlIfBlankT,\tlIfBlankF,\tlIfBlankTF}
\begin{syntax}
-\cs{TlIfBlank} \Arg{token list}
-\cs{TlIfBlankT} \Arg{token list} \Arg{true code}
-\cs{TlIfBlankF} \Arg{token list} \Arg{false code}
-\cs{TlIfBlankTF} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{tlIfBlank} \Arg{token list}
+\cs{tlIfBlankT} \Arg{token list} \Arg{true code}
+\cs{tlIfBlankF} \Arg{token list} \Arg{false code}
+\cs{tlIfBlankTF} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token list} consists only of blank spaces
(\emph{i.e.} contains no item). The test is \texttt{true} if
@@ -1927,41 +1927,41 @@
(explicit tokens with character code $32$ and category code $10$),
and is \texttt{false} otherwise.
\begin{demohigh}
-\TlIfEmptyTF { } {\Return{Yes}} {\Return{No}}
-\TlIfBlankTF { } {\Return{Yes}} {\Return{No}}
+\tlIfEmptyTF { } {\prgReturn{Yes}} {\prgReturn{No}}
+\tlIfBlankTF { } {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\TlIfEq,\TlIfEqT,\TlIfEqF,\TlIfEqTF}
+\begin{function}{\tlIfEq,\tlIfEqT,\tlIfEqF,\tlIfEqTF}
\begin{syntax}
-\cs{TlIfEq} \Arg{token list_1} \Arg{token list_2}
-\cs{TlIfEqT} \Arg{token list_1} \Arg{token list_2} \Arg{true code}
-\cs{TlIfEqF} \Arg{token list_1} \Arg{token list_2} \Arg{false code}
-\cs{TlIfEqTF} \Arg{token list_1} \Arg{token list_2} \Arg{true code} \Arg{false code}
+\cs{tlIfEq} \Arg{token list_1} \Arg{token list_2}
+\cs{tlIfEqT} \Arg{token list_1} \Arg{token list_2} \Arg{true code}
+\cs{tlIfEqF} \Arg{token list_1} \Arg{token list_2} \Arg{false code}
+\cs{tlIfEqTF} \Arg{token list_1} \Arg{token list_2} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if \meta{token list_1} and \meta{token list_2} contain the
same list of tokens, both in respect of character codes and category
-codes. See \cs{StrIfEq} if category codes are not important.
+codes. See \cs{strIfEq} if category codes are not important.
For example
\begin{demohigh}
-\TlIfEqTF {abc} {abc} {\Return{Yes}} {\Return{No}}
-\TlIfEqTF {abc} {xyz} {\Return{Yes}} {\Return{No}}
+\tlIfEqTF {abc} {abc} {\prgReturn{Yes}} {\prgReturn{No}}
+\tlIfEqTF {abc} {xyz} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
%\begin{demohigh}
-%\TlSet\lTmpaTl{abc}
-%\TlSet\lTmpbTl{abc}
-%\TlSet\lTmpcTl{xyz}
-%\TlIfEqTF{\TlUse\lTmpaTl}{\TlUse\lTmpbTl}{\Return{Yes}}{\Return{No}}
-%\TlIfEqTF{\TlUse\lTmpaTl}{\TlUse\lTmpcTl}{\Return{Yes}}{\Return{No}}
+%\tlSet\lTmpaTl{abc}
+%\tlSet\lTmpbTl{abc}
+%\tlSet\lTmpcTl{xyz}
+%\tlIfEqTF{\tlUse\lTmpaTl}{\tlUse\lTmpbTl}{\prgReturn{Yes}}{\prgReturn{No}}
+%\tlIfEqTF{\tlUse\lTmpaTl}{\tlUse\lTmpcTl}{\prgReturn{Yes}}{\prgReturn{No}}
%\end{demohigh}
\end{function}
-\begin{function}{\TlVarIfEq,\TlVarIfEqT,\TlVarIfEqF,\TlVarIfEqTF}
+\begin{function}{\tlVarIfEq,\tlVarIfEqT,\tlVarIfEqF,\tlVarIfEqTF}
\begin{syntax}
-\cs{TlVarIfEq} \meta{tl var_1} \meta{tl var_2}
-\cs{TlVarIfEqT} \meta{tl var_1} \meta{tl var_2} \Arg{true code}
-\cs{TlVarIfEqF} \meta{tl var_1} \meta{tl var_2} \Arg{false code}
-\cs{TlVarIfEqTF} \meta{tl var_1} \meta{tl var_2} \Arg{true code} \Arg{false code}
+\cs{tlVarIfEq} \meta{tl var_1} \meta{tl var_2}
+\cs{tlVarIfEqT} \meta{tl var_1} \meta{tl var_2} \Arg{true code}
+\cs{tlVarIfEqF} \meta{tl var_1} \meta{tl var_2} \Arg{false code}
+\cs{tlVarIfEqTF} \meta{tl var_1} \meta{tl var_2} \Arg{true code} \Arg{false code}
\end{syntax}
Compares the content of two \meta{token list variables} and
is logically \texttt{true} if the two contain the same list of
@@ -1968,21 +1968,21 @@
tokens (\emph{i.e.}~identical in both the list of characters they
contain and the category codes of those characters). For example
\begin{demohigh}
-\TlSet \lTmpaTl {abc}
-\TlSet \lTmpbTl {abc}
-\TlSet \lTmpcTl {xyz}
-\TlVarIfEqTF \lTmpaTl \lTmpbTl {\Return{Yes}} {\Return{No}}
-\TlVarIfEqTF \lTmpaTl \lTmpcTl {\Return{Yes}} {\Return{No}}
+\tlSet \lTmpaTl {abc}
+\tlSet \lTmpbTl {abc}
+\tlSet \lTmpcTl {xyz}
+\tlVarIfEqTF \lTmpaTl \lTmpbTl {\prgReturn{Yes}} {\prgReturn{No}}
+\tlVarIfEqTF \lTmpaTl \lTmpcTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
-See also \cs{StrVarIfEq} for a comparison that ignores category codes.
+See also \cs{strVarIfEq} for a comparison that ignores category codes.
\end{function}
-\begin{function}{\TlIfIn,\TlIfInT,\TlIfInF,\TlIfInTF}
+\begin{function}{\tlIfIn,\tlIfInT,\tlIfInF,\tlIfInTF}
\begin{syntax}
-\cs{TlIfIn} \Arg{token list_1} \Arg{token list_2}
-\cs{TlIfInT} \Arg{token list_1} \Arg{token list_2} \Arg{true code}
-\cs{TlIfInF} \Arg{token list_1} \Arg{token list_2} \Arg{false code}
-\cs{TlIfInTF} \Arg{token list_1} \Arg{token list_2} \Arg{true code} \Arg{false code}
+\cs{tlIfIn} \Arg{token list_1} \Arg{token list_2}
+\cs{tlIfInT} \Arg{token list_1} \Arg{token list_2} \Arg{true code}
+\cs{tlIfInF} \Arg{token list_1} \Arg{token list_2} \Arg{false code}
+\cs{tlIfInTF} \Arg{token list_1} \Arg{token list_2} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if \meta{token list_2} is found inside \meta{token list_1}.
The \meta{token list_2} cannot contain the tokens \verb|{|, \verb|}| or \verb|#|
@@ -1990,17 +1990,17 @@
(begin-group) or $2$ (end-group), and tokens with category code $6$).
The search does \emph{not} enter brace (category code $1$/$2$) groups.
\begin{demohigh}
-\TlIfInTF {hello world} {o} {\Return{Yes}} {\Return{No}}
-\TlIfInTF {hello world} {a} {\Return{Yes}} {\Return{No}}
+\tlIfInTF {hello world} {o} {\prgReturn{Yes}} {\prgReturn{No}}
+\tlIfInTF {hello world} {a} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\TlVarIfIn,\TlVarIfInT,\TlVarIfInF,\TlVarIfInTF}
+\begin{function}{\tlVarIfIn,\tlVarIfInT,\tlVarIfInF,\tlVarIfInTF}
\begin{syntax}
-\cs{TlVarIfIn} \meta{tl var} \Arg{token list}
-\cs{TlVarIfInT} \meta{tl var} \Arg{token list} \Arg{true code}
-\cs{TlVarIfInF} \meta{tl var} \Arg{token list} \Arg{false code}
-\cs{TlVarIfInTF} \meta{tl var} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{tlVarIfIn} \meta{tl var} \Arg{token list}
+\cs{tlVarIfInT} \meta{tl var} \Arg{token list} \Arg{true code}
+\cs{tlVarIfInF} \meta{tl var} \Arg{token list} \Arg{false code}
+\cs{tlVarIfInTF} \meta{tl var} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token list} is found in the content of the
\meta{tl var}. The \meta{token list} cannot contain
@@ -2008,55 +2008,55 @@
(more precisely, explicit character tokens with category code $1$
(begin-group) or $2$ (end-group), and tokens with category code $6$).
\begin{demohigh}
-\TlSet \lTmpaTl {hello world}
-\TlVarIfInTF \lTmpaTl {o} {\Return{Yes}} {\Return{No}}
-\TlVarIfInTF \lTmpaTl {a} {\Return{Yes}} {\Return{No}}
+\tlSet \lTmpaTl {hello world}
+\tlVarIfInTF \lTmpaTl {o} {\prgReturn{Yes}} {\prgReturn{No}}
+\tlVarIfInTF \lTmpaTl {a} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\TlIfSingle,\TlIfSingleT,\TlIfSingleF,\TlIfSingleTF}
+\begin{function}{\tlIfSingle,\tlIfSingleT,\tlIfSingleF,\tlIfSingleTF}
\begin{syntax}
-\cs{TlIfSingle} \Arg{token list}
-\cs{TlIfSingleT} \Arg{token list} \Arg{true code}
-\cs{TlIfSingleF} \Arg{token list} \Arg{false code}
-\cs{TlIfSingleTF} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{tlIfSingle} \Arg{token list}
+\cs{tlIfSingleT} \Arg{token list} \Arg{true code}
+\cs{tlIfSingleF} \Arg{token list} \Arg{false code}
+\cs{tlIfSingleTF} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token list} has exactly one \meta{item}, \emph{i.e.} is
a single normal token (neither an explicit space character nor a
begin-group character) or a single brace group, surrounded by
optional spaces on both sides. In other words, such a token list has
-token count $1$ according to \cs{TlCount}.
+token count $1$ according to \cs{tlCount}.
\begin{demohigh}
-\TlIfSingleTF {a} {\Return{Yes}} {\Return{No}}
-\TlIfSingleTF {abc} {\Return{Yes}} {\Return{No}}
+\tlIfSingleTF {a} {\prgReturn{Yes}} {\prgReturn{No}}
+\tlIfSingleTF {abc} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\TlVarIfSingle,\TlVarIfSingleT,\TlVarIfSingleF,\TlVarIfSingleTF}
+\begin{function}{\tlVarIfSingle,\tlVarIfSingleT,\tlVarIfSingleF,\tlVarIfSingleTF}
\begin{syntax}
-\cs{TlVarIfSingle} \meta{tl var}
-\cs{TlVarIfSingleT} \meta{tl var} \Arg{true code}
-\cs{TlVarIfSingleF} \meta{tl var} \Arg{false code}
-\cs{TlVarIfSingleTF} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{tlVarIfSingle} \meta{tl var}
+\cs{tlVarIfSingleT} \meta{tl var} \Arg{true code}
+\cs{tlVarIfSingleF} \meta{tl var} \Arg{false code}
+\cs{tlVarIfSingleTF} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the content of the \meta{tl var} consists of a single \meta{item},
\emph{i.e.} is a single normal token (neither an explicit space
character nor a begin-group character) or a single brace group,
surrounded by optional spaces on both sides. In other words, such a
-token list has token count $1$ according to \cs{TlVarCount}.
+token list has token count $1$ according to \cs{tlVarCount}.
\begin{demohigh}
-\TlSet \lTmpaTl {a}
-\TlVarIfSingleTF \lTmpaTl {\Return{Yes}} {\Return{No}}
-\TlSet \lTmpaTl {abc}
-\TlVarIfSingleTF \lTmpaTl {\Return{Yes}} {\Return{No}}
+\tlSet \lTmpaTl {a}
+\tlVarIfSingleTF \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
+\tlSet \lTmpaTl {abc}
+\tlVarIfSingleTF \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
\section{Token List Case Functions}
-\begin{function}{\TlVarCase}
+\begin{function}{\tlVarCase}
\begin{syntax}
-\cs{TlVarCase} \meta{test token list variable}
+\cs{tlVarCase} \meta{test token list variable}
~ ~ \verb"{"
~ ~ ~ ~ \meta{token list variable case_1} \Arg{code case_1}
~ ~ ~ ~ \meta{token list variable case_2} \Arg{code case_2}
@@ -2066,28 +2066,28 @@
\end{syntax}
This function compares the \meta{test token list variable} in turn
with each of the \meta{token list variable cases}. If the two
-are equal (as described for \cs{TlVarIfEq})
+are equal (as described for \cs{tlVarIfEq})
then the associated \meta{code} is left in the input
stream and other cases are discarded. The function
does nothing if there is no match.
\begin{demohigh}
\IgnoreSpacesOn
-\TlSet \lTmpaTl {a}
-\TlSet \lTmpbTl {b}
-\TlSet \lTmpcTl {c}
-\TlSet \lTmpkTl {b}
-\TlVarCase \lTmpkTl {
- \lTmpaTl {\Return {First}}
- \lTmpbTl {\Return {Second}}
- \lTmpcTl {\Return {Third}}
+\tlSet \lTmpaTl {a}
+\tlSet \lTmpbTl {b}
+\tlSet \lTmpcTl {c}
+\tlSet \lTmpkTl {b}
+\tlVarCase \lTmpkTl {
+ \lTmpaTl {\prgReturn {First}}
+ \lTmpbTl {\prgReturn {Second}}
+ \lTmpcTl {\prgReturn {Third}}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\TlVarCaseT}
+\begin{function}{\tlVarCaseT}
\begin{syntax}
-\cs{TlVarCaseT} \meta{test token list variable}
+\cs{tlVarCaseT} \meta{test token list variable}
~ ~ \verb"{"
~ ~ ~ ~ \meta{token list variable case_1} \Arg{code case_1}
~ ~ ~ ~ \meta{token list variable case_2} \Arg{code case_2}
@@ -2098,7 +2098,7 @@
\end{syntax}
This function compares the \meta{test token list variable} in turn
with each of the \meta{token list variable cases}. If the two
-are equal (as described for \cs{TlVarIfEq})
+are equal (as described for \cs{tlVarIfEq})
then the associated \meta{code} is left in the input
stream and other cases are discarded. If any of the
cases are matched, the \meta{true code} is also inserted into the
@@ -2105,24 +2105,24 @@
input stream (after the code for the appropriate case).
\begin{demohigh}
\IgnoreSpacesOn
-\TlSet \lTmpaTl {a}
-\TlSet \lTmpbTl {b}
-\TlSet \lTmpcTl {c}
-\TlSet \lTmpkTl {b}
-\TlVarCaseT \lTmpkTl {
- \lTmpaTl {\IntSet \lTmpkInt {1}}
- \lTmpbTl {\IntSet \lTmpkInt {2}}
- \lTmpcTl {\IntSet \lTmpkInt {3}}
+\tlSet \lTmpaTl {a}
+\tlSet \lTmpbTl {b}
+\tlSet \lTmpcTl {c}
+\tlSet \lTmpkTl {b}
+\tlVarCaseT \lTmpkTl {
+ \lTmpaTl {\intSet \lTmpkInt {1}}
+ \lTmpbTl {\intSet \lTmpkInt {2}}
+ \lTmpcTl {\intSet \lTmpkInt {3}}
}{
- \Return {\IntUse \lTmpkInt}
+ \prgReturn {\intUse \lTmpkInt}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\TlVarCaseF}
+\begin{function}{\tlVarCaseF}
\begin{syntax}
-\cs{TlVarCaseF} \meta{test token list variable}
+\cs{tlVarCaseF} \meta{test token list variable}
~ ~ \verb"{"
~ ~ ~ ~ \meta{token list variable case_1} \Arg{code case_1}
~ ~ ~ ~ \meta{token list variable case_2} \Arg{code case_2}
@@ -2133,30 +2133,30 @@
\end{syntax}
This function compares the \meta{test token list variable} in turn
with each of the \meta{token list variable cases}. If the two
-are equal (as described for \cs{TlVarIfEq})
+are equal (as described for \cs{tlVarIfEq})
then the associated \meta{code} is left in the input
stream and other cases are discarded. If none match then the \meta{false code}
is inserted into the input stream (after the code for the appropriate case).
\begin{demohigh}
\IgnoreSpacesOn
-\TlSet \lTmpaTl {a}
-\TlSet \lTmpbTl {b}
-\TlSet \lTmpcTl {c}
-\TlSet \lTmpkTl {b}
-\TlVarCaseF \lTmpkTl{
- \lTmpaTl {\Return {First}}
- \lTmpbTl {\Return {Second}}
- \lTmpcTl {\Return {Third}}
+\tlSet \lTmpaTl {a}
+\tlSet \lTmpbTl {b}
+\tlSet \lTmpcTl {c}
+\tlSet \lTmpkTl {b}
+\tlVarCaseF \lTmpkTl{
+ \lTmpaTl {\prgReturn {First}}
+ \lTmpbTl {\prgReturn {Second}}
+ \lTmpcTl {\prgReturn {Third}}
}{
- \Return {No~Match!}
+ \prgReturn {No~Match!}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\TlVarCaseTF}
+\begin{function}{\tlVarCaseTF}
\begin{syntax}
-\cs{TlVarCaseTF} \meta{test token list variable}
+\cs{tlVarCaseTF} \meta{test token list variable}
~ ~ \verb"{"
~ ~ ~ ~ \meta{token list variable case_1} \Arg{code case_1}
~ ~ ~ ~ \meta{token list variable case_2} \Arg{code case_2}
@@ -2168,27 +2168,27 @@
\end{syntax}
This function compares the \meta{test token list variable} in turn
with each of the \meta{token list variable cases}. If the two
-are equal (as described for \cs{TlVarIfEq})
+are equal (as described for \cs{tlVarIfEq})
then the associated \meta{code} is left in the input
stream and other cases are discarded. If any of the
cases are matched, the \meta{true code} is also inserted into the
input stream (after the code for the appropriate case), while if none
-match then the \meta{false code} is inserted. The function \cs{TlVarCase},
+match then the \meta{false code} is inserted. The function \cs{tlVarCase},
which does nothing if there is no match, is also available.
\begin{demohigh}
\IgnoreSpacesOn
-\TlSet \lTmpaTl {a}
-\TlSet \lTmpbTl {b}
-\TlSet \lTmpcTl {c}
-\TlSet \lTmpkTl {b}
-\TlVarCaseTF \lTmpkTl {
- \lTmpaTl {\IntSet \lTmpkInt {1}}
- \lTmpbTl {\IntSet \lTmpkInt {2}}
- \lTmpcTl {\IntSet \lTmpkInt {3}}
+\tlSet \lTmpaTl {a}
+\tlSet \lTmpbTl {b}
+\tlSet \lTmpcTl {c}
+\tlSet \lTmpkTl {b}
+\tlVarCaseTF \lTmpkTl {
+ \lTmpaTl {\intSet \lTmpkInt {1}}
+ \lTmpbTl {\intSet \lTmpkInt {2}}
+ \lTmpcTl {\intSet \lTmpkInt {3}}
}{
- \Return {\IntUse \lTmpkInt}
+ \prgReturn {\intUse \lTmpkInt}
}{
- \Return {0}
+ \prgReturn {0}
}
\IgnoreSpacesOff
\end{demohigh}
@@ -2214,7 +2214,7 @@
should contain characters with category code $12$ (other), except
spaces, which have category code $10$ (blank space). All the
functions in this module which accept a token list argument first
-convert it to a string using \cs{TlToStr} for internal processing,
+convert it to a string using \cs{tlToStr} for internal processing,
and do not treat a token list or the corresponding string
representation differently.
@@ -2225,7 +2225,7 @@
This data type simplifies comparison of variables since there are no concerns
about expansion of their contents.
-%The functions \cs{CsToStr}, \cs{TlToStr}, \cs{TlVarToStr} and
+%The functions \cs{CsToStr}, \cs{tlToStr}, \cs{tlVarToStr} and
%\cs{TokenToStr} (and variants) generate strings from the appropriate
%input: these are documented in modules \pkg{Cs}, \pkg{Tl} and \pkg{Token},
%respectively.
@@ -2253,33 +2253,33 @@
\section{Creating and Using Strings}
-\begin{function}{\StrNew}
+\begin{function}{\strNew}
\begin{syntax}
-\cs{StrNew} \meta{str var}
+\cs{strNew} \meta{str var}
\end{syntax}
Creates a new \meta{str var} or raises an error if the name is
already taken. The declaration is global. The \meta{str var} is
initially empty.
\begin{codehigh}
-\StrNew \lFooSomeStr
+\strNew \lFooSomeStr
\end{codehigh}
\end{function}
-\begin{function}{\StrConst}
+\begin{function}{\strConst}
\begin{syntax}
-\cs{StrConst} \meta{str var} \Arg{token list}
+\cs{strConst} \meta{str var} \Arg{token list}
\end{syntax}
Creates a new constant \meta{str var} or raises an error if the name
is already taken. The value of the \meta{str var} is set
globally to the \meta{token list}, converted to a string.
\begin{codehigh}
-\StrConst \cFooSomeStr {12\abc34}
+\strConst \cFooSomeStr {12\abc34}
\end{codehigh}
\end{function}
-\begin{function}{\StrUse}
+\begin{function}{\strUse}
\begin{syntax}
-\cs{StrUse} \meta{str var}
+\cs{strUse} \meta{str var}
\end{syntax}
Recovers the content of a \meta{str var} and returns the value.
An error is raised if the variable
@@ -2286,109 +2286,109 @@
does not exist or if it is invalid. Note that it is possible to use
a \meta{str} directly without an accessor function.
\begin{codehigh}
-\StrUse \lTmpaStr
+\strUse \lTmpaStr
\end{codehigh}
\end{function}
\section{Viewing Strings}
-\begin{function}{\StrLog}
+\begin{function}{\strLog}
\begin{syntax}
-\cs{StrLog} \Arg{token list}
+\cs{strLog} \Arg{token list}
\end{syntax}
Writes \meta{token list} in the log file.
\begin{codehigh}
-\StrLog {1234\abcd5678}
+\strLog {1234\abcd5678}
\end{codehigh}
\end{function}
-\begin{function}{\StrVarLog}
+\begin{function}{\strVarLog}
\begin{syntax}
-\cs{StrVarLog} \meta{str var}
+\cs{strVarLog} \meta{str var}
\end{syntax}
Writes the content of the \meta{str var} in the log file.
\begin{codehigh}
-\StrSet \lTmpiStr {1234\abcd5678}
-\StrVarLog \lTmpiStr
+\strSet \lTmpiStr {1234\abcd5678}
+\strVarLog \lTmpiStr
\end{codehigh}
\end{function}
-\begin{function}{\StrShow}
+\begin{function}{\strShow}
\begin{syntax}
-\cs{StrShow} \Arg{token list}
+\cs{strShow} \Arg{token list}
\end{syntax}
Displays \meta{token list} on the terminal.
\begin{codehigh}
-\StrShow {1234\abcd5678}
+\strShow {1234\abcd5678}
\end{codehigh}
\end{function}
-\begin{function}{\StrVarShow}
+\begin{function}{\strVarShow}
\begin{syntax}
-\cs{StrVarShow} \meta{str var}
+\cs{strVarShow} \meta{str var}
\end{syntax}
Displays the content of the \meta{str var} on the terminal.
\begin{codehigh}
-\StrSet \lTmpiStr {1234\abcd5678}
-\StrVarShow \lTmpiStr
+\strSet \lTmpiStr {1234\abcd5678}
+\strVarShow \lTmpiStr
\end{codehigh}
\end{function}
\section{Setting String Variables}
-\begin{function}{\StrSet}
+\begin{function}{\strSet}
\begin{syntax}
-\cs{StrSet} \meta{str var} \Arg{token list}
+\cs{strSet} \meta{str var} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string}, and stores the
result in \meta{str var}.
\begin{demohigh}
-\StrSet \lTmpiStr {\IntMathMult{4}{5}}
-\StrUse \lTmpiStr
+\strSet \lTmpiStr {\intMathMult{4}{5}}
+\strUse \lTmpiStr
\end{demohigh}
\end{function}
-\begin{function}{\StrSetEq}
+\begin{function}{\strSetEq}
\begin{syntax}
-\cs{StrSetEq} \meta{str var_1} \meta{str var_2}
+\cs{strSetEq} \meta{str var_1} \meta{str var_2}
\end{syntax}
Sets the content of \meta{str var_1} equal to that of \meta{str var_2}.
\begin{demohigh}
-\StrSet \lTmpaStr {abc}
-\StrSetEq \lTmpbStr \lTmpaStr
-\StrUse \lTmpbStr
+\strSet \lTmpaStr {abc}
+\strSetEq \lTmpbStr \lTmpaStr
+\strUse \lTmpbStr
\end{demohigh}
\end{function}
-\begin{function}{\StrClear}
+\begin{function}{\strClear}
\begin{syntax}
-\cs{StrClear} \meta{str var}
+\cs{strClear} \meta{str var}
\end{syntax}
Clears the content of the \meta{str var}. For example
\begin{demohigh}
-\StrSet \lTmpjStr {One}
-\StrClear \lTmpjStr
-\StrSet \lTmpjStr {Two}
-\StrUse \lTmpjStr
+\strSet \lTmpjStr {One}
+\strClear \lTmpjStr
+\strSet \lTmpjStr {Two}
+\strUse \lTmpjStr
\end{demohigh}
\end{function}
-\begin{function}{\StrClearNew}
+\begin{function}{\strClearNew}
\begin{syntax}
-\cs{StrClearNew} \meta{str var}
+\cs{strClearNew} \meta{str var}
\end{syntax}
Ensures that the \meta{str var} exists globally by applying
-\cs{StrNew} if necessary, then applies \cs{StrClear} to leave
+\cs{strNew} if necessary, then applies \cs{strClear} to leave
the \meta{str var} empty.
\begin{codehigh}
-\StrClearNew \lFooSomeStr
-\StrUse \lFooSomeStr
+\strClearNew \lFooSomeStr
+\strUse \lFooSomeStr
\end{codehigh}
\end{function}
-\begin{function}{\StrConcat}
+\begin{function}{\strConcat}
\begin{syntax}
-\cs{StrConcat} \meta{str var_1} \meta{str var_2} \meta{str var_3}
+\cs{strConcat} \meta{str var_1} \meta{str var_2} \meta{str var_3}
\end{syntax}
Concatenates the content of \meta{str var_2} and \meta{str var_3}
together and saves the result in \meta{str var_1}. The \meta{str var_2}
@@ -2396,60 +2396,60 @@
The \meta{str var_2} and \meta{str var_3} must indeed be strings, as
this function does not convert their contents to a string.
\begin{demohigh}
-\StrSet \lTmpbStr {con}
-\StrSet \lTmpcStr {cat}
-\StrConcat \lTmpaStr \lTmpbStr \lTmpcStr
-\StrUse \lTmpaStr
+\strSet \lTmpbStr {con}
+\strSet \lTmpcStr {cat}
+\strConcat \lTmpaStr \lTmpbStr \lTmpcStr
+\strUse \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrPutLeft}
+\begin{function}{\strPutLeft}
\begin{syntax}
-\cs{StrPutLeft} \meta{str var} \Arg{token list}
+\cs{strPutLeft} \meta{str var} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string}, and prepends the
result to \meta{str var}. The current contents of the \meta{str
var} are not automatically converted to a string.
\begin{demohigh}
-\StrSet \lTmpkStr {Functional}
-\StrPutLeft \lTmpkStr {Hello}
-\StrUse \lTmpkStr
+\strSet \lTmpkStr {Functional}
+\strPutLeft \lTmpkStr {Hello}
+\strUse \lTmpkStr
\end{demohigh}
\end{function}
-\begin{function}{\StrPutRight}
+\begin{function}{\strPutRight}
\begin{syntax}
-\cs{StrPutRight} \meta{str var} \Arg{token list}
+\cs{strPutRight} \meta{str var} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string}, and appends the
result to \meta{str var}. The current contents of the \meta{str
var} are not automatically converted to a string.
\begin{demohigh}
-\StrSet \lTmpkStr {Functional}
-\StrPutRight \lTmpkStr {World}
-\StrUse \lTmpkStr
+\strSet \lTmpkStr {Functional}
+\strPutRight \lTmpkStr {World}
+\strUse \lTmpkStr
\end{demohigh}
\end{function}
\section{Modifying String Variables}
-\begin{function}{\StrVarReplaceOnce}
+\begin{function}{\strVarReplaceOnce}
\begin{syntax}
-\cs{StrVarReplaceOnce} \meta{str var} \Arg{old} \Arg{new}
+\cs{strVarReplaceOnce} \meta{str var} \Arg{old} \Arg{new}
\end{syntax}
Converts the \meta{old} and \meta{new} token lists to strings, then
replaces the first (leftmost) occurrence of \meta{old string} in the
\meta{str var} with \meta{new string}.
\begin{demohigh}
-\StrSet \lTmpaStr {a{bc}bcd}
-\StrVarReplaceOnce \lTmpaStr {bc} {xx}
-\StrUse \lTmpaStr
+\strSet \lTmpaStr {a{bc}bcd}
+\strVarReplaceOnce \lTmpaStr {bc} {xx}
+\strUse \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrVarReplaceAll}
+\begin{function}{\strVarReplaceAll}
\begin{syntax}
-\cs{StrVarReplaceAll} \meta{str var} \Arg{old} \Arg{new}
+\cs{strVarReplaceAll} \meta{str var} \Arg{old} \Arg{new}
\end{syntax}
Converts the \meta{old} and \meta{new} token lists to strings, then
replaces all occurrences of \meta{old string} in the
@@ -2458,28 +2458,28 @@
operates from left to right, the pattern \meta{old string}
may remain after the replacement.
\begin{demohigh}
-\StrSet \lTmpaStr {a{bc}bcd}
-\StrVarReplaceAll \lTmpaStr {bc} {xx}
-\StrUse \lTmpaStr
+\strSet \lTmpaStr {a{bc}bcd}
+\strVarReplaceAll \lTmpaStr {bc} {xx}
+\strUse \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrVarRemoveOnce}
+\begin{function}{\strVarRemoveOnce}
\begin{syntax}
-\cs{StrVarRemoveOnce} \meta{str var} \Arg{token list}
+\cs{strVarRemoveOnce} \meta{str var} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string} then
removes the first (leftmost) occurrence of \meta{string} from the \meta{str var}.
\begin{demohigh}
-\StrSet \lTmpaStr {a{bc}bcd}
-\StrVarRemoveOnce \lTmpaStr {bc}
-\StrUse \lTmpaStr
+\strSet \lTmpaStr {a{bc}bcd}
+\strVarRemoveOnce \lTmpaStr {bc}
+\strUse \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrVarRemoveAll}
+\begin{function}{\strVarRemoveAll}
\begin{syntax}
-\cs{StrVarRemoveAll} \meta{str var} \Arg{token list}
+\cs{strVarRemoveAll} \meta{str var} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string} then
removes all occurrences of \meta{string} from the \meta{str var}.
@@ -2486,42 +2486,42 @@
As this function operates from left to right,
the pattern \meta{string} may remain after the removal, for instance,
\begin{demohigh}
-\StrSet \lTmpaStr {abbccd}
-\StrVarRemoveAll \lTmpaStr {bc}
-\TlUse \lTmpaStr
+\strSet \lTmpaStr {abbccd}
+\strVarRemoveAll \lTmpaStr {bc}
+\tlUse \lTmpaStr
\end{demohigh}
\end{function}
\section{Working with the Content of Strings}
-\begin{function}{\StrCount}
+\begin{function}{\strCount}
\begin{syntax}
-\cs{StrCount} \Arg{token list}
+\cs{strCount} \Arg{token list}
\end{syntax}
Returns the number of characters in the string representation of \meta{token list},
as an integer denotation. All characters including spaces are counted.
\begin{demohigh}
-\StrCount {12\abc34}
+\strCount {12\abc34}
\end{demohigh}
-Due to naming conflict, you need to use \cs{StrSize} instead of \cs{StrCount}
+Due to naming conflict, you need to use \cs{strSize} instead of \cs{strCount}
if you want to use \verb!functional! package together with \verb!xstring! package.
\end{function}
\begin{function}{\StVarCount}
\begin{syntax}
-\cs{StrVarCount} \meta{tl var}
+\cs{strVarCount} \meta{tl var}
\end{syntax}
Returns the number of characters in the string representation of the \meta{tl var},
as an integer denotation. All characters including spaces are counted.
\begin{demohigh}
-\StrSet \lTmpaStr {12\abc34}
-\StrVarCount \lTmpaStr
+\strSet \lTmpaStr {12\abc34}
+\strVarCount \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrHead}
+\begin{function}{\strHead}
\begin{syntax}
-\cs{StrHead} \Arg{token list}
+\cs{strHead} \Arg{token list}
\end{syntax}
Converts the \meta{token list} into a \meta{string}.
The first character in the \meta{string} is then returned,
@@ -2529,13 +2529,13 @@
it returns a space token with category code $10$ (blank space).
If the \meta{string} is empty, then nothing is returned.
\begin{demohigh}
-\StrHead {HELLO}
+\strHead {HELLO}
\end{demohigh}
\end{function}
-\begin{function}{\StrVarHead}
+\begin{function}{\strVarHead}
\begin{syntax}
-\cs{StrVarHead} \meta{tl var}
+\cs{strVarHead} \meta{tl var}
\end{syntax}
Converts the \meta{tl var} into a \meta{string}.
The first character in the \meta{string} is then returned,
@@ -2543,14 +2543,14 @@
it returns a space token with category code $10$ (blank space).
If the \meta{string} is empty, then nothing is returned.
\begin{demohigh}
-\StrSet \lTmpaStr {HELLO}
-\StrVarHead \lTmpaStr
+\strSet \lTmpaStr {HELLO}
+\strVarHead \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrTail}
+\begin{function}{\strTail}
\begin{syntax}
-\cs{StrTail} \Arg{token list}
+\cs{strTail} \Arg{token list}
\end{syntax}
Converts the \meta{token list} to a \meta{string}, removes the first
character, and returns the remaining characters (if any)
@@ -2559,13 +2559,13 @@
If the \meta{token list} is empty,
then nothing is left on the input stream.
\begin{demohigh}
-\StrTail {HELLO}
+\strTail {HELLO}
\end{demohigh}
\end{function}
-\begin{function}{\StrVarTail}
+\begin{function}{\strVarTail}
\begin{syntax}
-\cs{StrVarTail} \meta{tl var}
+\cs{strVarTail} \meta{tl var}
\end{syntax}
Converts the \meta{tl var} to a \meta{string}, removes the first
character, and returns the remaining characters (if any)
@@ -2574,14 +2574,14 @@
If the \meta{token list} is empty,
then nothing is left on the input stream.
\begin{demohigh}
-\StrSet \lTmpaStr {HELLO}
-\StrVarTail \lTmpaStr
+\strSet \lTmpaStr {HELLO}
+\strVarTail \lTmpaStr
\end{demohigh}
\end{function}
-\begin{function}{\StrItem}
+\begin{function}{\strItem}
\begin{syntax}
-\cs{StrItem} \Arg{token list} \Arg{integer expression}
+\cs{strItem} \Arg{token list} \Arg{integer expression}
\end{syntax}
Converts the \meta{token list} to a \meta{string},
and returns the character in position \meta{integer expression} of
@@ -2591,13 +2591,13 @@
characters are counted from the end of the \meta{string}. Hence,
$-1$ is the right-most character, \emph{etc.}
\begin{demohigh}
-\StrItem {abcd} {3}
+\strItem {abcd} {3}
\end{demohigh}
\end{function}
-\begin{function}{\StrVarItem}
+\begin{function}{\strVarItem}
\begin{syntax}
-\cs{StrVarItem} \meta{tl var} \Arg{integer expression}
+\cs{strVarItem} \meta{tl var} \Arg{integer expression}
\end{syntax}
Converts the \meta{tl var} to a \meta{string},
and returns the character in position \meta{integer expression} of
@@ -2607,8 +2607,8 @@
characters are counted from the end of the \meta{string}. Hence,
$-1$ is the right-most character, \emph{etc.}
\begin{demohigh}
-\StrSet \lTmpaStr {abcd}
-\StrVarItem \lTmpaStr {3}
+\strSet \lTmpaStr {abcd}
+\strVarItem \lTmpaStr {3}
\end{demohigh}
\end{function}
@@ -2618,10 +2618,10 @@
local assignments made by the \meta{function} or \meta{code} discussed
below remain in effect after the loop.
-%\begin{function}{\StrMapFunction,\StrVarMapFunction}
+%\begin{function}{\strMapFunction,\strVarMapFunction}
%\begin{syntax}
-%\cs{StrMapFunction} \Arg{token list} \meta{function}
-%\cs{StrVarMapFunction} \meta{str var} \meta{function}
+%\cs{strMapFunction} \Arg{token list} \meta{function}
+%\cs{strVarMapFunction} \meta{str var} \meta{function}
%\end{syntax}
%Converts the \meta{token list} to a \meta{string} then
%applies \meta{function} to every \meta{character} in the
@@ -2628,10 +2628,10 @@
%\meta{string} including spaces.
%\end{function}
-\begin{function}{\StrMapInline,\StrVarMapInline}
+\begin{function}{\strMapInline,\strVarMapInline}
\begin{syntax}
-\cs{StrMapInline} \Arg{token list} \Arg{inline function}
-\cs{StrVarMapInline} \meta{str var} \Arg{inline function}
+\cs{strMapInline} \Arg{token list} \Arg{inline function}
+\cs{strVarMapInline} \meta{str var} \Arg{inline function}
\end{syntax}
Converts the \meta{token list} to a \meta{string} then
applies the \meta{inline function} to every \meta{character} in the
@@ -2640,31 +2640,31 @@
receives the \meta{character} as \verb|#1|.
\begin{demohigh}
\IgnoreSpacesOn
-\StrClear \lTmpaStr
-\StrMapInline {one} {
- \StrPutRight \lTmpaStr {[#1]}
+\strClear \lTmpaStr
+\strMapInline {one} {
+ \strPutRight \lTmpaStr {[#1]}
}
-\StrUse \lTmpaStr
+\strUse \lTmpaStr
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\StrMapTokens, \StrVarMapTokens}
+%\begin{function}{\strMapTokens, \strVarMapTokens}
%\begin{syntax}
-%\cs{StrMapTokens} \Arg{token list} \Arg{code}
-%\cs{StrVarMapTokens} \meta{str var} \Arg{code}
+%\cs{strMapTokens} \Arg{token list} \Arg{code}
+%\cs{strVarMapTokens} \meta{str var} \Arg{code}
%\end{syntax}
%Converts the \meta{token list} to a \meta{string} then applies
%\meta{code} to every \meta{character} in the \meta{string} including spaces.
%The \meta{code} receives each character as a trailing brace group.
-%This is equivalent to \cs{StrMapFunction} if the
+%This is equivalent to \cs{strMapFunction} if the
%\meta{code} consists of a single function.
%\end{function}
-\begin{function}{\StrMapVariable,\StrMapVariable}
+\begin{function}{\strMapVariable,\strMapVariable}
\begin{syntax}
-\cs{StrMapVariable} \Arg{token list} \meta{variable} \Arg{code}
-\cs{StrVarMapVariable} \meta{str var} \meta{variable} \Arg{code}
+\cs{strMapVariable} \Arg{token list} \meta{variable} \Arg{code}
+\cs{strVarMapVariable} \meta{str var} \meta{variable} \Arg{code}
\end{syntax}
Converts the \meta{token list} to a \meta{string} then stores each
\meta{character} in the \meta{string} (including spaces) in turn in
@@ -2676,18 +2676,18 @@
\meta{string} is empty.
\begin{demohigh}
\IgnoreSpacesOn
-\StrClear \lTmpaStr
-\StrMapVariable {one} \lTmpiStr {
- \StrPutRight \lTmpaStr {\Expand {[\lTmpiStr]}}
+\strClear \lTmpaStr
+\strMapVariable {one} \lTmpiStr {
+ \strPutRight \lTmpaStr {\expWhole {[\lTmpiStr]}}
}
-\StrUse \lTmpaStr
+\strUse \lTmpaStr
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\StrMapBreak}
+%\begin{function}{\strMapBreak}
%\begin{syntax}
-%\cs{StrMapBreak}
+%\cs{strMapBreak}
%\end{syntax}
%Used to terminate a string map function before all
%characters in the \meta{string} have been processed. This
@@ -2699,7 +2699,7 @@
%Do something useful
%}
%\end{verbatim}
-%See also \cs{StrMapBreakDo}.
+%See also \cs{strMapBreakDo}.
%Use outside of a string map scenario leads to low
%level \TeX{} errors.
%\begin{texnote}
@@ -2710,9 +2710,9 @@
%\end{texnote}
%\end{function}
%
-%\begin{function}{\StrMapBreakDo}
+%\begin{function}{\strMapBreakDo}
%\begin{syntax}
-%\cs{StrMapBreakDo} \Arg{code}
+%\cs{strMapBreakDo} \Arg{code}
%\end{syntax}
%Used to terminate a string map function before all
%characters in the \meta{string} have been processed, inserting
@@ -2738,44 +2738,44 @@
\section{String Conditionals}
-\begin{function}{\StrIfExist,\StrIfExistT,\StrIfExistF,\StrIfExistTF}
+\begin{function}{\strIfExist,\strIfExistT,\strIfExistF,\strIfExistTF}
\begin{syntax}
-\cs{StrIfExist} \meta{str var}
-\cs{StrIfExistT} \meta{str var} \Arg{true code}
-\cs{StrIfExistF} \meta{str var} \Arg{false code}
-\cs{StrIfExistTF} \meta{str var} \Arg{true code} \Arg{false code}
+\cs{strIfExist} \meta{str var}
+\cs{strIfExistT} \meta{str var} \Arg{true code}
+\cs{strIfExistF} \meta{str var} \Arg{false code}
+\cs{strIfExistTF} \meta{str var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{str var} is currently defined. This does not
check that the \meta{str var} really is a string.
\begin{demohigh}
-\StrIfExistTF \lTmpaStr {\Return{Yes}} {\Return{No}}
-\StrIfExistTF \lFooUndefinedStr {\Return{Yes}} {\Return{No}}
+\strIfExistTF \lTmpaStr {\prgReturn{Yes}} {\prgReturn{No}}
+\strIfExistTF \lFooUndefinedStr {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\StrVarIfEmpty,\StrVarIfEmptyT,\StrVarIfEmptyF,\StrVarIfEmptyTF}
+\begin{function}{\strVarIfEmpty,\strVarIfEmptyT,\strVarIfEmptyF,\strVarIfEmptyTF}
\begin{syntax}
-\cs{StrVarIfEmpty} \meta{str var}
-\cs{StrVarIfEmptyT} \meta{str var} \Arg{true code}
-\cs{StrVarIfEmptyF} \meta{str var} \Arg{false code}
-\cs{StrVarIfEmptyTF} \meta{str var} \Arg{true code} \Arg{false code}
+\cs{strVarIfEmpty} \meta{str var}
+\cs{strVarIfEmptyT} \meta{str var} \Arg{true code}
+\cs{strVarIfEmptyF} \meta{str var} \Arg{false code}
+\cs{strVarIfEmptyTF} \meta{str var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{string variable} is entirely empty
(\emph{i.e.} contains no characters at all).
\begin{demohigh}
-\StrSet \lTmpaStr {abc}
-\StrVarIfEmptyTF \lTmpaStr {\Return{Empty}} {\Return{NonEmpty}}
-\StrClear \lTmpaStr
-\StrVarIfEmptyTF \lTmpaStr {\Return{Empty}} {\Return{NonEmpty}}
+\strSet \lTmpaStr {abc}
+\strVarIfEmptyTF \lTmpaStr {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\strClear \lTmpaStr
+\strVarIfEmptyTF \lTmpaStr {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\StrIfEq,\StrIfEqT,\StrIfEqF,\StrIfEqTF}
+\begin{function}{\strIfEq,\strIfEqT,\strIfEqF,\strIfEqTF}
\begin{syntax}
-\cs{StrIfEq} \Arg{tl_1} \Arg{tl_2}
-\cs{StrIfEqT} \Arg{tl_1} \Arg{tl_2} \Arg{true code}
-\cs{StrIfEqF} \Arg{tl_1} \Arg{tl_2} \Arg{false code}
-\cs{StrIfEqTF} \Arg{tl_1} \Arg{tl_2} \Arg{true code} \Arg{false code}
+\cs{strIfEq} \Arg{tl_1} \Arg{tl_2}
+\cs{strIfEqT} \Arg{tl_1} \Arg{tl_2} \Arg{true code}
+\cs{strIfEqF} \Arg{tl_1} \Arg{tl_2} \Arg{false code}
+\cs{strIfEqTF} \Arg{tl_1} \Arg{tl_2} \Arg{true code} \Arg{false code}
\end{syntax}
Compares the two \meta{token lists} on a character by character
basis (namely after converting them to strings),
@@ -2783,84 +2783,84 @@
characters in the same order.
%Thus for example
%\begin{codehigh}
-%\StrIfEq{abc}{\TlToStr{abc}}
+%\strIfEq{abc}{\tlToStr{abc}}
%\end{codehigh}
%is logically \texttt{true}.
-See \cs{TlIfEq} to compare
+See \cs{tlIfEq} to compare
tokens (including their category codes) rather than characters.
For example
\begin{demohigh}
-\StrIfEqTF {abc} {abc} {\Return{Yes}} {\Return{No}}
-\StrIfEqTF {abc} {xyz} {\Return{Yes}} {\Return{No}}
+\strIfEqTF {abc} {abc} {\prgReturn{Yes}} {\prgReturn{No}}
+\strIfEqTF {abc} {xyz} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
%\begin{demohigh}
-%\StrSet\lTmpaStr{abc}
-%\StrSet\lTmpbStr{abc}
-%\StrSet\lTmpcStr{xyz}
-%\StrIfEqTF{\lTmpaStr}{\lTmpbStr}{\Return{Yes}}{\Return{No}}
-%\StrIfEqTF{\lTmpaStr}{\lTmpcStr}{\Return{Yes}}{\Return{No}}
-%\StrIfEqTF{\StrUse\lTmpaStr}{\StrUse\lTmpbStr}{\Return{Yes}}{\Return{No}}
-%\StrIfEqTF{\StrUse\lTmpaStr}{\StrUse\lTmpcStr}{\Return{Yes}}{\Return{No}}
+%\strSet\lTmpaStr{abc}
+%\strSet\lTmpbStr{abc}
+%\strSet\lTmpcStr{xyz}
+%\strIfEqTF{\lTmpaStr}{\lTmpbStr}{\prgReturn{Yes}}{\prgReturn{No}}
+%\strIfEqTF{\lTmpaStr}{\lTmpcStr}{\prgReturn{Yes}}{\prgReturn{No}}
+%\strIfEqTF{\strUse\lTmpaStr}{\strUse\lTmpbStr}{\prgReturn{Yes}}{\prgReturn{No}}
+%\strIfEqTF{\strUse\lTmpaStr}{\strUse\lTmpcStr}{\prgReturn{Yes}}{\prgReturn{No}}
%\end{demohigh}
\end{function}
-\begin{function}{\StrVarIfEq,\StrVarIfEqT,\StrVarIfEqF,\StrVarIfEqTF}
+\begin{function}{\strVarIfEq,\strVarIfEqT,\strVarIfEqF,\strVarIfEqTF}
\begin{syntax}
-\cs{StrVarIfEq} \meta{str var_1} \meta{str var_2}
-\cs{StrVarIfEqT} \meta{str var_1} \meta{str var_2} \Arg{true code}
-\cs{StrVarIfEqF} \meta{str var_1} \meta{str var_2} \Arg{false code}
-\cs{StrVarIfEqTF} \meta{str var_1} \meta{str var_2} \Arg{true code} \Arg{false code}
+\cs{strVarIfEq} \meta{str var_1} \meta{str var_2}
+\cs{strVarIfEqT} \meta{str var_1} \meta{str var_2} \Arg{true code}
+\cs{strVarIfEqF} \meta{str var_1} \meta{str var_2} \Arg{false code}
+\cs{strVarIfEqTF} \meta{str var_1} \meta{str var_2} \Arg{true code} \Arg{false code}
\end{syntax}
Compares the content of two \meta{str variables} and
is logically \texttt{true} if the two contain the same characters
-in the same order. See \cs{TlVarIfEq} to compare tokens
+in the same order. See \cs{tlVarIfEq} to compare tokens
(including their category codes) rather than characters.
\begin{demohigh}
-\StrSet \lTmpaStr {abc}
-\StrSet \lTmpbStr {abc}
-\StrSet \lTmpcStr {xyz}
-\StrVarIfEqTF \lTmpaStr \lTmpbStr {\Return{Yes}} {\Return{No}}
-\StrVarIfEqTF \lTmpaStr \lTmpcStr {\Return{Yes}} {\Return{No}}
+\strSet \lTmpaStr {abc}
+\strSet \lTmpbStr {abc}
+\strSet \lTmpcStr {xyz}
+\strVarIfEqTF \lTmpaStr \lTmpbStr {\prgReturn{Yes}} {\prgReturn{No}}
+\strVarIfEqTF \lTmpaStr \lTmpcStr {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\StrIfIn,\StrIfInT,\StrIfInF,\StrIfInTF}
+\begin{function}{\strIfIn,\strIfInT,\strIfInF,\strIfInTF}
\begin{syntax}
-\cs{StrIfIn} \Arg{tl_1} \Arg{tl_2}
-\cs{StrIfInT} \Arg{tl_1} \Arg{tl_2} \Arg{true code}
-\cs{StrIfInF} \Arg{tl_1} \Arg{tl_2} \Arg{false code}
-\cs{StrIfInTF} \Arg{tl_1} \Arg{tl_2} \Arg{true code} \Arg{false code}
+\cs{strIfIn} \Arg{tl_1} \Arg{tl_2}
+\cs{strIfInT} \Arg{tl_1} \Arg{tl_2} \Arg{true code}
+\cs{strIfInF} \Arg{tl_1} \Arg{tl_2} \Arg{false code}
+\cs{strIfInTF} \Arg{tl_1} \Arg{tl_2} \Arg{true code} \Arg{false code}
\end{syntax}
Converts both \meta{token lists} to \meta{strings} and
tests whether \meta{string_2} is found inside \meta{string_1}.
\begin{demohigh}
-\StrIfInTF {hello world} {o} {\Return{Yes}}{\Return{No}}
-\StrIfInTF {hello world} {a} {\Return{Yes}}{\Return{No}}
+\strIfInTF {hello world} {o} {\prgReturn{Yes}}{\prgReturn{No}}
+\strIfInTF {hello world} {a} {\prgReturn{Yes}}{\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\StrVarIfIn,\StrVarIfInT,\StrVarIfInF,\StrVarIfInTF}
+\begin{function}{\strVarIfIn,\strVarIfInT,\strVarIfInF,\strVarIfInTF}
\begin{syntax}
-\cs{StrVarIfIn} \meta{str var} \Arg{token list}
-\cs{StrVarIfInT} \meta{str var} \Arg{token list} \Arg{true code}
-\cs{StrVarIfInF} \meta{str var} \Arg{token list} \Arg{false code}
-\cs{StrVarIfInTF} \meta{str var} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{strVarIfIn} \meta{str var} \Arg{token list}
+\cs{strVarIfInT} \meta{str var} \Arg{token list} \Arg{true code}
+\cs{strVarIfInF} \meta{str var} \Arg{token list} \Arg{false code}
+\cs{strVarIfInTF} \meta{str var} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Converts the \meta{token list} to a \meta{string} and
tests if that \meta{string} is found in the content of the \meta{str var}.
\begin{demohigh}
-\StrSet \lTmpaStr {hello world}
-\StrVarIfInTF \lTmpaStr {o} {\Return{Yes}}{\Return{No}}
-\StrVarIfInTF \lTmpaStr {a} {\Return{Yes}}{\Return{No}}
+\strSet \lTmpaStr {hello world}
+\strVarIfInTF \lTmpaStr {o} {\prgReturn{Yes}}{\prgReturn{No}}
+\strVarIfInTF \lTmpaStr {a} {\prgReturn{Yes}}{\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\StrCompare,\StrCompareT,\StrCompareF,\StrCompareTF}
+\begin{function}{\strCompare,\strCompareT,\strCompareF,\strCompareTF}
\begin{syntax}
-\cs{StrCompare} \Arg{tl_1} \meta{relation} \Arg{tl_2}
-\cs{StrCompareT} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{true code}
-\cs{StrCompareF} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{false code}
-\cs{StrCompareTF} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{true code} \Arg{false code}
+\cs{strCompare} \Arg{tl_1} \meta{relation} \Arg{tl_2}
+\cs{strCompareT} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{true code}
+\cs{strCompareF} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{false code}
+\cs{strCompareTF} \Arg{tl_1} \meta{relation} \Arg{tl_2} \Arg{true code} \Arg{false code}
\end{syntax}
Compares the two \meta{token lists} on a character by character
basis (namely after converting them to strings) in a lexicographic
@@ -2874,8 +2874,8 @@
\end{itemize}
For example:
\begin{demohigh}
-\StrCompareTF {ab} < {abc} {\Return{Yes}} {\Return{No}}
-\StrCompareTF {ab} < {aa} {\Return{Yes}} {\Return{No}}
+\strCompareTF {ab} < {abc} {\prgReturn{Yes}} {\prgReturn{No}}
+\strCompareTF {ab} < {aa} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
%\begin{texnote}
%This is a wrapper around the \TeX{} primitive
@@ -2885,15 +2885,15 @@
%clusters, locale, etc.
%\end{texnote}
\par
-Due to naming conflict, you need to use \cs{StrIfCompare}/\cs{StrIfCompareTF} as a replacement
+Due to naming conflict, you need to use \cs{strIfCompare}/\cs{strIfCompareTF} as a replacement
if you want to use \verb!functional! package together with \verb!xstring! package.
\end{function}
\section{String Case Functions}
-\begin{function}{\StrCase}
+\begin{function}{\strCase}
\begin{syntax}
-\cs{StrCase} \Arg{test string}
+\cs{strCase} \Arg{test string}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{string case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{string case_2} \Arg{code case_2}
@@ -2904,22 +2904,22 @@
Compares the \meta{test string} in turn with each
of the \meta{string cases} (all token lists are converted to strings).
If the two are equal (as described for
-\cs{StrIfEq}) then the associated \meta{code} is left in the
+\cs{strIfEq}) then the associated \meta{code} is left in the
input stream and other cases are discarded.
\begin{demohigh}
\IgnoreSpacesOn
-\StrCase {bbb} {
- {aaa} {\Return{First}}
- {bbb} {\Return{Second}}
- {ccb} {\Return{Third}}
+\strCase {bbb} {
+ {aaa} {\prgReturn{First}}
+ {bbb} {\prgReturn{Second}}
+ {ccb} {\prgReturn{Third}}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\StrCaseT}
+\begin{function}{\strCaseT}
\begin{syntax}
-\cs{StrCaseT} \Arg{test string}
+\cs{strCaseT} \Arg{test string}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{string case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{string case_2} \Arg{code case_2}
@@ -2931,26 +2931,26 @@
Compares the \meta{test string} in turn with each
of the \meta{string cases} (all token lists are converted to strings).
If the two are equal (as described for
-\cs{StrIfEq}) then the associated \meta{code} is left in the
+\cs{strIfEq}) then the associated \meta{code} is left in the
input stream and other cases are discarded. If any of the
cases are matched, the \meta{true code} is also inserted into the
input stream (after the code for the appropriate case).
\begin{demohigh}
\IgnoreSpacesOn
-\StrCaseT {bbb} {
- {aaa} {\TlSet\lTmpkTl{First}}
- {bbb} {\TlSet\lTmpkTl{Second}}
- {ccb} {\TlSet\lTmpkTl{Third}}
+\strCaseT {bbb} {
+ {aaa} {\tlSet\lTmpkTl{First}}
+ {bbb} {\tlSet\lTmpkTl{Second}}
+ {ccb} {\tlSet\lTmpkTl{Third}}
}{
- \Return{\TlUse\lTmpkTl}
+ \prgReturn{\tlUse\lTmpkTl}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\StrCaseF}
+\begin{function}{\strCaseF}
\begin{syntax}
-\cs{StrCaseF} \Arg{test string}
+\cs{strCaseF} \Arg{test string}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{string case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{string case_2} \Arg{code case_2}
@@ -2962,25 +2962,25 @@
Compares the \meta{test string} in turn with each
of the \meta{string cases} (all token lists are converted to strings).
If the two are equal (as described for
-\cs{StrIfEq}) then the associated \meta{code} is left in the
+\cs{strIfEq}) then the associated \meta{code} is left in the
input stream and other cases are discarded. If none
match then the \meta{false code} is inserted.
\begin{demohigh}
\IgnoreSpacesOn
-\StrCaseF {bbb} {
- {aaa} {\Return{First}}
- {bbb} {\Return{Second}}
- {ccb} {\Return{Third}}
+\strCaseF {bbb} {
+ {aaa} {\prgReturn{First}}
+ {bbb} {\prgReturn{Second}}
+ {ccb} {\prgReturn{Third}}
}{
- \Return{No~Match!}
+ \prgReturn{No~Match!}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\StrCaseTF}
+\begin{function}{\strCaseTF}
\begin{syntax}
-\cs{StrCaseTF} \Arg{test string}
+\cs{strCaseTF} \Arg{test string}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{string case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{string case_2} \Arg{code case_2}
@@ -2993,7 +2993,7 @@
Compares the \meta{test string} in turn with each
of the \meta{string cases} (all token lists are converted to strings).
If the two are equal (as described for
-\cs{StrIfEq}) then the associated \meta{code} is left in the
+\cs{strIfEq}) then the associated \meta{code} is left in the
input stream and other cases are discarded. If any of the
cases are matched, the \meta{true code} is also inserted into the
input stream (after the code for the appropriate case), while if none
@@ -3000,14 +3000,14 @@
match then the \meta{false code} is inserted.
\begin{demohigh}
\IgnoreSpacesOn
-\StrCaseTF {bbb} {
- {aaa} {\TlSet\lTmpkTl{First}}
- {bbb} {\TlSet\lTmpkTl{Second}}
- {ccb} {\TlSet\lTmpkTl{Third}}
+\strCaseTF {bbb} {
+ {aaa} {\tlSet\lTmpkTl{First}}
+ {bbb} {\tlSet\lTmpkTl{Second}}
+ {ccb} {\tlSet\lTmpkTl{Third}}
}{
- \Return{\TlUse\lTmpkTl}
+ \prgReturn{\tlUse\lTmpkTl}
}{
- \Return{No~Match!}
+ \prgReturn{No~Match!}
}
\IgnoreSpacesOff
\end{demohigh}
@@ -3072,19 +3072,19 @@
\texttt{/} or~\texttt{(} leads to an error.
\end{itemize}
Each integer operand can be either an integer variable (with no need
-for \cs{IntUse}) or an integer denotation.
+for \cs{intUse}) or an integer denotation.
For example both of the following give the same result
because \cs{lFooSomeTl} expands to the integer denotation~$5$
while the integer variable \cs{lFooSomeInt} takes the value~$4$.
\begin{demohigh}
-\IntEval {5 + 4 * 3 - (3 + 4 * 5)}
+\intEval {5 + 4 * 3 - (3 + 4 * 5)}
\end{demohigh}
\begin{demohigh}
-\TlNew \lFooSomeTl
-\TlSet \lFooSomeTl {5}
-\IntNew \lFooSomeInt
-\IntSet \lFooSomeInt {4}
-\IntEval {\lFooSomeTl + \lFooSomeInt * 3 - (3 + 4 * 5)}
+\tlNew \lFooSomeTl
+\tlSet \lFooSomeTl {5}
+\intNew \lFooSomeInt
+\intSet \lFooSomeInt {4}
+\intEval {\lFooSomeTl + \lFooSomeInt * 3 - (3 + 4 * 5)}
\end{demohigh}
%\begin{texnote}
@@ -3100,9 +3100,9 @@
\section{Using Integer Expressions}
-\begin{function}{\IntEval}
+\begin{function}{\intEval}
\begin{syntax}
-\cs{IntEval} \Arg{integer expression}
+\cs{intEval} \Arg{integer expression}
\end{syntax}
Evaluates the \meta{integer expression} and returns the result:
for positive results an
@@ -3110,49 +3110,49 @@
for negative results \texttt{-}~followed by such a sequence, and
\texttt{0}~for zero. For example
\begin{demohigh}
-\IntEval {(1+4)*(2-3)/5}
+\intEval {(1+4)*(2-3)/5}
\end{demohigh}
\begin{demohigh}
-\IntEval {\StrCount{12\TeX34} - \TlCount{12\TeX34}}
+\intEval {\strCount{12\TeX34} - \tlCount{12\TeX34}}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathAdd}
+\begin{function}{\intMathAdd}
\begin{syntax}
-\cs{IntMathAdd} \Arg{integer expression_1} \Arg{integer expression_2}
+\cs{intMathAdd} \Arg{integer expression_1} \Arg{integer expression_2}
\end{syntax}
Adds \Arg{integer expression_1} and \Arg{integer expression_2},
and returns the result. For example
\begin{demohigh}
-\IntMathAdd {7} {3}
+\intMathAdd {7} {3}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathSub}
+\begin{function}{\intMathSub}
\begin{syntax}
-\cs{IntMathSub} \Arg{integer expression_1} \Arg{integer expression_2}
+\cs{intMathSub} \Arg{integer expression_1} \Arg{integer expression_2}
\end{syntax}
Subtracts \Arg{integer expression_2} from \Arg{integer expression_1},
and returns the result. For example
\begin{demohigh}
-\IntMathSub {7} {3}
+\intMathSub {7} {3}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathMult}
+\begin{function}{\intMathMult}
\begin{syntax}
-\cs{IntMathMult} \Arg{integer expression_1} \Arg{integer expression_2}
+\cs{intMathMult} \Arg{integer expression_1} \Arg{integer expression_2}
\end{syntax}
Multiplies \Arg{integer expression_1} by \Arg{integer expression_2},
and returns the result. For example
\begin{demohigh}
-\IntMathMult {7} {3}
+\intMathMult {7} {3}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathDiv}
+\begin{function}{\intMathDiv}
\begin{syntax}
-\cs{IntMathDiv} \Arg{integer expression_1} \Arg{integer expression_2}
+\cs{intMathDiv} \Arg{integer expression_1} \Arg{integer expression_2}
\end{syntax}
Evaluates the two \meta{integer expressions} as described earlier,
then divides the first value by the second, and rounds the result
@@ -3161,13 +3161,13 @@
The result is returned as an \meta{integer denotation}.
For example
\begin{demohigh}
-\IntMathDiv {8} {3}
+\intMathDiv {8} {3}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathDivTrancate}
+\begin{function}{\intMathDivTrancate}
\begin{syntax}
-\cs{IntMathDivTrancate} \Arg{integer expression_1} \Arg{integer expression_2}
+\cs{intMathDivTrancate} \Arg{integer expression_1} \Arg{integer expression_2}
\end{syntax}
Evaluates the two \meta{integer expressions} as described earlier,
then divides the first value by the second, and rounds the result towards zero.
@@ -3175,47 +3175,47 @@
The result is returned as an \meta{integer denotation}.
For example
\begin{demohigh}
-\IntMathDivTruncate {8} {3}
+\intMathDivTruncate {8} {3}
\end{demohigh}
\end{function}
-\begin{function}{\IntMathSign}
+\begin{function}{\intMathSign}
\begin{syntax}
-\cs{IntMathSign} \Arg{intexpr}
+\cs{intMathSign} \Arg{intexpr}
\end{syntax}
Evaluates the \meta{integer expression} then leaves $1$ or $0$ or
$-1$ in the input stream according to the sign of the result.
\end{function}
-\begin{function}{\IntMathAbs}
+\begin{function}{\intMathAbs}
\begin{syntax}
-\cs{IntMathAbs} \Arg{integer expression}
+\cs{intMathAbs} \Arg{integer expression}
\end{syntax}
Evaluates the \meta{integer expression} as described for
-\cs{IntEval} and leaves the absolute value of the result in
+\cs{intEval} and leaves the absolute value of the result in
the input stream as an \meta{integer denotation} after two
expansions.
\end{function}
-\begin{function}{\IntMathMax,\IntMathMin}
+\begin{function}{\intMathMax,\intMathMin}
\begin{syntax}
-\cs{IntMathMax} \Arg{intexpr_1} \Arg{intexpr_2}
-\cs{IntMathMin} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{intMathMax} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{intMathMin} \Arg{intexpr_1} \Arg{intexpr_2}
\end{syntax}
Evaluates the \meta{integer expressions} as described for
-\cs{IntEval} and leaves either the larger or smaller value
+\cs{intEval} and leaves either the larger or smaller value
in the input stream as an \meta{integer denotation} after two
expansions.
\end{function}
-\begin{function}{\IntMathMod}
+\begin{function}{\intMathMod}
\begin{syntax}
-\cs{IntMathMod} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{intMathMod} \Arg{intexpr_1} \Arg{intexpr_2}
\end{syntax}
Evaluates the two \meta{integer expressions} as described earlier,
then calculates the integer remainder of dividing the first
expression by the second. This is obtained by subtracting
-\cs{IntMathDivTruncate} \Arg{intexpr_1} \Arg{intexpr_2} times
+\cs{intMathDivTruncate} \Arg{intexpr_1} \Arg{intexpr_2} times
\meta{intexpr_2} from \meta{intexpr_1}. Thus, the result has the
same sign as \meta{intexpr_1} and its absolute value is strictly
less than that of \meta{intexpr_2}. The result is left in the input
@@ -3222,9 +3222,9 @@
stream as an \meta{integer denotation} after two expansions.
\end{function}
-\begin{function}{\IntMathRand}
+\begin{function}{\intMathRand}
\begin{syntax}
-\cs{IntMathRand} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{intMathRand} \Arg{intexpr_1} \Arg{intexpr_2}
\end{syntax}
Evaluates the two \meta{integer expressions} and produces a
pseudo-random number between the two (with bounds included).
@@ -3233,9 +3233,9 @@
\section{Creating and Using Integers}
-\begin{function}{\IntNew}
+\begin{function}{\intNew}
\begin{syntax}
-\cs{IntNew} \meta{integer}
+\cs{intNew} \meta{integer}
\end{syntax}
Creates a new \meta{integer} or raises an error if the name is
already taken. The declaration is global. The \meta{integer} is
@@ -3242,9 +3242,9 @@
initially equal to $0$.
\end{function}
-\begin{function}{\IntConst}
+\begin{function}{\intConst}
\begin{syntax}
-\cs{IntConst} \meta{integer} \Arg{integer expression}
+\cs{intConst} \meta{integer} \Arg{integer expression}
\end{syntax}
Creates a new constant \meta{integer} or raises an error if the name
is already taken. The value of the \meta{integer} is set
@@ -3251,9 +3251,9 @@
globally to the \meta{integer expression}.
\end{function}
-\begin{function}{\IntUse}
+\begin{function}{\intUse}
\begin{syntax}
-\cs{IntUse} \meta{integer}
+\cs{intUse} \meta{integer}
\end{syntax}
Recovers the content of an \meta{integer} and returns the value.
An error is raised if the variable does not exist or if it is invalid.
@@ -3261,32 +3261,32 @@
\section{Viewing Integers}
-\begin{function}{\IntLog}
+\begin{function}{\intLog}
\begin{syntax}
-\cs{IntLog} \Arg{integer expression}
+\cs{intLog} \Arg{integer expression}
\end{syntax}
Writes the result of evaluating the \meta{integer expression}
in the log file.
\end{function}
-\begin{function}{\IntVarLog}
+\begin{function}{\intVarLog}
\begin{syntax}
-\cs{IntVarLog} \meta{integer}
+\cs{intVarLog} \meta{integer}
\end{syntax}
Writes the value of the \meta{integer} in the log file.
\end{function}
-\begin{function}{\IntShow}
+\begin{function}{\intShow}
\begin{syntax}
-\cs{IntShow} \Arg{integer expression}
+\cs{intShow} \Arg{integer expression}
\end{syntax}
Displays the result of evaluating the \meta{integer expression}
on the terminal.
\end{function}
-\begin{function}{\IntVarShow}
+\begin{function}{\intVarShow}
\begin{syntax}
-\cs{IntVarShow} \meta{integer}
+\cs{intVarShow} \meta{integer}
\end{syntax}
Displays the value of the \meta{integer} on the terminal.
\end{function}
@@ -3293,116 +3293,116 @@
\section{Setting Integer Variables}
-\begin{function}{\IntSet}
+\begin{function}{\intSet}
\begin{syntax}
-\cs{IntSet} \meta{integer} \Arg{integer expression}
+\cs{intSet} \meta{integer} \Arg{integer expression}
\end{syntax}
Sets \meta{integer} to the value of \meta{integer expression},
-which must evaluate to an integer (as described for \cs{IntEval}).
+which must evaluate to an integer (as described for \cs{intEval}).
For example
\begin{demohigh}
-\IntSet \lTmpaInt {3+5}
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {3+5}
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
-\begin{function}{\IntSetEq}
+\begin{function}{\intSetEq}
\begin{syntax}
-\cs{IntSetEq} \meta{integer_1} \meta{integer_2}
+\cs{intSetEq} \meta{integer_1} \meta{integer_2}
\end{syntax}
Sets the content of \meta{integer_1} equal to that of
\meta{integer_2}.
\end{function}
-\begin{function}{\IntZero}
+\begin{function}{\intZero}
\begin{syntax}
-\cs{IntZero} \meta{integer}
+\cs{intZero} \meta{integer}
\end{syntax}
Sets \meta{integer} to $0$. For example
\begin{demohigh}
-\IntSet \lTmpaInt {5}
-\IntZero \lTmpaInt
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {5}
+\intZero \lTmpaInt
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
-\begin{function}{\IntZeroNew}
+\begin{function}{\intZeroNew}
\begin{syntax}
-\cs{IntZeroNew} \meta{integer}
+\cs{intZeroNew} \meta{integer}
\end{syntax}
Ensures that the \meta{integer} exists globally by applying
-\cs{IntNew} if necessary, then applies \cs{IntZero} to leave
+\cs{intNew} if necessary, then applies \cs{intZero} to leave
the \meta{integer} set to zero.
\end{function}
-\begin{function}{\IntIncr}
+\begin{function}{\intIncr}
\begin{syntax}
-\cs{IntIncr} \meta{integer}
+\cs{intIncr} \meta{integer}
\end{syntax}
Increases the value stored in \meta{integer} by $1$.
For example
\begin{demohigh}
-\IntSet \lTmpaInt {5}
-\IntIncr \lTmpaInt
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {5}
+\intIncr \lTmpaInt
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
-\begin{function}{\IntDecr}
+\begin{function}{\intDecr}
\begin{syntax}
-\cs{IntDecr} \meta{integer}
+\cs{intDecr} \meta{integer}
\end{syntax}
Decreases the value stored in \meta{integer} by $1$.
For example
\begin{demohigh}
-\IntSet \lTmpaInt {5}
-\IntDecr \lTmpaInt
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {5}
+\intDecr \lTmpaInt
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
-\begin{function}{\IntAdd}
+\begin{function}{\intAdd}
\begin{syntax}
-\cs{IntAdd} \meta{integer} \Arg{integer expression}
+\cs{intAdd} \meta{integer} \Arg{integer expression}
\end{syntax}
Adds the result of the \meta{integer expression} to the current
content of the \meta{integer}. For example
\begin{demohigh}
-\IntSet \lTmpaInt {5}
-\IntAdd \lTmpaInt {2}
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {5}
+\intAdd \lTmpaInt {2}
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
-\begin{function}{\IntSub}
+\begin{function}{\intSub}
\begin{syntax}
-\cs{IntSub} \meta{integer} \Arg{integer expression}
+\cs{intSub} \meta{integer} \Arg{integer expression}
\end{syntax}
Subtracts the result of the \meta{integer expression} from the
current content of the \meta{integer}. For example
\begin{demohigh}
-\IntSet \lTmpaInt {5}
-\IntSub \lTmpaInt {3}
-\IntUse \lTmpaInt
+\intSet \lTmpaInt {5}
+\intSub \lTmpaInt {3}
+\intUse \lTmpaInt
\end{demohigh}
\end{function}
\section{Integer Step Functions}
-\begin{function}{\IntReplicate}
+\begin{function}{\intReplicate}
\begin{syntax}
-\cs{IntReplicate} \Arg{integer expression} \Arg{tokens}
+\cs{intReplicate} \Arg{integer expression} \Arg{tokens}
\end{syntax}
Evaluates the \meta{integer expression} (which should be zero or positive)
and returns the resulting number of copies of the \meta{tokens}.
\begin{demohigh}
-\IntReplicate {4} {Hello}
+\intReplicate {4} {Hello}
\end{demohigh}
\end{function}
-%\begin{function}{\IntStepFunction}
+%\begin{function}{\intStepFunction}
%\begin{syntax}
-%\cs{IntStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
+%\cs{intStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
%\end{syntax}
%This function first evaluates the \meta{initial value}, \meta{step}
%and \meta{final value}, all of which should be integer expressions.
@@ -3428,9 +3428,9 @@
%\end{quote}
%\end{function}
-\begin{function}{\IntStepInline}
+\begin{function}{\intStepInline}
\begin{syntax}
-\cs{IntStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
+\cs{intStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be integer expressions.
@@ -3441,18 +3441,18 @@
\meta{code} should define a function of one argument~(\verb|#1|).
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\IntStepInline {1} {3} {30} {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\intStepInline {1} {3} {30} {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\IntStepOneInline}
+\begin{function}{\intStepOneInline}
\begin{syntax}
-\cs{IntStepOneInline} \Arg{initial value} \Arg{final value} \Arg{code}
+\cs{intStepOneInline} \Arg{initial value} \Arg{final value} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value} and \meta{final value},
all of which should be integer expressions.
@@ -3463,18 +3463,18 @@
\meta{code} should define a function of one argument~(\verb|#1|).
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\IntStepOneInline {1} {10} {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\intStepOneInline {1} {10} {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\IntStepVariable}
+\begin{function}{\intStepVariable}
\begin{syntax}
-\cs{IntStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
+\cs{intStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be integer expressions.
@@ -3486,19 +3486,19 @@
%For example
%\begin{demohigh}
%\IgnoreSpacesOn
-%\TlClear\lTmpaTl
-%\IntStepVariable{1}{3}{30}\lTmpiTl{
-% \TlPutRight\lTmpaTl{\Value\lTmpiTl}
-% \TlPutRight\lTmpaTl{~}
+%\tlClear\lTmpaTl
+%\intStepVariable{1}{3}{30}\lTmpiTl{
+% \tlPutRight\lTmpaTl{\expValue\lTmpiTl}
+% \tlPutRight\lTmpaTl{~}
%}
-%\Return{\Value\lTmpaTl}
+%\prgReturn{\expValue\lTmpaTl}
%\IgnoreSpacesOff
%\end{demohigh}
\end{function}
-\begin{function}{\IntStepOneVariable}
+\begin{function}{\intStepOneVariable}
\begin{syntax}
-\cs{IntStepOneVariable} \Arg{initial value} \Arg{final value} \meta{tl var} \Arg{code}
+\cs{intStepOneVariable} \Arg{initial value} \Arg{final value} \meta{tl var} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value} and \meta{final value},
all of which should be integer expressions.
@@ -3511,50 +3511,50 @@
\section{Integer Conditionals}
-\begin{function}{\IntIfExist,\IntIfExistT,\IntIfExistF,\IntIfExistTF}
+\begin{function}{\intIfExist,\intIfExistT,\intIfExistF,\intIfExistTF}
\begin{syntax}
-\cs{IntIfExist} \meta{integer}
-\cs{IntIfExistT} \meta{integer} \Arg{true code}
-\cs{IntIfExistF} \meta{integer} \Arg{false code}
-\cs{IntIfExistTF} \meta{integer} \Arg{true code} \Arg{false code}
+\cs{intIfExist} \meta{integer}
+\cs{intIfExistT} \meta{integer} \Arg{true code}
+\cs{intIfExistF} \meta{integer} \Arg{false code}
+\cs{intIfExistTF} \meta{integer} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{integer} is currently defined. This does not
check that the \meta{integer} really is an integer variable.
\end{function}
-\begin{function}{\IntIfOdd,\IntIfOddT,\IntIfOddF,\IntIfOddTF}
+\begin{function}{\intIfOdd,\intIfOddT,\intIfOddF,\intIfOddTF}
\begin{syntax}
-\cs{IntIfOdd} \Arg{integer expression}
-\cs{IntIfOddT} \Arg{integer expression} \Arg{true code}
-\cs{IntIfOddF} \Arg{integer expression} \Arg{false code}
-\cs{IntIfOddTF} \Arg{integer expression} \Arg{true code} \Arg{false code}
+\cs{intIfOdd} \Arg{integer expression}
+\cs{intIfOddT} \Arg{integer expression} \Arg{true code}
+\cs{intIfOddF} \Arg{integer expression} \Arg{false code}
+\cs{intIfOddTF} \Arg{integer expression} \Arg{true code} \Arg{false code}
\end{syntax}
This function first evaluates the \meta{integer expression}
-as described for \cs{IntEval}.
+as described for \cs{intEval}.
It then evaluates if this is odd or even, as appropriate.
\end{function}
-\begin{function}{\IntIfEven,\IntIfEvenT,\IntIfEvenF,\IntIfEvenTF}
+\begin{function}{\intIfEven,\intIfEvenT,\intIfEvenF,\intIfEvenTF}
\begin{syntax}
-\cs{IntIfEven} \Arg{integer expression}
-\cs{IntIfEvenT} \Arg{integer expression} \Arg{true code}
-\cs{IntIfEvenF} \Arg{integer expression} \Arg{false code}
-\cs{IntIfEvenTF} \Arg{integer expression} \Arg{true code} \Arg{false code}
+\cs{intIfEven} \Arg{integer expression}
+\cs{intIfEvenT} \Arg{integer expression} \Arg{true code}
+\cs{intIfEvenF} \Arg{integer expression} \Arg{false code}
+\cs{intIfEvenTF} \Arg{integer expression} \Arg{true code} \Arg{false code}
\end{syntax}
This function first evaluates the \meta{integer expression}
-as described for \cs{IntEval}.
+as described for \cs{intEval}.
It then evaluates if this is even or odd, as appropriate.
\end{function}
-\begin{function}{\IntCompare,\IntCompareT,\IntCompareF,\IntCompareTF}
+\begin{function}{\intCompare,\intCompareT,\intCompareF,\intCompareTF}
\begin{syntax}
-\cs{IntCompare} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2}
-\cs{IntCompareT} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{true code}
-\cs{IntCompareF} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{false code}
-\cs{IntCompareTF} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{true code} \Arg{false code}
+\cs{intCompare} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2}
+\cs{intCompareT} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{true code}
+\cs{intCompareF} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{false code}
+\cs{intCompareTF} \Arg{intexpr_1} \meta{relation} \Arg{intexpr_2} \Arg{true code} \Arg{false code}
\end{syntax}
This function first evaluates each of the \meta{integer expressions}
-as described for \cs{IntEval}. The two results are then
+as described for \cs{intEval}. The two results are then
compared using the \meta{relation}:\par
{\centering\begin{tabular}{ll}
Equal & \texttt{=} \\
@@ -3563,16 +3563,16 @@
\end{tabular}\par}
For example
\begin{demohigh}
-\IntCompareTF {2} > {1} {\Return{Greater}} {\Return{Less}}
-\IntCompareTF {2} > {3} {\Return{Greater}} {\Return{Less}}
+\intCompareTF {2} > {1} {\prgReturn{Greater}} {\prgReturn{Less}}
+\intCompareTF {2} > {3} {\prgReturn{Greater}} {\prgReturn{Less}}
\end{demohigh}
\end{function}
\section{Integer Case Functions}
-\begin{function}{\IntCase}
+\begin{function}{\intCase}
\begin{syntax}
-\cs{IntCase} \Arg{test integer expression}
+\cs{intCase} \Arg{test integer expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{intexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{intexpr case_2} \Arg{code case_2}
@@ -3587,9 +3587,9 @@
and other cases are discarded.
\end{function}
-\begin{function}{\IntCaseT}
+\begin{function}{\intCaseT}
\begin{syntax}
-\cs{IntCaseT} \Arg{test integer expression}
+\cs{intCaseT} \Arg{test integer expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{intexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{intexpr case_2} \Arg{code case_2}
@@ -3607,9 +3607,9 @@
input stream (after the code for the appropriate case).
\end{function}
-\begin{function}{\IntCaseF}
+\begin{function}{\intCaseF}
\begin{syntax}
-\cs{IntCaseF} \Arg{test integer expression}
+\cs{intCaseF} \Arg{test integer expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{intexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{intexpr case_2} \Arg{code case_2}
@@ -3628,7 +3628,7 @@
For example
\begin{demohigh}
\IgnoreSpacesOn
-\IntCaseF { 2 * 5 }
+\intCaseF { 2 * 5 }
{
{ 5 } { Small }
{ 4 + 6 } { Medium }
@@ -3639,9 +3639,9 @@
\end{demohigh}
\end{function}
-\begin{function}{\IntCaseTF}
+\begin{function}{\intCaseTF}
\begin{syntax}
-\cs{IntCaseTF} \Arg{test integer expression}
+\cs{intCaseTF} \Arg{test integer expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{intexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{intexpr case_2} \Arg{code case_2}
@@ -3768,7 +3768,7 @@
\item Constants: \texttt{pi}, \texttt{deg} (one degree in radians).
\item Dimensions, automatically expressed in points, \emph{e.g.},
\texttt{pc} is $12$.
-\item Automatic conversion (no need for \cs{IntUse}, etc) of
+\item Automatic conversion (no need for \cs{intUse}, etc) of
integer, dimension, and skip variables to floating point numbers,
expressing dimensions in points and ignoring the stretch and
shrink components of skips.
@@ -3789,7 +3789,7 @@
An example of use could be the following.
\begin{demohigh}
\LaTeX{} can now compute: $ \frac{\sin(3.5)}{2} + 2\cdot 10^{-3}
-= \FpEval {sin(3.5)/2 + 2e-3} $.
+= \fpEval {sin(3.5)/2 + 2e-3} $.
\end{demohigh}
The operation \texttt{round} can be used to limit the result's
@@ -3816,9 +3816,9 @@
\section{Using Floating Point Expressions}
-\begin{function}{\FpEval}
+\begin{function}{\fpEval}
\begin{syntax}
-\cs{FpEval} \Arg{floating point expression}
+\cs{fpEval} \Arg{floating point expression}
\end{syntax}
Evaluates the \meta{floating point expression} and returns the
result as a decimal number with no
@@ -3827,86 +3827,86 @@
integers are expressed without a decimal separator. The values
$\pm\infty$ and \nan{} trigger an \enquote{invalid operation}
exception.
-For a tuple, each item is converted using \cs{FpEval} and they are combined as
+For a tuple, each item is converted using \cs{fpEval} and they are combined as
\verb|(|\meta{fp_1}\verb*|, |\meta{fp_2}\verb*|, |\ldots{}\meta{fp_n}\verb|)|
if $n>1$ and \verb|(|\meta{fp_1}\verb|,)| or \verb|()| for fewer items.
%This function is identical to \cs{fp_to_decimal:n}.
For example
\begin{demohigh}
-\FpEval {(1.2+3.4)*(5.6-7.8)/9}
+\fpEval {(1.2+3.4)*(5.6-7.8)/9}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathAdd}
+\begin{function}{\fpMathAdd}
\begin{syntax}
-\cs{FpMathAdd} \Arg{fpexpr_1} \Arg{fpexpr_2}
+\cs{fpMathAdd} \Arg{fpexpr_1} \Arg{fpexpr_2}
\end{syntax}
Adds \Arg{fpexpr_1} and \Arg{fpexpr_2},
and returns the result. For example
\begin{demohigh}
-\FpMathAdd {2.8} {3.7}
-\FpMathAdd {3.8-1} {2.7+1}
+\fpMathAdd {2.8} {3.7}
+\fpMathAdd {3.8-1} {2.7+1}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathSub}
+\begin{function}{\fpMathSub}
\begin{syntax}
-\cs{FpMathSub} \Arg{fpexpr_1} \Arg{fpexpr_2}
+\cs{fpMathSub} \Arg{fpexpr_1} \Arg{fpexpr_2}
\end{syntax}
Subtracts \Arg{fpexpr_2} from \Arg{fpexpr_1},
and returns the result. For example
\begin{demohigh}
-\FpMathSub {2.8} {3.7}
-\FpMathSub {3.8-1} {2.7+1}
+\fpMathSub {2.8} {3.7}
+\fpMathSub {3.8-1} {2.7+1}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathMult}
+\begin{function}{\fpMathMult}
\begin{syntax}
-\cs{FpMathMult} \Arg{fpexpr_1} \Arg{fpexpr_2}
+\cs{fpMathMult} \Arg{fpexpr_1} \Arg{fpexpr_2}
\end{syntax}
Multiplies \Arg{fpexpr_1} by \Arg{fpexpr_2},
and returns the result. For example
\begin{demohigh}
-\FpMathMult {2.8} {3.7}
-\FpMathMult {3.8-1} {2.7+1}
+\fpMathMult {2.8} {3.7}
+\fpMathMult {3.8-1} {2.7+1}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathDiv}
+\begin{function}{\fpMathDiv}
\begin{syntax}
-\cs{FpMathDiv} \Arg{fpexpr_1} \Arg{fpexpr_2}
+\cs{fpMathDiv} \Arg{fpexpr_1} \Arg{fpexpr_2}
\end{syntax}
Divides \Arg{fpexpr_1} by \Arg{fpexpr_2},
and returns the result. For example
\begin{demohigh}
-\FpMathDiv {2.8} {3.7}
-\FpMathDiv {3.8-1} {2.7+1}
+\fpMathDiv {2.8} {3.7}
+\fpMathDiv {3.8-1} {2.7+1}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathSign}
+\begin{function}{\fpMathSign}
\begin{syntax}
-\cs{FpMathSign} \Arg{fpexpr}
+\cs{fpMathSign} \Arg{fpexpr}
\end{syntax}
Evaluates the \meta{fpexpr} and returns the value
-using \cs{FpEval}\verb|{sign(|\meta{result}\verb|)}|: $+1$ for positive
+using \cs{fpEval}\verb|{sign(|\meta{result}\verb|)}|: $+1$ for positive
numbers and for $+\infty$, $-1$ for negative numbers and for
$-\infty$, $\pm 0$ for $\pm 0$. If the operand is a tuple or is
\nan{}, then \enquote{invalid operation} occurs and the result
is $0$. For example
\begin{demohigh}
-\FpMathSign {3.5}
-\FpMathSign {-2.7}
+\fpMathSign {3.5}
+\fpMathSign {-2.7}
\end{demohigh}
\end{function}
-\begin{function}{\FpMathAbs}
+\begin{function}{\fpMathAbs}
\begin{syntax}
-\cs{FpMathAbs} \Arg{floating point expression}
+\cs{fpMathAbs} \Arg{floating point expression}
\end{syntax}
Evaluates the \meta{floating point expression} as described for
-\cs{FpEval} and returns the absolute value.
+\cs{fpEval} and returns the absolute value.
If the argument is $\pm\infty$, \nan{} or a tuple,
\enquote{invalid operation} occurs. Within floating point
expressions, \verb|abs()| can be used; it accepts $\pm\infty$ and \nan{}
@@ -3913,12 +3913,12 @@
as arguments.
\end{function}
-\begin{function}{\FpMathMax,\FpMathMin}
+\begin{function}{\fpMathMax,\fpMathMin}
\begin{syntax}
-\cs{FpMathMax} \Arg{fp expression_1} \Arg{fp expression_2}
-\cs{FpMathMin} \Arg{fp expression_1} \Arg{fp expression_2}
+\cs{fpMathMax} \Arg{fp expression_1} \Arg{fp expression_2}
+\cs{fpMathMin} \Arg{fp expression_1} \Arg{fp expression_2}
\end{syntax}
-Evaluates the \meta{floating point expressions} as described for \cs{FpEval}
+Evaluates the \meta{floating point expressions} as described for \cs{fpEval}
and returns the resulting larger (\texttt{max}) or smaller (\texttt{min}) value.
If the argument is a tuple, \enquote{invalid operation} occurs,
but no other case raises exceptions. Within floating point expressions,
@@ -3927,9 +3927,9 @@
\section{Creating and Using Floating Points}
-\begin{function}{\FpNew}
+\begin{function}{\fpNew}
\begin{syntax}
-\cs{FpNew} \meta{fp var}
+\cs{fpNew} \meta{fp var}
\end{syntax}
Creates a new \meta{fp var} or raises an error if the name is
already taken. The declaration is global. The \meta{fp~var} is
@@ -3936,9 +3936,9 @@
initially $+0$.
\end{function}
-\begin{function}{\FpConst}
+\begin{function}{\fpConst}
\begin{syntax}
-\cs{FpConst} \meta{fp var} \Arg{floating point expression}
+\cs{fpConst} \meta{fp var} \Arg{floating point expression}
\end{syntax}
Creates a new constant \meta{fp var} or raises an error if the name
is already taken. The \meta{fp var} is set globally equal to
@@ -3945,14 +3945,14 @@
the result of evaluating the \meta{floating point expression}.
For example
\begin{demohigh}
-\FpConst \cMyPiFp {3.1415926}
-\FpUse \cMyPiFp
+\fpConst \cMyPiFp {3.1415926}
+\fpUse \cMyPiFp
\end{demohigh}
\end{function}
-\begin{function}{\FpUse}
+\begin{function}{\fpUse}
\begin{syntax}
-\cs{FpUse} \meta{fp var}
+\cs{fpUse} \meta{fp var}
\end{syntax}
Recovers the value of the \meta{fp var} and returns the value as a
decimal number with no exponent.
@@ -3968,32 +3968,32 @@
\section{Viewing Floating Points}
-\begin{function}{\FpLog}
+\begin{function}{\fpLog}
\begin{syntax}
-\cs{FpLog} \Arg{floating point expression}
+\cs{fpLog} \Arg{floating point expression}
\end{syntax}
Evaluates the \meta{floating point expression} and writes the
result in the log file.
\end{function}
-\begin{function}{\FpVarLog}
+\begin{function}{\fpVarLog}
\begin{syntax}
-\cs{FpVarLog} \meta{fp var}
+\cs{fpVarLog} \meta{fp var}
\end{syntax}
Writes the value of \meta{fp var} in the log file.
\end{function}
-\begin{function}{\FpShow}
+\begin{function}{\fpShow}
\begin{syntax}
-\cs{FpShow} \Arg{floating point expression}
+\cs{fpShow} \Arg{floating point expression}
\end{syntax}
Evaluates the \meta{floating point expression} and displays the
result in the terminal.
\end{function}
-\begin{function}{\FpVarShow}
+\begin{function}{\fpVarShow}
\begin{syntax}
-\cs{FpVarShow} \meta{fp var}
+\cs{fpVarShow} \meta{fp var}
\end{syntax}
Displays the value of \meta{fp var} in the terminal.
\end{function}
@@ -4000,50 +4000,50 @@
\section{Setting Floating Point Variables}
-\begin{function}{\FpSet}
+\begin{function}{\fpSet}
\begin{syntax}
-\cs{FpSet} \meta{fp var} \Arg{floating point expression}
+\cs{fpSet} \meta{fp var} \Arg{floating point expression}
\end{syntax}
Sets \meta{fp var} equal to the result of computing the
\meta{floating point expression}. For example
\begin{demohigh}
-\FpSet \lTmpaFp {4/7}
-\FpUse \lTmpaFp
+\fpSet \lTmpaFp {4/7}
+\fpUse \lTmpaFp
\end{demohigh}
\end{function}
-\begin{function}{\FpSetEq}
+\begin{function}{\fpSetEq}
\begin{syntax}
-\cs{FpSetEq} \meta{fp var_1} \meta{fp var_2}
+\cs{fpSetEq} \meta{fp var_1} \meta{fp var_2}
\end{syntax}
Sets the floating point variable \meta{fp var_1} equal to the current
value of \meta{fp var_2}.
\end{function}
-\begin{function}{\FpZero}
+\begin{function}{\fpZero}
\begin{syntax}
-\cs{FpZero} \meta{fp var}
+\cs{fpZero} \meta{fp var}
\end{syntax}
Sets the \meta{fp var} to $+0$. For example
\begin{demohigh}
-\FpSet \lTmpaFp {5.3}
-\FpZero \lTmpaFp
-\FpUse \lTmpaFp
+\fpSet \lTmpaFp {5.3}
+\fpZero \lTmpaFp
+\fpUse \lTmpaFp
\end{demohigh}
\end{function}
-\begin{function}{\FpZeroNew}
+\begin{function}{\fpZeroNew}
\begin{syntax}
-\cs{FpZeroNew} \meta{fp var}
+\cs{fpZeroNew} \meta{fp var}
\end{syntax}
Ensures that the \meta{fp var} exists globally
-by applying \cs{FpNew} if necessary, then applies
-\cs{FpZero} to leave the \meta{fp var} set to $+0$.
+by applying \cs{fpNew} if necessary, then applies
+\cs{fpZero} to leave the \meta{fp var} set to $+0$.
\end{function}
-\begin{function}{\FpAdd}
+\begin{function}{\fpAdd}
\begin{syntax}
-\cs{FpAdd} \meta{fp var} \Arg{floating point expression}
+\cs{fpAdd} \meta{fp var} \Arg{floating point expression}
\end{syntax}
Adds the result of computing the \meta{floating point expression} to
the \meta{fp var}.
@@ -4050,15 +4050,15 @@
This also applies if \meta{fp var} and \meta{floating point
expression} evaluate to tuples of the same size. For example
\begin{demohigh}
-\FpSet \lTmpaFp {5.3}
-\FpAdd \lTmpaFp {2.11}
-\FpUse \lTmpaFp
+\fpSet \lTmpaFp {5.3}
+\fpAdd \lTmpaFp {2.11}
+\fpUse \lTmpaFp
\end{demohigh}
\end{function}
-\begin{function}{\FpSub}
+\begin{function}{\fpSub}
\begin{syntax}
-\cs{FpSub} \meta{fp var} \Arg{floating point expression}
+\cs{fpSub} \meta{fp var} \Arg{floating point expression}
\end{syntax}
Subtracts the result of computing the \meta{floating point
expression} from the \meta{fp var}.
@@ -4065,17 +4065,17 @@
This also applies if \meta{fp var} and \meta{floating point
expression} evaluate to tuples of the same size. For example
\begin{demohigh}
-\FpSet \lTmpaFp {5.3}
-\FpSub \lTmpaFp {2.11}
-\FpUse \lTmpaFp
+\fpSet \lTmpaFp {5.3}
+\fpSub \lTmpaFp {2.11}
+\fpUse \lTmpaFp
\end{demohigh}
\end{function}
\section{Floating Point Step Functions}
-%\begin{function}{\FpStepFunction}
+%\begin{function}{\fpStepFunction}
%\begin{syntax}
-%\cs{FpStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
+%\cs{fpStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
%\end{syntax}
%This function first evaluates the \meta{initial value}, \meta{step}
%and \meta{final value}, each of which should be a floating point
@@ -4108,9 +4108,9 @@
%\end{texnote}
%\end{function}
-\begin{function}{\FpStepInline}
+\begin{function}{\fpStepInline}
\begin{syntax}
-\cs{FpStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
+\cs{fpStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be floating point
@@ -4122,18 +4122,18 @@
\meta{code} should define a function of one argument (\verb|#1|).
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\FpStepInline {1} {0.1} {1.5} {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\fpStepInline {1} {0.1} {1.5} {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\FpStepVariable}
+\begin{function}{\fpStepVariable}
\begin{syntax}
-\cs{FpStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
+\cs{fpStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be floating point
@@ -4146,12 +4146,12 @@
%For example
%\begin{demohigh}
%\IgnoreSpacesOn
-%\TlClear\lTmpaTl
-%\FpStepVariable{1}{0.1}{1.5}\lTmpiTl{
-% \TlPutRight\lTmpaTl{\Value\lTmpiTl}
-% \TlPutRight\lTmpaTl{~}
+%\tlClear\lTmpaTl
+%\fpStepVariable{1}{0.1}{1.5}\lTmpiTl{
+% \tlPutRight\lTmpaTl{\expValue\lTmpiTl}
+% \tlPutRight\lTmpaTl{~}
%}
-%\Return{\Value\lTmpaTl}
+%\prgReturn{\expValue\lTmpaTl}
%\IgnoreSpacesOff
%\end{demohigh}
\end{function}
@@ -4158,34 +4158,34 @@
\section{Float Point Conditionals}
-\begin{function}{\FpIfExist,\FpIfExistT,\FpIfExistF,\FpIfExistTF}
+\begin{function}{\fpIfExist,\fpIfExistT,\fpIfExistF,\fpIfExistTF}
\begin{syntax}
-\cs{FpIfExist} \meta{fp var}
-\cs{FpIfExistT} \meta{fp var} \Arg{true code}
-\cs{FpIfExistF} \meta{fp var} \Arg{false code}
-\cs{FpIfExistTF} \meta{fp var} \Arg{true code} \Arg{false code}
+\cs{fpIfExist} \meta{fp var}
+\cs{fpIfExistT} \meta{fp var} \Arg{true code}
+\cs{fpIfExistF} \meta{fp var} \Arg{false code}
+\cs{fpIfExistTF} \meta{fp var} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{fp var} is currently defined. This does not
check that the \meta{fp var} really is a floating point variable.
For example
\begin{demohigh}
-\FpIfExistTF \lTmpaFp {\Return{Yes}} {\Return{No}}
-\FpIfExistTF \lMyUndefinedFp {\Return{Yes}} {\Return{No}}
+\fpIfExistTF \lTmpaFp {\prgReturn{Yes}} {\prgReturn{No}}
+\fpIfExistTF \lMyUndefinedFp {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\FpCompare,\FpCompareT,\FpCompareF,\FpCompareTF}
+\begin{function}{\fpCompare,\fpCompareT,\fpCompareF,\fpCompareTF}
\begin{syntax}
-\cs{FpCompare} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2}
-\cs{FpCompareT} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{true code}
-\cs{FpCompareF} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{false code}
-\cs{FpCompareTF} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{true code} \Arg{false code}
+\cs{fpCompare} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2}
+\cs{fpCompareT} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{true code}
+\cs{fpCompareF} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{false code}
+\cs{fpCompareTF} \Arg{fpexpr_1} \meta{relation} \Arg{fpexpr_2} \Arg{true code} \Arg{false code}
\end{syntax}
Compares the \meta{fpexpr_1} and the \meta{fpexpr_2}, and returns
\texttt{true} if the \meta{relation} is obeyed. For example
\begin{demohigh}
-\FpCompareTF {1} > {0.9999} {\Return{Greater}} {\Return{Less}}
-\FpCompareTF {1} > {1.0001} {\Return{Greater}} {\Return{Less}}
+\fpCompareTF {1} > {0.9999} {\prgReturn{Greater}} {\prgReturn{Less}}
+\fpCompareTF {1} > {1.0001} {\prgReturn{Greater}} {\prgReturn{Less}}
\end{demohigh}
Two floating points
$x$ and $y$ may obey four mutually exclusive relations:
@@ -4196,7 +4196,7 @@
a \nan{}. To test if a value is \nan{}, compare it to an arbitrary
number with the \enquote{not ordered} relation.\par
%\begin{demohigh}
-%\FpCompareTF{0/0}?{0}{\Return{Is~a~Nan}}{\Return{Isn't~a~NaN}}
+%\fpCompareTF{0/0}?{0}{\prgReturn{Is~a~Nan}}{\prgReturn{Isn't~a~NaN}}
%\end{demohigh}
Tuples are equal if they have the same number of items and items
compare equal (in particular there must be no \nan{}).
@@ -4234,13 +4234,13 @@
\section{Dimension Expressions}
-\begin{function}{\DimEval}
+\begin{function}{\dimEval}
\begin{syntax}
-\cs{DimEval} \Arg{dimension expression}
+\cs{dimEval} \Arg{dimension expression}
\end{syntax}
Evaluates the \meta{dimension expression}, expanding any
dimensions and token list variables within the \meta{expression}
-to their content (without requiring \cs{DimUse}/\cs{TlUse})
+to their content (without requiring \cs{dimUse}/\cs{tlUse})
and applying the standard mathematical rules. The result of the
calculation is returned as a \meta{dimension denotation}.
%This is expressed in points (\texttt{pt}), and requires suitable
@@ -4248,38 +4248,38 @@
%an \meta{internal dimension}.
For example
\begin{demohigh}
-\DimEval {(1.2pt+3.4pt)/9}
+\dimEval {(1.2pt+3.4pt)/9}
\end{demohigh}
-%\DimEval{(1.2pt+3.4pt)*(5.6-7.8)/9}
+%\dimEval{(1.2pt+3.4pt)*(5.6-7.8)/9}
\end{function}
-\begin{function}{\DimMathAdd}
+\begin{function}{\dimMathAdd}
\begin{syntax}
-\cs{DimMathAdd} \Arg{dimexpr_1} \Arg{dimexpr_2}
+\cs{dimMathAdd} \Arg{dimexpr_1} \Arg{dimexpr_2}
\end{syntax}
Adds \Arg{dimexpr_1} and \Arg{dimexpr_2},
and returns the result. For example
\begin{demohigh}
-\DimMathAdd {2.8pt} {3.7pt}
-\DimMathAdd {3.8pt-1pt} {2.7pt+1pt}
+\dimMathAdd {2.8pt} {3.7pt}
+\dimMathAdd {3.8pt-1pt} {2.7pt+1pt}
\end{demohigh}
\end{function}
-\begin{function}{\DimMathSub}
+\begin{function}{\dimMathSub}
\begin{syntax}
-\cs{DimMathSub} \Arg{dimexpr_1} \Arg{dimexpr_2}
+\cs{dimMathSub} \Arg{dimexpr_1} \Arg{dimexpr_2}
\end{syntax}
Subtracts \Arg{dimexpr_2} from \Arg{dimexpr_1},
and returns the result. For example
\begin{demohigh}
-\DimMathSub {2.8pt} {3.7pt}
-\DimMathSub {3.8pt-1pt} {2.7pt+1pt}
+\dimMathSub {2.8pt} {3.7pt}
+\dimMathSub {3.8pt-1pt} {2.7pt+1pt}
\end{demohigh}
\end{function}
-\begin{function}{\DimMathRatio}
+\begin{function}{\dimMathRatio}
\begin{syntax}
-\cs{DimMathRatio} \Arg{dimexpr_1} \Arg{dimexpr_2}
+\cs{dimMathRatio} \Arg{dimexpr_1} \Arg{dimexpr_2}
\end{syntax}
Parses the two \meta{dimension expressions},
then calculates the ratio of the two and returns it.
@@ -4287,59 +4287,59 @@
between two integers, with all distances converted to scaled points.
For example
\begin{demohigh}
-\DimMathRatio {5pt} {10pt}
+\dimMathRatio {5pt} {10pt}
\end{demohigh}
The returned value is suitable for use inside a \meta{dimension expression}
such as
\begin{codehigh}
-\DimSet \lTmpaDim {10pt*\DimMathRatio{5pt}{10pt}}
+\dimSet \lTmpaDim {10pt*\dimMathRatio{5pt}{10pt}}
\end{codehigh}
\end{function}
-\begin{function}{\DimMathSign}
+\begin{function}{\dimMathSign}
\begin{syntax}
-\cs{DimMathSign} \Arg{dimexpr}
+\cs{dimMathSign} \Arg{dimexpr}
\end{syntax}
Evaluates the \meta{dimexpr} then returns $1$ or $0$ or $-1$
according to the sign of the result. For example
\begin{demohigh}
-\DimMathSign {3.5pt}
-\DimMathSign {-2.7pt}
+\dimMathSign {3.5pt}
+\dimMathSign {-2.7pt}
\end{demohigh}
\end{function}
-\begin{function}{\DimMathAbs}
+\begin{function}{\dimMathAbs}
\begin{syntax}
-\cs{DimMathAbs} \Arg{dimexpr}
+\cs{dimMathAbs} \Arg{dimexpr}
\end{syntax}
Converts the \meta{dimexpr} to its absolute value,
returning the result as a \meta{dimension denotation}.
For example
\begin{demohigh}
-\DimMathAbs {3.5pt}
-\DimMathAbs {-2.7pt}
+\dimMathAbs {3.5pt}
+\dimMathAbs {-2.7pt}
\end{demohigh}
\end{function}
-\begin{function}{\DimMathMax,\DimMathMin}
+\begin{function}{\dimMathMax,\dimMathMin}
\begin{syntax}
-\cs{DimMathMax} \Arg{dimexpr_1} \Arg{dimexpr_2}
-\cs{DimMathMin} \Arg{dimexpr_1} \Arg{dimexpr_2}
+\cs{dimMathMax} \Arg{dimexpr_1} \Arg{dimexpr_2}
+\cs{dimMathMin} \Arg{dimexpr_1} \Arg{dimexpr_2}
\end{syntax}
Evaluates the two \meta{dimension expressions} and returns either the
maximum or minimum value as appropriate as a \meta{dimension denotation}.
For example
\begin{demohigh}
-\DimMathMax {3.5pt} {-2.7pt}
-\DimMathMin {3.5pt} {-2.7pt}
+\dimMathMax {3.5pt} {-2.7pt}
+\dimMathMin {3.5pt} {-2.7pt}
\end{demohigh}
\end{function}
\section{Creating and Using Dimensions}
-\begin{function}{\DimNew}
+\begin{function}{\dimNew}
\begin{syntax}
-\cs{DimNew} \meta{dimension}
+\cs{dimNew} \meta{dimension}
\end{syntax}
Creates a new \meta{dimension} or raises an error if the name is
already taken. The declaration is global. The \meta{dimension}
@@ -4346,22 +4346,22 @@
is initially equal to $0$\,pt.
\end{function}
-\begin{function}{\DimConst}
+\begin{function}{\dimConst}
\begin{syntax}
-\cs{DimConst} \meta{dimension} \Arg{dimension expression}
+\cs{dimConst} \meta{dimension} \Arg{dimension expression}
\end{syntax}
Creates a new constant \meta{dimension} or raises an error if the
name is already taken. The value of the \meta{dimension} is set
globally to the \meta{dimension expression}. For example
\begin{demohigh}
-\DimConst \cFooSomeDim {1cm}
-\DimUse \cFooSomeDim
+\dimConst \cFooSomeDim {1cm}
+\dimUse \cFooSomeDim
\end{demohigh}
\end{function}
-\begin{function}{\DimUse}
+\begin{function}{\dimUse}
\begin{syntax}
-\cs{DimUse} \meta{dimension}
+\cs{dimUse} \meta{dimension}
\end{syntax}
Recovers the content of a \meta{dimension} and returns the value.
An error is raised if the variable does not exist or if it is invalid.
@@ -4369,127 +4369,127 @@
\section{Viewing Dimensions}
-\begin{function}{\DimLog}
+\begin{function}{\dimLog}
\begin{syntax}
-\cs{DimLog} \Arg{dimension expression}
+\cs{dimLog} \Arg{dimension expression}
\end{syntax}
Writes the result of evaluating the \meta{dimension expression}
in the log file. For example
\begin{codehigh}
-\DimLog {\lFooSomeDim+1cm}
+\dimLog {\lFooSomeDim+1cm}
\end{codehigh}
\end{function}
-\begin{function}{\DimVarLog}
+\begin{function}{\dimVarLog}
\begin{syntax}
-\cs{DimVarLog} \meta{dimension}
+\cs{dimVarLog} \meta{dimension}
\end{syntax}
Writes the value of the \meta{dimension} in the log file. For example
\begin{codehigh}
-\DimVarLog \lFooSomeDim
+\dimVarLog \lFooSomeDim
\end{codehigh}
\end{function}
-\begin{function}{\DimShow}
+\begin{function}{\dimShow}
\begin{syntax}
-\cs{DimShow} \Arg{dimension expression}
+\cs{dimShow} \Arg{dimension expression}
\end{syntax}
Displays the result of evaluating the \meta{dimension expression}
on the terminal. For example
\begin{codehigh}
-\DimShow {\lFooSomeDim+1cm}
+\dimShow {\lFooSomeDim+1cm}
\end{codehigh}
\end{function}
-\begin{function}{\DimVarShow}
+\begin{function}{\dimVarShow}
\begin{syntax}
-\cs{DimVarShow} \meta{dimension}
+\cs{dimVarShow} \meta{dimension}
\end{syntax}
Displays the value of the \meta{dimension} on the terminal. For example
\begin{codehigh}
-\DimVarShow \lFooSomeDim
+\dimVarShow \lFooSomeDim
\end{codehigh}
\end{function}
\section{Setting Dimension Variables}
-\begin{function}{\DimSet}
+\begin{function}{\dimSet}
\begin{syntax}
-\cs{DimSet} \meta{dimension} \Arg{dimension expression}
+\cs{dimSet} \meta{dimension} \Arg{dimension expression}
\end{syntax}
Sets \meta{dimension} to the value of \meta{dimension expression}, which
must evaluate to a length with units.
\end{function}
-\begin{function}{\DimSetEq}
+\begin{function}{\dimSetEq}
\begin{syntax}
-\cs{DimSetEq} \meta{dimension_1} \meta{dimension_2}
+\cs{dimSetEq} \meta{dimension_1} \meta{dimension_2}
\end{syntax}
Sets the content of \meta{dimension_1} equal to that of
\meta{dimension_2}. For example
\begin{demohigh}
-\DimSet \lTmpaDim {10pt}
-\DimSetEq \lTmpbDim \lTmpaDim
-\DimUse \lTmpbDim
+\dimSet \lTmpaDim {10pt}
+\dimSetEq \lTmpbDim \lTmpaDim
+\dimUse \lTmpbDim
\end{demohigh}
\end{function}
-\begin{function}{\DimZero}
+\begin{function}{\dimZero}
\begin{syntax}
-\cs{DimZero} \meta{dimension}
+\cs{dimZero} \meta{dimension}
\end{syntax}
Sets \meta{dimension} to $0$\,pt. For example
\begin{demohigh}
-\DimSet \lTmpaDim {1em}
-\DimZero \lTmpaDim
-\DimUse \lTmpaDim
+\dimSet \lTmpaDim {1em}
+\dimZero \lTmpaDim
+\dimUse \lTmpaDim
\end{demohigh}
\end{function}
-\begin{function}{\DimZeroNew}
+\begin{function}{\dimZeroNew}
\begin{syntax}
-\cs{DimZeroNew} \meta{dimension}
+\cs{dimZeroNew} \meta{dimension}
\end{syntax}
Ensures that the \meta{dimension} exists globally by applying
-\cs{DimNew} if necessary, then applies
-\cs{DimZero} to set the \meta{dimension} to zero. For example
+\cs{dimNew} if necessary, then applies
+\cs{dimZero} to set the \meta{dimension} to zero. For example
\begin{demohigh}
-\DimZeroNew \lFooSomeDim
-\DimUse \lFooSomeDim
+\dimZeroNew \lFooSomeDim
+\dimUse \lFooSomeDim
\end{demohigh}
\end{function}
-\begin{function}{\DimAdd}
+\begin{function}{\dimAdd}
\begin{syntax}
-\cs{DimAdd} \meta{dimension} \Arg{dimension expression}
+\cs{dimAdd} \meta{dimension} \Arg{dimension expression}
\end{syntax}
Adds the result of the \meta{dimension expression} to the current
content of the \meta{dimension}. For example
\begin{demohigh}
-\DimSet \lTmpaDim {5.3pt}
-\DimAdd \lTmpaDim {2.11pt}
-\DimUse \lTmpaDim
+\dimSet \lTmpaDim {5.3pt}
+\dimAdd \lTmpaDim {2.11pt}
+\dimUse \lTmpaDim
\end{demohigh}
\end{function}
-\begin{function}{\DimSub}
+\begin{function}{\dimSub}
\begin{syntax}
-\cs{DimSub} \meta{dimension} \Arg{dimension expression}
+\cs{dimSub} \meta{dimension} \Arg{dimension expression}
\end{syntax}
Subtracts the result of the \meta{dimension expression} from the
current content of the \meta{dimension}. For example
\begin{demohigh}
-\DimSet \lTmpaDim {5.3pt}
-\DimSub \lTmpaDim {2.11pt}
-\DimUse \lTmpaDim
+\dimSet \lTmpaDim {5.3pt}
+\dimSub \lTmpaDim {2.11pt}
+\dimUse \lTmpaDim
\end{demohigh}
\end{function}
\section{Dimension Step Functions}
-%\begin{function}{\DimStepFunction}
+%\begin{function}{\dimStepFunction}
%\begin{syntax}
-%\cs{DimStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
+%\cs{dimStepFunction} \Arg{initial value} \Arg{step} \Arg{final value} \meta{function}
%\end{syntax}
%This function first evaluates the \meta{initial value}, \meta{step}
%and \meta{final value}, all of which should be dimension expressions.
@@ -4503,9 +4503,9 @@
%should absorb one argument.
%\end{function}
-\begin{function}{\DimStepInline}
+\begin{function}{\dimStepInline}
\begin{syntax}
-\cs{DimStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
+\cs{dimStepInline} \Arg{initial value} \Arg{step} \Arg{final value} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be dimension expressions.
@@ -4516,18 +4516,18 @@
\meta{code} should define a function of one argument (\verb|#1|).
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\DimStepInline {1pt} {0.1pt} {1.5pt} {
- \TlPutRight \lTmpaTl {[#1]}
+\tlClear \lTmpaTl
+\dimStepInline {1pt} {0.1pt} {1.5pt} {
+ \tlPutRight \lTmpaTl {[#1]}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\DimStepVariable}
+\begin{function}{\dimStepVariable}
\begin{syntax}
-\cs{DimStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
+\cs{dimStepVariable} \Arg{initial value} \Arg{step} \Arg{final value} \meta{tl var} \Arg{code}
\end{syntax}
This function first evaluates the \meta{initial value}, \meta{step}
and \meta{final value}, all of which should be dimension expressions.
@@ -4539,12 +4539,12 @@
%For example
%\begin{demohigh}
%\IgnoreSpacesOn
-%\TlClear\lTmpaTl
-%\DimStepVariable{1pt}{0.1pt}{1.5pt}\lTmpiTl{
-% \TlPutRight\lTmpaTl{\Value\lTmpiTl}
-% \TlPutRight\lTmpaTl{~}
+%\tlClear\lTmpaTl
+%\dimStepVariable{1pt}{0.1pt}{1.5pt}\lTmpiTl{
+% \tlPutRight\lTmpaTl{\expValue\lTmpiTl}
+% \tlPutRight\lTmpaTl{~}
%}
-%\Return{\Value\lTmpaTl}
+%\prgReturn{\expValue\lTmpaTl}
%\IgnoreSpacesOff
%\end{demohigh}
\end{function}
@@ -4551,31 +4551,31 @@
\section{Dimension Conditionals}
-\begin{function}{\DimIfExist,\DimIfExistT,\DimIfExistF,\DimIfExistTF}
+\begin{function}{\dimIfExist,\dimIfExistT,\dimIfExistF,\dimIfExistTF}
\begin{syntax}
-\cs{DimIfExist} \meta{dimension}
-\cs{DimIfExistT} \meta{dimension} \Arg{true code}
-\cs{DimIfExistF} \meta{dimension} \Arg{false code}
-\cs{DimIfExistTF} \meta{dimension} \Arg{true code} \Arg{false code}
+\cs{dimIfExist} \meta{dimension}
+\cs{dimIfExistT} \meta{dimension} \Arg{true code}
+\cs{dimIfExistF} \meta{dimension} \Arg{false code}
+\cs{dimIfExistTF} \meta{dimension} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{dimension} is currently defined. This does
not check that the \meta{dimension} really is a dimension variable.
For example
\begin{demohigh}
-\DimIfExistTF \lTmpaDim {\Return{Yes}} {\Return{No}}
-\DimIfExistTF \lFooUndefinedDim {\Return{Yes}} {\Return{No}}
+\dimIfExistTF \lTmpaDim {\prgReturn{Yes}} {\prgReturn{No}}
+\dimIfExistTF \lFooUndefinedDim {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\DimCompare,\DimCompareT,\DimCompareF,\DimCompareTF}
+\begin{function}{\dimCompare,\dimCompareT,\dimCompareF,\dimCompareTF}
\begin{syntax}
-\cs{DimCompare} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2}
-\cs{DimCompareT} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{true code}
-\cs{DimCompareF} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{false code}
-\cs{DimCompareTF} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{true code} \Arg{false code}
+\cs{dimCompare} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2}
+\cs{dimCompareT} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{true code}
+\cs{dimCompareF} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{false code}
+\cs{dimCompareTF} \Arg{dimexpr_1} \meta{relation} \Arg{dimexpr_2} \Arg{true code} \Arg{false code}
\end{syntax}
This function first evaluates each of the \meta{dimension expressions}
-as described for \cs{DimEval}. The two results are then
+as described for \cs{dimEval}. The two results are then
compared using the \meta{relation}:\par
{\centering
\begin{tabular}{ll}
@@ -4585,16 +4585,16 @@
\end{tabular}\par}
For example
\begin{demohigh}
-\DimCompareTF {1pt} > {0.9999pt} {\Return{Greater}} {\Return{Less}}
-\DimCompareTF {1pt} > {1.0001pt} {\Return{Greater}} {\Return{Less}}
+\dimCompareTF {1pt} > {0.9999pt} {\prgReturn{Greater}} {\prgReturn{Less}}
+\dimCompareTF {1pt} > {1.0001pt} {\prgReturn{Greater}} {\prgReturn{Less}}
\end{demohigh}
\end{function}
\section{Dimension Case Functions}
-\begin{function}{\DimCase}
+\begin{function}{\dimCase}
\begin{syntax}
-\cs{DimCase} \Arg{test dimension expression}
+\cs{dimCase} \Arg{test dimension expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{dimexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{dimexpr case_2} \Arg{code case_2}
@@ -4609,9 +4609,9 @@
and other cases are discarded.
\end{function}
-\begin{function}{\DimCaseT}
+\begin{function}{\dimCaseT}
\begin{syntax}
-\cs{DimCaseT} \Arg{test dimension expression}
+\cs{dimCaseT} \Arg{test dimension expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{dimexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{dimexpr case_2} \Arg{code case_2}
@@ -4629,9 +4629,9 @@
input stream (after the code for the appropriate case).
\end{function}
-\begin{function}{\DimCaseF}
+\begin{function}{\dimCaseF}
\begin{syntax}
-\cs{DimCaseF} \Arg{test dimension expression}
+\cs{dimCaseF} \Arg{test dimension expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{dimexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{dimexpr case_2} \Arg{code case_2}
@@ -4649,21 +4649,21 @@
For example
\begin{demohigh}
\IgnoreSpacesOn
-\DimSet \lTmpaDim {5pt}
-\DimCaseF {2\lTmpaDim} {
- {5pt} {\Return{Small}}
- {4pt+6pt} {\Return{Medium}}
- {-10pt} {\Return{Negative}}
+\dimSet \lTmpaDim {5pt}
+\dimCaseF {2\lTmpaDim} {
+ {5pt} {\prgReturn{Small}}
+ {4pt+6pt} {\prgReturn{Medium}}
+ {-10pt} {\prgReturn{Negative}}
}{
- \Return {No Match}
+ \prgReturn {No Match}
}
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\DimCaseTF}
+\begin{function}{\dimCaseTF}
\begin{syntax}
-\cs{DimCaseTF} \Arg{test dimension expression}
+\cs{dimCaseTF} \Arg{test dimension expression}
~ ~ \verb|{|
~ ~ ~ ~ \Arg{dimexpr case_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{dimexpr case_2} \Arg{code case_2}
@@ -4684,15 +4684,15 @@
%For example
%\begin{demohigh}
%\IgnoreSpacesOn
-%\DimSet\lTmpaDim{5pt}
-%\DimCaseTF{2\lTmpaDim}{
-% {5pt} {\Return{Small}}
-% {4pt+6pt} {\Return{Medium}}
-% {-10pt} {\Return{Negative}}
+%\dimSet\lTmpaDim{5pt}
+%\dimCaseTF{2\lTmpaDim}{
+% {5pt} {\prgReturn{Small}}
+% {4pt+6pt} {\prgReturn{Medium}}
+% {-10pt} {\prgReturn{Negative}}
%}{
-% \Return{[Some Match]}
+% \prgReturn{[Some Match]}
%}{
-% \Return{[No Match]}
+% \prgReturn{[No Match]}
%}
%\IgnoreSpacesOff
%\end{demohigh}
@@ -4722,21 +4722,21 @@
\section{Creating and Using Comma Lists}
-\begin{function}{\ClistNew}
+\begin{function}{\clistNew}
\begin{syntax}
-\cs{ClistNew} \meta{comma list}
+\cs{clistNew} \meta{comma list}
\end{syntax}
Creates a new \meta{comma list} or raises an error if the name is
already taken. The declaration is global. The \meta{comma list}
initially contains no items.
\begin{codehigh}
-\ClistNew \lFooSomeClist
+\clistNew \lFooSomeClist
\end{codehigh}
\end{function}
-\begin{function}{\ClistConst}
+\begin{function}{\clistConst}
\begin{syntax}
-\cs{ClistConst} \meta{clist var} \Arg{comma list}
+\cs{clistConst} \meta{clist var} \Arg{comma list}
\end{syntax}
Creates a new constant \meta{clist var} or raises an error
if the name is already taken. The value of the
@@ -4743,13 +4743,13 @@
\meta{clist var} is set globally to the
\meta{comma list}.
\begin{codehigh}
-\ClistConst \cFooSomeClist {one,two,three}
+\clistConst \cFooSomeClist {one,two,three}
\end{codehigh}
\end{function}
-\begin{function}{\ClistVarJoin}
+\begin{function}{\clistVarJoin}
\begin{syntax}
-\cs{ClistVarJoin} \meta{clist var} \Arg{separator}
+\cs{clistVarJoin} \meta{clist var} \Arg{separator}
\end{syntax}
Returns the contents of the \meta{clist var},
with the \meta{separator} between the items.
@@ -4757,8 +4757,8 @@
%and a comma list with no items produces no output.
%An error is raised if the variable does not exist or if it is invalid.
\begin{demohigh}
-\ClistSet \lTmpaClist { a , b , , c , {de} , f }
-\ClistVarJoin \lTmpaClist { and }
+\clistSet \lTmpaClist { a , b , , c , {de} , f }
+\clistVarJoin \lTmpaClist { and }
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -4768,9 +4768,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistVarJoinExtended}
+\begin{function}{\clistVarJoinExtended}
\begin{syntax}
-\cs{ClistVarJoinExtended} \meta{clist var} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
+\cs{clistVarJoinExtended} \meta{clist var} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
\end{syntax}
Returns the contents of the \meta{clist var},
with the appropriate \meta{separator} between the items. Namely, if
@@ -4783,12 +4783,12 @@
%and a comma list with no items produces no output.
%An error is raised if the variable does not exist or if it is invalid.
\begin{demohigh}
-\ClistSet \lTmpaClist { a , b }
-\ClistVarJoinExtended \lTmpaClist { and } {, } {, and }
+\clistSet \lTmpaClist { a , b }
+\clistVarJoinExtended \lTmpaClist { and } {, } {, and }
\end{demohigh}
\begin{demohigh}
-\ClistSet \lTmpaClist { a , b , , c , {de} , f }
-\ClistVarJoinExtended \lTmpaClist { and } {, } {, and }
+\clistSet \lTmpaClist { a , b , , c , {de} , f }
+\clistVarJoinExtended \lTmpaClist { and } {, } {, and }
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -4798,23 +4798,23 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistJoin,\ClistJoinExtended}
+\begin{function}{\clistJoin,\clistJoinExtended}
\begin{syntax}
-\cs{ClistJoin} \meta{comma list} \Arg{separator}
-\cs{ClistJoinExtended} \meta{comma list} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
+\cs{clistJoin} \meta{comma list} \Arg{separator}
+\cs{clistJoinExtended} \meta{comma list} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
\end{syntax}
Returns the contents of the \meta{comma list},
with the appropriate \meta{separator} between the items. As for
-\cs{ClistSet}, blank items are omitted, spaces are removed from
+\cs{clistSet}, blank items are omitted, spaces are removed from
both sides of each item, then a set of braces is removed if the
resulting space-trimmed item is braced. The \meta{separators} are
-then inserted in the same way as for \cs{ClistVarJoin} and
-\cs{ClistVarJoinExtended}, respectively.
+then inserted in the same way as for \cs{clistVarJoin} and
+\cs{clistVarJoinExtended}, respectively.
\begin{demohigh}
-\ClistJoinExtended { a , b } { and } {, } {, and }
+\clistJoinExtended { a , b } { and } {, } {, and }
\end{demohigh}
\begin{demohigh}
-\ClistJoinExtended { a , b , , c , {de} , f } { and } {, } {, and }
+\clistJoinExtended { a , b , , c , {de} , f } { and } {, } {, and }
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -4826,55 +4826,55 @@
\section{Viewing Comma Lists}
-\begin{function}{\ClistLog}
+\begin{function}{\clistLog}
\begin{syntax}
-\cs{ClistLog} \Arg{tokens}
+\cs{clistLog} \Arg{tokens}
\end{syntax}
Writes the entries in the comma list in the log file. See also
-\cs{ClistShow} which displays the result in the terminal.
+\cs{clistShow} which displays the result in the terminal.
\begin{codehigh}
-\ClistLog {one,two,three}
+\clistLog {one,two,three}
\end{codehigh}
\end{function}
-\begin{function}{\ClistVarLog}
+\begin{function}{\clistVarLog}
\begin{syntax}
-\cs{ClistVarLog} \meta{comma list}
+\cs{clistVarLog} \meta{comma list}
\end{syntax}
Writes the entries in the \meta{comma list} in the log file. See
-also \cs{ClistVarShow} which displays the result in the terminal.
+also \cs{clistVarShow} which displays the result in the terminal.
\begin{codehigh}
-\ClistSet \lTmpaClist {one,two,three}
-\ClistVarLog \lTmpaClist
+\clistSet \lTmpaClist {one,two,three}
+\clistVarLog \lTmpaClist
\end{codehigh}
\end{function}
-\begin{function}{\ClistShow}
+\begin{function}{\clistShow}
\begin{syntax}
-\cs{ClistShow} \Arg{tokens}
+\cs{clistShow} \Arg{tokens}
\end{syntax}
Displays the entries in the comma list in the terminal.
\begin{codehigh}
-\ClistShow {one,two,three}
+\clistShow {one,two,three}
\end{codehigh}
\end{function}
-\begin{function}{\ClistVarShow}
+\begin{function}{\clistVarShow}
\begin{syntax}
-\cs{ClistVarShow} \meta{comma list}
+\cs{clistVarShow} \meta{comma list}
\end{syntax}
Displays the entries in the \meta{comma list} in the terminal.
\begin{codehigh}
-\ClistSet \lTmpaClist {one,two,three}
-\ClistVarShow \lTmpaClist
+\clistSet \lTmpaClist {one,two,three}
+\clistVarShow \lTmpaClist
\end{codehigh}
\end{function}
\section{Setting Comma Lists}
-\begin{function}{\ClistSet}
+\begin{function}{\clistSet}
\begin{syntax}
-\cs{ClistSet} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
+\cs{clistSet} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
\end{syntax}
Sets \meta{comma list} to contain the \meta{items},
removing any previous content from the variable.
@@ -4883,87 +4883,87 @@
item is braced.
To store some \meta{tokens} as a single \meta{item} even if the
\meta{tokens} contain commas or spaces, add a set of braces:
-\cs{ClistSet} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
+\cs{clistSet} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,three}
-\ClistVarJoin \lTmpaClist { and }
+\clistSet \lTmpaClist {one,two,three}
+\clistVarJoin \lTmpaClist { and }
\end{demohigh}
\end{function}
-\begin{function}{\ClistSetEq}
+\begin{function}{\clistSetEq}
\begin{syntax}
-\cs{ClistSetEq} \meta{comma list_1} \meta{comma list_2}
+\cs{clistSetEq} \meta{comma list_1} \meta{comma list_2}
\end{syntax}
Sets the content of \meta{comma list_1} equal to that of
\meta{comma list_2}. To set a token list variable equal to a comma
-list variable, use \cs{TlSetEq}. Conversely, setting a comma
+list variable, use \cs{tlSetEq}. Conversely, setting a comma
list variable to a token list is unadvisable unless one checks
space-trimming and related issues.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,three,four}
-\ClistSetEq \lTmpbClist \lTmpaClist
-\ClistVarJoin \lTmpbClist { and }
+\clistSet \lTmpaClist {one,two,three,four}
+\clistSetEq \lTmpbClist \lTmpaClist
+\clistVarJoin \lTmpbClist { and }
\end{demohigh}
\end{function}
-\begin{function}{\ClistSetFromSeq}
+\begin{function}{\clistSetFromSeq}
\begin{syntax}
-\cs{ClistSetFromSeq} \meta{comma list} \meta{sequence}
+\cs{clistSetFromSeq} \meta{comma list} \meta{sequence}
\end{syntax}
Converts the data in the \meta{sequence} into a \meta{comma list}:
the original \meta{sequence} is unchanged.
Items which contain either spaces or commas are surrounded by braces.
\begin{demohigh}
-\SeqPutRight \lTmpaSeq {one}
-\SeqPutRight \lTmpaSeq {two}
-\ClistSetFromSeq \lTmpaClist \lTmpaSeq
-\ClistVarJoin \lTmpaClist { and }
+\seqPutRight \lTmpaSeq {one}
+\seqPutRight \lTmpaSeq {two}
+\clistSetFromSeq \lTmpaClist \lTmpaSeq
+\clistVarJoin \lTmpaClist { and }
\end{demohigh}
\end{function}
-\begin{function}{\ClistClear}
+\begin{function}{\clistClear}
\begin{syntax}
-\cs{ClistClear} \meta{comma list}
+\cs{clistClear} \meta{comma list}
\end{syntax}
Clears all items from the \meta{comma list}.
\begin{codehigh}
-\ClistSet \lTmpaClist {one,two,three,four}
-\ClistClear \lTmpaClist
+\clistSet \lTmpaClist {one,two,three,four}
+\clistClear \lTmpaClist
\end{codehigh}
\end{function}
-\begin{function}{\ClistClearNew}
+\begin{function}{\clistClearNew}
\begin{syntax}
-\cs{ClistClearNew} \meta{comma list}
+\cs{clistClearNew} \meta{comma list}
\end{syntax}
Ensures that the \meta{comma list} exists globally by applying
-\cs{ClistNew} if necessary, then applies \cs{ClistClear} to leave
+\cs{clistNew} if necessary, then applies \cs{clistClear} to leave
the list empty.
\begin{demohigh}
-\ClistClearNew \lFooSomeClist
-\ClistSet \lFooSomeClist {one,two,three}
-\ClistVarJoin \lFooSomeClist { and }
+\clistClearNew \lFooSomeClist
+\clistSet \lFooSomeClist {one,two,three}
+\clistVarJoin \lFooSomeClist { and }
\end{demohigh}
\end{function}
-\begin{function}{\ClistConcat}
+\begin{function}{\clistConcat}
\begin{syntax}
-\cs{ClistConcat} \meta{comma list_1} \meta{comma list_2} \meta{comma list_3}
+\cs{clistConcat} \meta{comma list_1} \meta{comma list_2} \meta{comma list_3}
\end{syntax}
Concatenates the content of \meta{comma list_2} and \meta{comma list_3}
together and saves the result in \meta{comma list_1}. The items in
\meta{comma list_2} are placed at the left side of the new comma list.
\begin{demohigh}
-\ClistSet \lTmpbClist {one,two}
-\ClistSet \lTmpcClist {three,four}
-\ClistConcat \lTmpaClist \lTmpbClist \lTmpcClist
-\ClistVarJoin \lTmpaClist { + }
+\clistSet \lTmpbClist {one,two}
+\clistSet \lTmpcClist {three,four}
+\clistConcat \lTmpaClist \lTmpbClist \lTmpcClist
+\clistVarJoin \lTmpaClist { + }
\end{demohigh}
\end{function}
-\begin{function}{\ClistPutLeft}
+\begin{function}{\clistPutLeft}
\begin{syntax}
-\cs{ClistPutLeft} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
+\cs{clistPutLeft} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
\end{syntax}
Appends the \meta{items} to the left of the \meta{comma list}.
Blank items are omitted, spaces are removed from both sides of each
@@ -4971,17 +4971,17 @@
item is braced.
To append some \meta{tokens} as a single \meta{item} even if the
\meta{tokens} contain commas or spaces, add a set of braces:
-\cs{ClistPutLeft} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
+\cs{clistPutLeft} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two}
-\ClistPutLeft \lTmpaClist {zero}
-\ClistVarJoin \lTmpaClist { and }
+\clistSet \lTmpaClist {one,two}
+\clistPutLeft \lTmpaClist {zero}
+\clistVarJoin \lTmpaClist { and }
\end{demohigh}
\end{function}
-\begin{function}{\ClistPutRight}
+\begin{function}{\clistPutRight}
\begin{syntax}
-\cs{ClistPutRight} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
+\cs{clistPutRight} \meta{comma list} \verb|{|\meta{item_1},\ldots{},\meta{item_n}\verb|}|
\end{syntax}
Appends the \meta{items} to the right of the \meta{comma list}.
Blank items are omitted, spaces are removed from both sides of each
@@ -4989,11 +4989,11 @@
item is braced.
To append some \meta{tokens} as a single \meta{item} even if the
\meta{tokens} contain commas or spaces, add a set of braces:
-\cs{ClistPutRight} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
+\cs{clistPutRight} \meta{comma list} \verb|{| \Arg{tokens} \verb|}|.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two}
-\ClistPutRight \lTmpaClist {three}
-\ClistVarJoin \lTmpaClist { and }
+\clistSet \lTmpaClist {one,two}
+\clistPutRight \lTmpaClist {three}
+\clistVarJoin \lTmpaClist { and }
\end{demohigh}
\end{function}
@@ -5004,17 +5004,17 @@
to update comma lists, while retaining the order of the unaffected
entries.
-\begin{function}{\ClistVarRemoveDuplicates}
+\begin{function}{\clistVarRemoveDuplicates}
\begin{syntax}
-\cs{ClistVarRemoveDuplicates} \meta{comma list}
+\cs{clistVarRemoveDuplicates} \meta{comma list}
\end{syntax}
Removes duplicate items from the \meta{comma list}, leaving the
left most copy of each item in the \meta{comma list}. The \meta{item}
-comparison takes place on a token basis, as for \cs{TlIfEqTF}.
+comparison takes place on a token basis, as for \cs{tlIfEqTF}.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,one,two,three}
-\ClistVarRemoveDuplicates \lTmpaClist
-\ClistVarJoin \lTmpaClist {,}
+\clistSet \lTmpaClist {one,two,one,two,three}
+\clistVarRemoveDuplicates \lTmpaClist
+\clistVarJoin \lTmpaClist {,}
\end{demohigh}
%\begin{texnote}
%This function iterates through every item in the \meta{comma list} and
@@ -5026,17 +5026,17 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistVarRemoveAll}
+\begin{function}{\clistVarRemoveAll}
\begin{syntax}
-\cs{ClistVarRemoveAll} \meta{comma list} \Arg{item}
+\cs{clistVarRemoveAll} \meta{comma list} \Arg{item}
\end{syntax}
Removes every occurrence of \meta{item} from the \meta{comma list}.
The \meta{item} comparison takes place on a token basis, as for
-\cs{TlIfEqTF}.
+\cs{tlIfEqTF}.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,one,two,three}
-\ClistVarRemoveAll \lTmpaClist {two}
-\ClistVarJoin \lTmpaClist {,}
+\clistSet \lTmpaClist {one,two,one,two,three}
+\clistVarRemoveAll \lTmpaClist {two}
+\clistVarJoin \lTmpaClist {,}
\end{demohigh}
%\begin{texnote}
%The function may fail if the \meta{item} contains \verb|{|, \verb|}|, or \verb|#|
@@ -5044,21 +5044,21 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistVarReverse}
+\begin{function}{\clistVarReverse}
\begin{syntax}
-\cs{ClistVarReverse} \meta{comma list}
+\cs{clistVarReverse} \meta{comma list}
\end{syntax}
Reverses the order of items stored in the \meta{comma list}.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,one,two,three}
-\ClistVarReverse \lTmpaClist
-\ClistVarJoin \lTmpaClist {,}
+\clistSet \lTmpaClist {one,two,one,two,three}
+\clistVarReverse \lTmpaClist
+\clistVarJoin \lTmpaClist {,}
\end{demohigh}
\end{function}
-%\begin{function}{\ClistVarSort}
+%\begin{function}{\clistVarSort}
%\begin{syntax}
-%\cs{ClistVarSort} \meta{clist var} \Arg{comparison code}
+%\cs{clistVarSort} \meta{clist var} \Arg{comparison code}
%\end{syntax}
%Sorts the items in the \meta{clist var} according to the
%\meta{comparison code}, and assigns the result to
@@ -5068,10 +5068,10 @@
\section{Working with the Contents of Comma Lists}
-\begin{function}{\ClistCount,\ClistVarCount}
+\begin{function}{\clistCount,\clistVarCount}
\begin{syntax}
-\cs{ClistCount} \Arg{comma list}
-\cs{ClistVarCount} \meta{comma list}
+\cs{clistCount} \Arg{comma list}
+\cs{clistVarCount} \meta{comma list}
\end{syntax}
Returns the number of items in the \meta{comma list}
as an \meta{integer denotation}. The total number of items
@@ -5078,14 +5078,14 @@
in a \meta{comma list} includes those which are duplicates,
\emph{i.e.} every item in a \meta{comma list} is counted.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,three,four}
-\ClistVarCount \lTmpaClist
+\clistSet \lTmpaClist {one,two,three,four}
+\clistVarCount \lTmpaClist
\end{demohigh}
\end{function}
-\begin{function}{\ClistItem}
+\begin{function}{\clistItem}
\begin{syntax}
-\cs{ClistItem} \Arg{comma list} \Arg{integer expression}
+\cs{clistItem} \Arg{comma list} \Arg{integer expression}
\end{syntax}
Indexing items in the \meta{comma list} from $1$ at the top (left), this
function evaluates the \meta{integer expression} and returns the
@@ -5093,10 +5093,10 @@
\meta{integer expression} is negative, indexing occurs from the
bottom (right) of the comma list. When the \meta{integer expression}
is larger than the number of items in the \meta{comma list} (as
-calculated by \cs{ClistCount}) then the function returns nothing.
+calculated by \cs{clistCount}) then the function returns nothing.
\begin{demohigh}
-\TlSet \lTmpaTl {\ClistItem {one,two,three,four} {3}}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {\clistItem {one,two,three,four} {3}}
+\tlUse \lTmpaTl
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -5106,9 +5106,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistVarItem}
+\begin{function}{\clistVarItem}
\begin{syntax}
-\cs{ClistVarItem} \meta{comma list} \Arg{integer expression}
+\cs{clistVarItem} \meta{comma list} \Arg{integer expression}
\end{syntax}
Indexing items in the \meta{comma list} from $1$ at the top (left), this
function evaluates the \meta{integer expression} and returns the
@@ -5116,11 +5116,11 @@
\meta{integer expression} is negative, indexing occurs from the
bottom (right) of the comma list. When the \meta{integer expression}
is larger than the number of items in the \meta{comma list} (as
-calculated by \cs{ClistVarCount}) then the function returns nothing.
+calculated by \cs{clistVarCount}) then the function returns nothing.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two,three,four}
-\TlSet \lTmpaTl {\ClistVarItem \lTmpaClist {3}}
-\TlUse \lTmpaTl
+\clistSet \lTmpaClist {one,two,three,four}
+\tlSet \lTmpaTl {\clistVarItem \lTmpaClist {3}}
+\tlUse \lTmpaTl
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -5130,18 +5130,18 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistRandItem,\ClistVarRandItem}
+\begin{function}{\clistRandItem,\clistVarRandItem}
\begin{syntax}
-\cs{ClistRandItem} \Arg{comma list}
-\cs{ClistVarRandItem} \meta{clist var}
+\cs{clistRandItem} \Arg{comma list}
+\cs{clistVarRandItem} \meta{clist var}
\end{syntax}
Selects a pseudo-random item of the \meta{comma list}.
If the \meta{comma list} has no item, the result is empty.
\begin{demohigh}
-\TlSet \lTmpaTl {\ClistRandItem {one,two,three,four,five,six}}
-\TlUse \lTmpaTl
-\TlSet \lTmpaTl {\ClistRandItem {one,two,three,four,five,six}}
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {\clistRandItem {one,two,three,four,five,six}}
+\tlUse \lTmpaTl
+\tlSet \lTmpaTl {\clistRandItem {one,two,three,four,five,six}}
+\tlUse \lTmpaTl
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -5160,9 +5160,9 @@
in the previous section: a comma list should either be used as an
ordered data type or as a stack, but not in both ways.
-\begin{function}{\ClistGet}
+\begin{function}{\clistGet}
\begin{syntax}
-\cs{ClistGet} \meta{comma list} \meta{token list variable}
+\cs{clistGet} \meta{comma list} \meta{token list variable}
\end{syntax}
Stores the left-most item from the \meta{comma list} in the
\meta{token list variable} without removing it from the
@@ -5170,17 +5170,17 @@
If the \meta{comma list} is empty the
\meta{token list variable} is set to the marker value \cs{qNoValue}.
\begin{demohigh}
-\ClistSet \lTmpaClist {two,three,four}
-\ClistGet \lTmpaClist \lTmpaTl
-\TlUse \lTmpaTl
+\clistSet \lTmpaClist {two,three,four}
+\clistGet \lTmpaClist \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\ClistGetT,\ClistGetF,\ClistGetTF}
+\begin{function}{\clistGetT,\clistGetF,\clistGetTF}
\begin{syntax}
-\cs{ClistGetT} \meta{comma list} \meta{token list variable} \meta{true code}
-\cs{ClistGetF} \meta{comma list} \meta{token list variable} \meta{false code}
-\cs{ClistGetTF} \meta{comma list} \meta{token list variable} \meta{true code} \meta{false code}
+\cs{clistGetT} \meta{comma list} \meta{token list variable} \meta{true code}
+\cs{clistGetF} \meta{comma list} \meta{token list variable} \meta{false code}
+\cs{clistGetTF} \meta{comma list} \meta{token list variable} \meta{true code} \meta{false code}
\end{syntax}
If the \meta{comma list} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -5190,14 +5190,14 @@
it from the \meta{comma list}.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\ClistSet \lTmpaClist {two,three,four}
-\ClistGetTF \lTmpaClist \lTmpaTl {\Return{Yes}} {\Return{No}}
+\clistSet \lTmpaClist {two,three,four}
+\clistGetTF \lTmpaClist \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\ClistPop}
+\begin{function}{\clistPop}
\begin{syntax}
-\cs{ClistPop} \meta{comma list} \meta{token list variable}
+\cs{clistPop} \meta{comma list} \meta{token list variable}
\end{syntax}
Pops the left-most item from a \meta{comma list} into the
\meta{token list variable}, \emph{i.e.} removes the item from the
@@ -5206,17 +5206,17 @@
If the \meta{comma list} is empty the
\meta{token list variable} is set to the marker value \cs{qNoValue}.
\begin{demohigh}
-\ClistSet \lTmpaClist {two,three,four}
-\ClistPop \lTmpaClist \lTmpaTl
-\ClistVarJoin \lTmpaClist {,}
+\clistSet \lTmpaClist {two,three,four}
+\clistPop \lTmpaClist \lTmpaTl
+\clistVarJoin \lTmpaClist {,}
\end{demohigh}
\end{function}
-\begin{function}{\ClistPopT,\ClistPopF,\ClistPopTF}
+\begin{function}{\clistPopT,\clistPopF,\clistPopTF}
\begin{syntax}
-\cs{ClistPopT} \meta{comma list} \meta{token list variable} \Arg{true code}
-\cs{ClistPopF} \meta{comma list} \meta{token list variable} \Arg{false code}
-\cs{ClistPopTF} \meta{comma list} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{clistPopT} \meta{comma list} \meta{token list variable} \Arg{true code}
+\cs{clistPopF} \meta{comma list} \meta{token list variable} \Arg{false code}
+\cs{clistPopTF} \meta{comma list} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{comma list} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -5226,22 +5226,22 @@
the item from the \meta{comma list}.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\ClistSet \lTmpaClist {two,three,four}
-\ClistPopTF \lTmpaClist \lTmpaTl {\Return{Yes}} {\Return{No}}
+\clistSet \lTmpaClist {two,three,four}
+\clistPopTF \lTmpaClist \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\ClistPush}
+\begin{function}{\clistPush}
\begin{syntax}
-\cs{ClistPush} \meta{comma list} \Arg{items}
+\cs{clistPush} \meta{comma list} \Arg{items}
\end{syntax}
Adds the \Arg{items} to the top of the \meta{comma list}.
Spaces are removed from both sides of each item as for any
\texttt{n}-type comma list.
\begin{demohigh}
-\ClistSet \lTmpaClist {two,three,four}
-\ClistPush \lTmpaClist {zero,one}
-\ClistVarJoin \lTmpaClist {|}
+\clistSet \lTmpaClist {two,three,four}
+\clistPush \lTmpaClist {zero,one}
+\clistVarJoin \lTmpaClist {|}
\end{demohigh}
\end{function}
@@ -5267,22 +5267,22 @@
of one set of braces if any. This case is more efficient than using
explicit comma lists.
-%\begin{function}{\ClistMapFunction,\ClistVarMapFunction}
+%\begin{function}{\clistMapFunction,\clistVarMapFunction}
%\begin{syntax}
-%\cs{ClistMapFunction} \Arg{comma list} \meta{function}
-%\cs{ClistVarMapFunction} \meta{comma list} \meta{function}
+%\cs{clistMapFunction} \Arg{comma list} \meta{function}
+%\cs{clistVarMapFunction} \meta{comma list} \meta{function}
%\end{syntax}
%Applies \meta{function} to every \meta{item} stored in the
%\meta{comma list}. The \meta{function} receives one argument for
%each iteration. The \meta{items} are returned from left to right.
-%The function \cs{ClistMapInline} is in general more efficient
-%than \cs{ClistMapFunction}.
+%The function \cs{clistMapInline} is in general more efficient
+%than \cs{clistMapFunction}.
%\end{function}
-\begin{function}{\ClistMapInline,\ClistVarMapInline}
+\begin{function}{\clistMapInline,\clistVarMapInline}
\begin{syntax}
-\cs{ClistMapInline} \Arg{comma list} \Arg{inline function}
-\cs{ClistVarMapInline} \meta{comma list} \Arg{inline function}
+\cs{clistMapInline} \Arg{comma list} \Arg{inline function}
+\cs{clistVarMapInline} \meta{comma list} \Arg{inline function}
\end{syntax}
Applies \meta{inline function} to every \meta{item} stored
within the \meta{comma list}. The \meta{inline function} should
@@ -5290,19 +5290,19 @@
The \meta{items} are returned from left to right.
\begin{demohigh}
\IgnoreSpacesOn
-\TlClear \lTmpaTl
-\ClistMapInline {one,two,three} {
- \TlPutRight \lTmpaTl {(#1)}
+\tlClear \lTmpaTl
+\clistMapInline {one,two,three} {
+ \tlPutRight \lTmpaTl {(#1)}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-\begin{function}{\ClistMapVariable,\ClistVarMapVariable}
+\begin{function}{\clistMapVariable,\clistVarMapVariable}
\begin{syntax}
-\cs{ClistMapVariable} \Arg{comma list} \meta{variable} \Arg{code}
-\cs{ClistVarMapVariable} \meta{comma list} \meta{variable} \Arg{code}
+\cs{clistMapVariable} \Arg{comma list} \meta{variable} \Arg{code}
+\cs{clistVarMapVariable} \meta{comma list} \meta{variable} \Arg{code}
\end{syntax}
Stores each \meta{item} of the \meta{comma list} in turn in the
(token list) \meta{variable} and applies the \meta{code}. The
@@ -5313,28 +5313,28 @@
\meta{items} are returned from left to right.
\begin{demohigh}
\IgnoreSpacesOn
-\ClistMapVariable {one,two,three} \lTmpiTl {
- \TlPutRight \gTmpaTl {\Expand {(\lTmpiTl)}}
+\clistMapVariable {one,two,three} \lTmpiTl {
+ \tlPutRight \gTmpaTl {\expWhole {(\lTmpiTl)}}
}
-\TlUse \gTmpaTl
+\tlUse \gTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\ClistMapTokens,\ClistVarMapTokens}
+%\begin{function}{\clistMapTokens,\clistVarMapTokens}
%\begin{syntax}
-%\cs{ClistMapTokens} \Arg{comma list} \Arg{code}
-%\cs{ClistVarMapTokens} \meta{clist var} \Arg{code}
+%\cs{clistMapTokens} \Arg{comma list} \Arg{code}
+%\cs{clistVarMapTokens} \meta{clist var} \Arg{code}
%\end{syntax}
%Calls \meta{code} \Arg{item} for every \meta{item} stored in the
%\meta{comma list}. The \meta{code} receives each \meta{item} as a
%trailing brace group. If the \meta{code} consists of a single
-%function this is equivalent to \cs{ClistMapFunction} or \cs{ClistVarMapFunction}.
+%function this is equivalent to \cs{clistMapFunction} or \cs{clistVarMapFunction}.
%\end{function}
-%\begin{function}{\ClistMapBreak}
+%\begin{function}{\clistMapBreak}
%\begin{syntax}
-%\cs{ClistMapBreak}
+%\cs{clistMapBreak}
%\end{syntax}
%Used to terminate a clist map function before all
%entries in the \meta{comma list} have been processed. This
@@ -5359,9 +5359,9 @@
%\end{texnote}
%\end{function}
%
-%\begin{function}{\ClistMapBreakDo}
+%\begin{function}{\clistMapBreakDo}
%\begin{syntax}
-%\cs{ClistMapBreakDo} \Arg{code}
+%\cs{clistMapBreakDo} \Arg{code}
%\end{syntax}
%Used to terminate a clist map function before all
%entries in the \meta{comma list} have been processed, inserting
@@ -5389,27 +5389,27 @@
\section{Comma List Conditionals}
-\begin{function}{\ClistIfExist,\ClistIfExistT,\ClistIfExistF,\ClistIfExistTF}
+\begin{function}{\clistIfExist,\clistIfExistT,\clistIfExistF,\clistIfExistTF}
\begin{syntax}
-\cs{ClistIfExist} \meta{comma list}
-\cs{ClistIfExistT} \meta{comma list} \Arg{true code}
-\cs{ClistIfExistF} \meta{comma list} \Arg{false code}
-\cs{ClistIfExistTF} \meta{comma list} \Arg{true code} \Arg{false code}
+\cs{clistIfExist} \meta{comma list}
+\cs{clistIfExistT} \meta{comma list} \Arg{true code}
+\cs{clistIfExistF} \meta{comma list} \Arg{false code}
+\cs{clistIfExistTF} \meta{comma list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{comma list} is currently defined. This does
not check that the \meta{comma list} really is a comma list.
\begin{demohigh}
-\ClistIfExistTF \lTmpaClist {\Return{Yes}} {\Return{No}}
-\ClistIfExistTF \lFooUndefinedClist {\Return{Yes}} {\Return{No}}
+\clistIfExistTF \lTmpaClist {\prgReturn{Yes}} {\prgReturn{No}}
+\clistIfExistTF \lFooUndefinedClist {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\ClistIfEmpty,\ClistIfEmptyT,\ClistIfEmptyF,\ClistIfEmptyTF}
+\begin{function}{\clistIfEmpty,\clistIfEmptyT,\clistIfEmptyF,\clistIfEmptyTF}
\begin{syntax}
-\cs{ClistIfEmpty} \Arg{comma list}
-\cs{ClistIfEmptyT} \Arg{comma list} \Arg{true code}
-\cs{ClistIfEmptyF} \Arg{comma list} \Arg{false code}
-\cs{ClistIfEmptyTF} \Arg{comma list} \Arg{true code} \Arg{false code}
+\cs{clistIfEmpty} \Arg{comma list}
+\cs{clistIfEmptyT} \Arg{comma list} \Arg{true code}
+\cs{clistIfEmptyF} \Arg{comma list} \Arg{false code}
+\cs{clistIfEmptyTF} \Arg{comma list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{comma list} is empty (containing no items).
The rules for space trimming are as for other \texttt{n}-type
@@ -5418,40 +5418,40 @@
contains one element, which happens to be empty: the comma-list
is not empty.
\begin{demohigh}
-\ClistIfEmptyTF {one,two} {\Return{Empty}} {\Return{NonEmpty}}
-\ClistIfEmptyTF { , } {\Return{Empty}} {\Return{NonEmpty}}
+\clistIfEmptyTF {one,two} {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\clistIfEmptyTF { , } {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\ClistVarIfEmpty,\ClistVarIfEmptyT,\ClistVarIfEmptyF,\ClistVarIfEmptyTF}
+\begin{function}{\clistVarIfEmpty,\clistVarIfEmptyT,\clistVarIfEmptyF,\clistVarIfEmptyTF}
\begin{syntax}
-\cs{ClistVarIfEmpty} \meta{comma list}
-\cs{ClistVarIfEmptyT} \meta{comma list} \Arg{true code}
-\cs{ClistVarIfEmptyF} \meta{comma list} \Arg{false code}
-\cs{ClistVarIfEmptyTF} \meta{comma list} \Arg{true code} \Arg{false code}
+\cs{clistVarIfEmpty} \meta{comma list}
+\cs{clistVarIfEmptyT} \meta{comma list} \Arg{true code}
+\cs{clistVarIfEmptyF} \meta{comma list} \Arg{false code}
+\cs{clistVarIfEmptyTF} \meta{comma list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{comma list} is empty (containing no items).
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two}
-\ClistVarIfEmptyTF \lTmpaClist {\Return{Empty}} {\Return{NonEmpty}}
-\ClistClear \lTmpaClist
-\ClistVarIfEmptyTF \lTmpaClist {\Return{Empty}} {\Return{NonEmpty}}
+\clistSet \lTmpaClist {one,two}
+\clistVarIfEmptyTF \lTmpaClist {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\clistClear \lTmpaClist
+\clistVarIfEmptyTF \lTmpaClist {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\ClistIfIn,\ClistIfInT,\ClistIfInF,\ClistIfInTF}
+\begin{function}{\clistIfIn,\clistIfInT,\clistIfInF,\clistIfInTF}
\begin{syntax}
-\cs{ClistIfIn} \Arg{comma list} \Arg{item}
-\cs{ClistIfInT} \Arg{comma list} \Arg{item} \Arg{true code}
-\cs{ClistIfInF} \Arg{comma list} \Arg{item} \Arg{false code}
-\cs{ClistIfInTF} \Arg{comma list} \Arg{item} \Arg{true code} \Arg{false code}
+\cs{clistIfIn} \Arg{comma list} \Arg{item}
+\cs{clistIfInT} \Arg{comma list} \Arg{item} \Arg{true code}
+\cs{clistIfInF} \Arg{comma list} \Arg{item} \Arg{false code}
+\cs{clistIfInTF} \Arg{comma list} \Arg{item} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{item} is present in the \meta{comma list}.
In the case of an \texttt{n}-type \meta{comma list}, the usual rules
of space trimming and brace stripping apply. For example
\begin{demohigh}
-\ClistIfInTF { a , {b} , {b} , c } {b} {\Return{Yes}} {\Return{No}}
-\ClistIfInTF { a , {b} , {b} , c } {d} {\Return{Yes}} {\Return{No}}
+\clistIfInTF { a , {b} , {b} , c } {b} {\prgReturn{Yes}} {\prgReturn{No}}
+\clistIfInTF { a , {b} , {b} , c } {d} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
%\begin{texnote}
%The function may fail if the \meta{item} contains \verb|{|, \verb|}|, or \verb|#|
@@ -5459,20 +5459,20 @@
%\end{texnote}
\end{function}
-\begin{function}{\ClistVarIfIn,\ClistVarIfInT,\ClistVarIfInF,\ClistVarIfInTF}
+\begin{function}{\clistVarIfIn,\clistVarIfInT,\clistVarIfInF,\clistVarIfInTF}
\begin{syntax}
-\cs{ClistVarIfIn} \meta{comma list} \Arg{item}
-\cs{ClistVarIfInT} \meta{comma list} \Arg{item} \Arg{true code}
-\cs{ClistVarIfInF} \meta{comma list} \Arg{item} \Arg{false code}
-\cs{ClistVarIfInTF} \meta{comma list} \Arg{item} \Arg{true code} \Arg{false code}
+\cs{clistVarIfIn} \meta{comma list} \Arg{item}
+\cs{clistVarIfInT} \meta{comma list} \Arg{item} \Arg{true code}
+\cs{clistVarIfInF} \meta{comma list} \Arg{item} \Arg{false code}
+\cs{clistVarIfInTF} \meta{comma list} \Arg{item} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{item} is present in the \meta{comma list}.
In the case of an \texttt{n}-type \meta{comma list}, the usual rules
of space trimming and brace stripping apply.
\begin{demohigh}
-\ClistSet \lTmpaClist {one,two}
-\ClistVarIfInTF \lTmpaClist {one} {\Return{Yes}} {\Return{No}}
-\ClistVarIfInTF \lTmpaClist {three} {\Return{Yes}} {\Return{No}}
+\clistSet \lTmpaClist {one,two}
+\clistVarIfInTF \lTmpaClist {one} {\prgReturn{Yes}} {\prgReturn{No}}
+\clistVarIfInTF \lTmpaClist {three} {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
%\begin{texnote}
%The function may fail if the \meta{item} contains \verb|{|, \verb|}|, or \verb|#|
@@ -5504,33 +5504,33 @@
\section{Creating and Using Sequences}
-\begin{function}{\SeqNew}
+\begin{function}{\seqNew}
\begin{syntax}
-\cs{SeqNew} \meta{sequence}
+\cs{seqNew} \meta{sequence}
\end{syntax}
Creates a new \meta{sequence} or raises an error if the name is
already taken. The declaration is global. The \meta{sequence}
initially contains no items.
\begin{codehigh}
-\SeqNew \lFooSomeSeq
+\seqNew \lFooSomeSeq
\end{codehigh}
\end{function}
-\begin{function}{\SeqConstFromClist}
+\begin{function}{\seqConstFromClist}
\begin{syntax}
-\cs{SeqConstFromClist} \meta{seq var} \Arg{comma-list}
+\cs{seqConstFromClist} \meta{seq var} \Arg{comma-list}
\end{syntax}
Creates a new constant \meta{seq var} or raises an error if the name
is already taken. The \meta{seq var} is set globally to contain the
items in the \meta{comma list}.
\begin{codehigh}
-\SeqConstFromClist \cFooSomeSeq {one,two,three}
+\seqConstFromClist \cFooSomeSeq {one,two,three}
\end{codehigh}
\end{function}
-\begin{function}{\SeqVarJoin}
+\begin{function}{\seqVarJoin}
\begin{syntax}
-\cs{SeqVarJoin} \meta{seq var} \Arg{separator}
+\cs{seqVarJoin} \meta{seq var} \Arg{separator}
\end{syntax}
Returns the contents of the \meta{seq var}, with
the \meta{separator} between the items. If the sequence has
@@ -5538,8 +5538,8 @@
and an empty sequence returns nothing. An error is raised if
the variable does not exist or if it is invalid.
\begin{demohigh}
-\SeqSetSplit \lTmpaSeq {|} {a|b|c|{de}|f}
-\SeqVarJoin \lTmpaSeq { and }
+\seqSetSplit \lTmpaSeq {|} {a|b|c|{de}|f}
+\seqVarJoin \lTmpaSeq { and }
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -5549,9 +5549,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\SeqVarJoinExtended}
+\begin{function}{\seqVarJoinExtended}
\begin{syntax}
-\cs{SeqVarJoinExtended} \meta{seq var} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
+\cs{seqVarJoinExtended} \meta{seq var} \Arg{separator between two} \Arg{separator between more than two} \Arg{separator between final two}
\end{syntax}
Returns the contents of the \meta{seq var}, with
the appropriate \meta{separator} between the items. Namely, if the
@@ -5564,8 +5564,8 @@
returns nothing. An error is raised if the variable does
not exist or if it is invalid.
\begin{demohigh}
-\SeqSetSplit \lTmpaSeq {|} {a|b|c|{de}|f}
-\SeqVarJoinExtended \lTmpaSeq { and } {, } {, and }
+\seqSetSplit \lTmpaSeq {|} {a|b|c|{de}|f}
+\seqVarJoinExtended \lTmpaSeq { and } {, } {, and }
\end{demohigh}
The first separator argument is not used in this case
because the sequence has more than $2$ items.
@@ -5579,43 +5579,43 @@
\section{Viewing Sequences}
-\begin{function}{\SeqVarLog}
+\begin{function}{\seqVarLog}
\begin{syntax}
-\cs{SeqVarLog} \meta{sequence}
+\cs{seqVarLog} \meta{sequence}
\end{syntax}
Writes the entries in the \meta{sequence} in the log file.
\begin{codehigh}
-\SeqVarLog \lFooSomeSeq
+\seqVarLog \lFooSomeSeq
\end{codehigh}
\end{function}
-\begin{function}{\SeqVarShow}
+\begin{function}{\seqVarShow}
\begin{syntax}
-\cs{SeqVarShow} \meta{sequence}
+\cs{seqVarShow} \meta{sequence}
\end{syntax}
Displays the entries in the \meta{sequence} in the terminal.
\begin{codehigh}
-\SeqVarShow \lFooSomeSeq
+\seqVarShow \lFooSomeSeq
\end{codehigh}
\end{function}
\section{Setting Sequences}
-\begin{function}{\SeqSetFromClist}
+\begin{function}{\seqSetFromClist}
\begin{syntax}
-\cs{SeqSetFromClist} \meta{sequence} \meta{comma-list}
+\cs{seqSetFromClist} \meta{sequence} \meta{comma-list}
\end{syntax}
Converts the data in the \meta{comma list} into a \meta{sequence}:
the original \meta{comma list} is unchanged.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,three}
-\SeqVarJoin \lTmpaSeq { and }
+\seqSetFromClist \lTmpaSeq {one,two,three}
+\seqVarJoin \lTmpaSeq { and }
\end{demohigh}
\end{function}
-\begin{function}{\SeqSetSplit}
+\begin{function}{\seqSetSplit}
\begin{syntax}
-\cs{SeqSetSplit} \meta{sequence} \Arg{delimiter} \Arg{token list}
+\cs{seqSetSplit} \meta{sequence} \Arg{delimiter} \Arg{token list}
\end{syntax}
Splits the \meta{token list} into \meta{items} separated
by \meta{delimiter}, and assigns the result to the \meta{sequence}.
@@ -5623,74 +5623,74 @@
then one set of outer braces is removed (if any);
this space trimming behaviour is identical to that of
\pkg{Clist} functions. Empty \meta{items} are preserved by
-\cs{SeqSetSplit}, and can be removed afterwards using
-\cs{SeqVarRemoveAll} \meta{sequence} \verb|{}|.
+\cs{seqSetSplit}, and can be removed afterwards using
+\cs{seqVarRemoveAll} \meta{sequence} \verb|{}|.
The \meta{delimiter} may not contain \verb|{|, \verb|}| or \verb|#|
(assuming \TeX{}'s normal category code r\'egime).
If the \meta{delimiter} is empty, the \meta{token list} is split
into \meta{items} as a \meta{token list}.
-%See also \cs{SeqSetSplitKeepSpaces}, which omits space stripping.
+%See also \cs{seqSetSplitKeepSpaces}, which omits space stripping.
\begin{demohigh}
-\SeqSetSplit \lTmpaSeq {,} {1,2,3}
-\SeqVarJoin \lTmpaSeq { and }
+\seqSetSplit \lTmpaSeq {,} {1,2,3}
+\seqVarJoin \lTmpaSeq { and }
\end{demohigh}
\end{function}
-\begin{function}{\SeqSetEq}
+\begin{function}{\seqSetEq}
\begin{syntax}
-\cs{SeqSetEq} \meta{sequence_1} \meta{sequence_2}
+\cs{seqSetEq} \meta{sequence_1} \meta{sequence_2}
\end{syntax}
Sets the content of \meta{sequence_1} equal to that of
\meta{sequence_2}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,three,four}
-\SeqSetEq \lTmpbSeq \lTmpaSeq
-\SeqVarJoin \lTmpbSeq { and }
+\seqSetFromClist \lTmpaSeq {one,two,three,four}
+\seqSetEq \lTmpbSeq \lTmpaSeq
+\seqVarJoin \lTmpbSeq { and }
\end{demohigh}
\end{function}
-\begin{function}{\SeqClear}
+\begin{function}{\seqClear}
\begin{syntax}
-\cs{SeqClear} \meta{sequence}
+\cs{seqClear} \meta{sequence}
\end{syntax}
Clears all items from the \meta{sequence}.
\begin{codehigh}
-\SeqClear \lTmpaSeq
+\seqClear \lTmpaSeq
\end{codehigh}
\end{function}
-\begin{function}{\SeqClearNew}
+\begin{function}{\seqClearNew}
\begin{syntax}
-\cs{SeqClearNew} \meta{sequence}
+\cs{seqClearNew} \meta{sequence}
\end{syntax}
Ensures that the \meta{sequence} exists globally by applying
-\cs{SeqNew} if necessary, then applies \cs{SeqClear} to leave
+\cs{seqNew} if necessary, then applies \cs{seqClear} to leave
the \meta{sequence} empty.
\begin{demohigh}
-\SeqClearNew \lFooSomeSeq
-\SeqSetFromClist \lFooSomeSeq {one,two,three}
-\SeqVarJoin \lFooSomeSeq { and }
+\seqClearNew \lFooSomeSeq
+\seqSetFromClist \lFooSomeSeq {one,two,three}
+\seqVarJoin \lFooSomeSeq { and }
\end{demohigh}
\end{function}
-\begin{function}{\SeqConcat}
+\begin{function}{\seqConcat}
\begin{syntax}
-\cs{SeqConcat} \meta{sequence_1} \meta{sequence_2} \meta{sequence_3}
+\cs{seqConcat} \meta{sequence_1} \meta{sequence_2} \meta{sequence_3}
\end{syntax}
Concatenates the content of \meta{sequence_2} and \meta{sequence_3}
together and saves the result in \meta{sequence_1}. The items in
\meta{sequence_2} are placed at the left side of the new sequence.
\begin{demohigh}
-\SeqSetFromClist \lTmpbSeq {one,two}
-\SeqSetFromClist \lTmpcSeq {three,four}
-\SeqConcat \lTmpaSeq \lTmpbSeq \lTmpcSeq
-\SeqVarJoin \lTmpaSeq {, }
+\seqSetFromClist \lTmpbSeq {one,two}
+\seqSetFromClist \lTmpcSeq {three,four}
+\seqConcat \lTmpaSeq \lTmpbSeq \lTmpcSeq
+\seqVarJoin \lTmpaSeq {, }
\end{demohigh}
\end{function}
-%\begin{function}{\SeqSetSplitKeepSpaces}
+%\begin{function}{\seqSetSplitKeepSpaces}
%\begin{syntax}
-%\cs{SeqSetSplitKeepSpaces} \meta{sequence} \Arg{delimiter} \Arg{token list}
+%\cs{seqSetSplitKeepSpaces} \meta{sequence} \Arg{delimiter} \Arg{token list}
%\end{syntax}
%Splits the \meta{token list} into \meta{items} separated
%by \meta{delimiter}, and assigns the result to the \meta{sequence}.
@@ -5697,36 +5697,36 @@
%One set of outer braces is removed (if any) but any surrounding spaces
%are retained: any braces \emph{inside} one or more spaces are
%therefore kept. Empty \meta{items} are preserved by
-%\cs{SeqSetSplitKeepSpaces}, and can be removed afterwards using
-%\cs{SeqVarRemoveAll} \meta{sequence} \verb|{}|.
+%\cs{seqSetSplitKeepSpaces}, and can be removed afterwards using
+%\cs{seqVarRemoveAll} \meta{sequence} \verb|{}|.
%The \meta{delimiter} may not contain \verb|{|, \verb|}| or \verb|#|
%(assuming \TeX{}'s normal category code r\'egime).
%If the \meta{delimiter} is empty, the \meta{token list} is split
%into \meta{items} as a \meta{token list}.
-%%See also \cs{SeqSetSplit}, which removes spaces around the delimiters.
+%%See also \cs{seqSetSplit}, which removes spaces around the delimiters.
%\end{function}
-\begin{function}{\SeqPutLeft}
+\begin{function}{\seqPutLeft}
\begin{syntax}
-\cs{SeqPutLeft} \meta{sequence} \Arg{item}
+\cs{seqPutLeft} \meta{sequence} \Arg{item}
\end{syntax}
Appends the \meta{item} to the left of the \meta{sequence}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two}
-\SeqPutLeft \lTmpaSeq {zero}
-\SeqVarJoin \lTmpaSeq { and }
+\seqSetFromClist \lTmpaSeq {one,two}
+\seqPutLeft \lTmpaSeq {zero}
+\seqVarJoin \lTmpaSeq { and }
\end{demohigh}
\end{function}
-\begin{function}{\SeqPutRight}
+\begin{function}{\seqPutRight}
\begin{syntax}
-\cs{SeqPutRight} \meta{sequence} \Arg{item}
+\cs{seqPutRight} \meta{sequence} \Arg{item}
\end{syntax}
Appends the \meta{item} to the right of the \meta{sequence}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two}
-\SeqPutRight \lTmpaSeq {three}
-\SeqVarJoin \lTmpaSeq { and }
+\seqSetFromClist \lTmpaSeq {one,two}
+\seqPutRight \lTmpaSeq {three}
+\seqVarJoin \lTmpaSeq { and }
\end{demohigh}
\end{function}
@@ -5737,17 +5737,17 @@
to update sequences, while retaining the order of the unaffected
entries.
-\begin{function}{\SeqVarRemoveDuplicates}
+\begin{function}{\seqVarRemoveDuplicates}
\begin{syntax}
-\cs{SeqVarRemoveDuplicates} \meta{sequence}
+\cs{seqVarRemoveDuplicates} \meta{sequence}
\end{syntax}
Removes duplicate items from the \meta{sequence}, leaving the
left most copy of each item in the \meta{sequence}. The \meta{item}
-comparison takes place on a token basis, as for \cs{TlIfEqTF}.
+comparison takes place on a token basis, as for \cs{tlIfEqTF}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,one,two,three}
-\SeqVarRemoveDuplicates \lTmpaSeq
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {one,two,one,two,three}
+\seqVarRemoveDuplicates \lTmpaSeq
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
%\begin{texnote}
%This function iterates through every item in the \meta{sequence} and
@@ -5756,34 +5756,34 @@
%\end{texnote}
\end{function}
-\begin{function}{\SeqVarRemoveAll}
+\begin{function}{\seqVarRemoveAll}
\begin{syntax}
-\cs{SeqVarRemoveAll} \meta{sequence} \Arg{item}
+\cs{seqVarRemoveAll} \meta{sequence} \Arg{item}
\end{syntax}
Removes every occurrence of \meta{item} from the \meta{sequence}.
-The \meta{item} comparison takes place on a token basis, as for \cs{TlIfEqTF}.
+The \meta{item} comparison takes place on a token basis, as for \cs{tlIfEqTF}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,one,two,three}
-\SeqVarRemoveAll \lTmpaSeq {two}
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {one,two,one,two,three}
+\seqVarRemoveAll \lTmpaSeq {two}
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
\end{function}
-\begin{function}{\SeqVarReverse}
+\begin{function}{\seqVarReverse}
\begin{syntax}
-\cs{SeqVarReverse} \meta{sequence}
+\cs{seqVarReverse} \meta{sequence}
\end{syntax}
Reverses the order of the items stored in the \meta{sequence}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,one,two,three}
-\SeqVarReverse \lTmpaSeq
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {one,two,one,two,three}
+\seqVarReverse \lTmpaSeq
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
\end{function}
-%\begin{function}{\SeqVarSort}
+%\begin{function}{\seqVarSort}
%\begin{syntax}
-%\cs{SeqVarSort} \meta{sequence} \Arg{comparison code}
+%\cs{seqVarSort} \meta{sequence} \Arg{comparison code}
%\end{syntax}
%Sorts the items in the \meta{sequence} according to the
%\meta{comparison code}, and assigns the result to
@@ -5791,9 +5791,9 @@
%described in Section \ref{sec:l3sort:mech}.
%\end{function}
-%\begin{function}{\SeqVarShuffle}
+%\begin{function}{\seqVarShuffle}
%\begin{syntax}
-%\cs{SeqVarShuffle} \meta{seq var}
+%\cs{seqVarShuffle} \meta{seq var}
%\end{syntax}
%Sets the \meta{seq var} to the result of placing the items of the
%\meta{seq var} in a random order. Each item is (roughly) as likely
@@ -5810,9 +5810,9 @@
\section{Working with the Contents of Sequences}
-\begin{function}{\SeqVarCount}
+\begin{function}{\seqVarCount}
\begin{syntax}
-\cs{SeqVarCount} \meta{sequence}
+\cs{seqVarCount} \meta{sequence}
\end{syntax}
Returns the number of items in the \meta{sequence}
as an \meta{integer denotation}. The total number of items
@@ -5819,14 +5819,14 @@
in a \meta{sequence} includes those which are empty and duplicates,
\emph{i.e.} every item in a \meta{sequence} is unique.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,three,four}
-\SeqVarCount \lTmpaSeq
+\seqSetFromClist \lTmpaSeq {one,two,three,four}
+\seqVarCount \lTmpaSeq
\end{demohigh}
\end{function}
-\begin{function}{\SeqVarItem}
+\begin{function}{\seqVarItem}
\begin{syntax}
-\cs{SeqVarItem} \meta{sequence} \Arg{integer expression}
+\cs{seqVarItem} \meta{sequence} \Arg{integer expression}
\end{syntax}
Indexing items in the \meta{sequence} from $1$ at the top (left), this
function evaluates the \meta{integer expression} and returns the
@@ -5834,11 +5834,11 @@
\meta{integer expression} is negative, indexing occurs from the
bottom (right) of the sequence. If the \meta{integer expression}
is larger than the number of items in the \meta{sequence} (as
-calculated by \cs{SeqVarCount}) then the function returns nothing.
+calculated by \cs{seqVarCount}) then the function returns nothing.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,three,four}
-\TlSet \lTmpaTl {\SeqVarItem \lTmpaSeq {3}}
-\TlUse \lTmpaTl
+\seqSetFromClist \lTmpaSeq {one,two,three,four}
+\tlSet \lTmpaTl {\seqVarItem \lTmpaSeq {3}}
+\tlUse \lTmpaTl
\end{demohigh}
%\begin{texnote}
%The result is returned within the \tn{unexpanded}
@@ -5848,18 +5848,18 @@
%\end{texnote}
\end{function}
-\begin{function}{\SeqVarRandItem}
+\begin{function}{\seqVarRandItem}
\begin{syntax}
-\cs{SeqVarRandItem} \meta{seq var}
+\cs{seqVarRandItem} \meta{seq var}
\end{syntax}
Selects a pseudo-random item of the \meta{sequence}. If the
\meta{sequence} is empty the result is empty.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two,three,four,five,six}
-\TlSet \lTmpaTl {\SeqVarRandItem \lTmpaSeq}
-\TlUse \lTmpaTl
-\TlSet \lTmpaTl {\SeqVarRandItem \lTmpaSeq}
-\TlUse \lTmpaTl
+\seqSetFromClist \lTmpaSeq {one,two,three,four,five,six}
+\tlSet \lTmpaTl {\seqVarRandItem \lTmpaSeq}
+\tlUse \lTmpaTl
+\tlSet \lTmpaTl {\seqVarRandItem \lTmpaSeq}
+\tlUse \lTmpaTl
\end{demohigh}
%This is not available in older versions of \XeTeX{}.
%\begin{texnote}
@@ -5879,9 +5879,9 @@
in the previous section: a sequence should either be used as an
ordered data type or as a stack, but not in both ways.
-\begin{function}{\SeqGet}
+\begin{function}{\seqGet}
\begin{syntax}
-\cs{SeqGet} \meta{sequence} \meta{token list variable}
+\cs{seqGet} \meta{sequence} \meta{token list variable}
\end{syntax}
Reads the top item from a \meta{sequence} into the
\meta{token list variable} without removing it from the
@@ -5889,17 +5889,17 @@
If \meta{sequence} is empty the \meta{token list variable} is set to
the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGet \lTmpaSeq \lTmpaTl
-\TlUse \lTmpaTl
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGet \lTmpaSeq \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\SeqGetT,\SeqGetF,\SeqGetTF}
+\begin{function}{\seqGetT,\seqGetF,\seqGetTF}
\begin{syntax}
-\cs{SeqGetT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqGetF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqGetTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqGetT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqGetF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqGetTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -5908,14 +5908,14 @@
\meta{sequence} in the \meta{token list variable} without removing it from
the \meta{sequence}. The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGetTF \lTmpaSeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGetTF \lTmpaSeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPop}
+\begin{function}{\seqPop}
\begin{syntax}
-\cs{SeqPop} \meta{sequence} \meta{token list variable}
+\cs{seqPop} \meta{sequence} \meta{token list variable}
\end{syntax}
Pops the top item from a \meta{sequence} into the
\meta{token list variable}. the \meta{token list variable} is assigned locally.
@@ -5922,17 +5922,17 @@
If \meta{sequence} is empty the \meta{token list variable} is set to
the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqPop \lTmpaSeq \lTmpaTl
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqPop \lTmpaSeq \lTmpaTl
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPopT,\SeqPopF,\SeqPopTF}
+\begin{function}{\seqPopT,\seqPopF,\seqPopTF}
\begin{syntax}
-\cs{SeqPopT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqPopF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqPopTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqPopT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqPopF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqPopTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -5941,21 +5941,21 @@
in the \meta{token list variable}, \emph{i.e.} removes the item from the
\meta{sequence}. The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqPopTF \cEmptySeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqPopTF \cEmptySeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPush}
+\begin{function}{\seqPush}
\begin{syntax}
-\cs{SeqPush} \meta{sequence} \Arg{item}
+\cs{seqPush} \meta{sequence} \Arg{item}
\end{syntax}
Adds the \Arg{item} to the top of the \meta{sequence}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqPush \lTmpaSeq {one}
-\SeqVarJoin \lTmpaSeq {|}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqPush \lTmpaSeq {one}
+\seqVarJoin \lTmpaSeq {|}
\end{demohigh}
-You can only push one item to the \meta{sequence} with \cs{SeqPush},
+You can only push one item to the \meta{sequence} with \cs{seqPush},
which is different from \cs{ClistPush}.
\end{function}
@@ -5966,9 +5966,9 @@
faster than those acting on the right. These functions all assign the
recovered material locally.
-\begin{function}{\SeqGetLeft}
+\begin{function}{\seqGetLeft}
\begin{syntax}
-\cs{SeqGetLeft} \meta{sequence} \meta{token list variable}
+\cs{seqGetLeft} \meta{sequence} \meta{token list variable}
\end{syntax}
Stores the left-most item from a \meta{sequence} in the
\meta{token list variable} without removing it from the
@@ -5976,17 +5976,17 @@
If \meta{sequence} is empty the \meta{token list variable}
is set to the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGetLeft \lTmpaSeq \lTmpaTl
-\TlUse \lTmpaTl
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGetLeft \lTmpaSeq \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\SeqGetLeftT,\SeqGetLeftF,\SeqGetLeftTF}
+\begin{function}{\seqGetLeftT,\seqGetLeftF,\seqGetLeftTF}
\begin{syntax}
-\cs{SeqGetLeftT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqGetLeftF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqGetLeftTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqGetLeftT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqGetLeftF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqGetLeftTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -5997,14 +5997,14 @@
\meta{sequence}, then leaves the \meta{true code} in the input stream.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGetLeftTF \lTmpaSeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGetLeftTF \lTmpaSeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqGetRight}
+\begin{function}{\seqGetRight}
\begin{syntax}
-\cs{SeqGetRight} \meta{sequence} \meta{token list variable}
+\cs{seqGetRight} \meta{sequence} \meta{token list variable}
\end{syntax}
Stores the right-most item from a \meta{sequence} in the
\meta{token list variable} without removing it from the
@@ -6012,17 +6012,17 @@
If \meta{sequence} is empty the \meta{token list variable}
is set to the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGetRight \lTmpaSeq \lTmpaTl
-\TlUse \lTmpaTl
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGetRight \lTmpaSeq \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\SeqGetRightT,\SeqGetRightF,\SeqGetRightTF}
+\begin{function}{\seqGetRightT,\seqGetRightF,\seqGetRightTF}
\begin{syntax}
-\cs{SeqGetRightT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqGetRightF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqGetRightTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqGetRightT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqGetRightF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqGetRightTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -6033,14 +6033,14 @@
\meta{sequence}, then leaves the \meta{true code} in the input stream.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqGetRightTF \lTmpaSeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqGetRightTF \lTmpaSeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPopLeft}
+\begin{function}{\seqPopLeft}
\begin{syntax}
-\cs{SeqPopLeft} \meta{sequence} \meta{token list variable}
+\cs{seqPopLeft} \meta{sequence} \meta{token list variable}
\end{syntax}
Pops the left-most item from a \meta{sequence} into the
\meta{token list variable}, \emph{i.e.} removes the item from the
@@ -6049,17 +6049,17 @@
If \meta{sequence} is empty the \meta{token list variable}
is set to the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqPopLeft \lTmpaSeq \lTmpaTl
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqPopLeft \lTmpaSeq \lTmpaTl
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPopLeftT,\SeqPopLeftF,\SeqPopLeftTF}
+\begin{function}{\seqPopLeftT,\seqPopLeftF,\seqPopLeftTF}
\begin{syntax}
-\cs{SeqPopLeftT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqPopLeftF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqPopLeftTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqPopLeftT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqPopLeftF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqPopLeftTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -6069,13 +6069,13 @@
\meta{sequence}, then leaves the \meta{true code} in the input stream.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqPopLeftTF \cEmptySeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqPopLeftTF \cEmptySeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPopRight}
+\begin{function}{\seqPopRight}
\begin{syntax}
-\cs{SeqPopRight} \meta{sequence} \meta{token list variable}
+\cs{seqPopRight} \meta{sequence} \meta{token list variable}
\end{syntax}
Pops the right-most item from a \meta{sequence} into the
\meta{token list variable}, \emph{i.e.} removes the item from the
@@ -6084,17 +6084,17 @@
If \meta{sequence} is empty the \meta{token list variable}
is set to the special marker \cs{qNoValue}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {two,three,four}
-\SeqPopRight \lTmpaSeq \lTmpaTl
-\SeqVarJoin \lTmpaSeq {,}
+\seqSetFromClist \lTmpaSeq {two,three,four}
+\seqPopRight \lTmpaSeq \lTmpaTl
+\seqVarJoin \lTmpaSeq {,}
\end{demohigh}
\end{function}
-\begin{function}{\SeqPopRightT,\SeqPopRightF,\SeqPopRightTF}
+\begin{function}{\seqPopRightT,\seqPopRightF,\seqPopRightTF}
\begin{syntax}
-\cs{SeqPopRightT} \meta{sequence} \meta{token list variable} \Arg{true code}
-\cs{SeqPopRightF} \meta{sequence} \meta{token list variable} \Arg{false code}
-\cs{SeqPopRightTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{seqPopRightT} \meta{sequence} \meta{token list variable} \Arg{true code}
+\cs{seqPopRightF} \meta{sequence} \meta{token list variable} \Arg{false code}
+\cs{seqPopRightTF} \meta{sequence} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{sequence} is empty, leaves the \meta{false code} in the
input stream. The value of the \meta{token list variable} is
@@ -6104,7 +6104,7 @@
\meta{sequence}, then leaves the \meta{true code} in the input stream.
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\SeqPopRightTF \cEmptySeq \lTmpaTl {\Return{Yes}} {\Return{No}}
+\seqPopRightTF \cEmptySeq \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
@@ -6114,21 +6114,21 @@
%local assignments made by the \meta{function} or \meta{code} discussed
%below remain in effect after the loop.
-%\begin{function}{\SeqVarMapFunction}
+%\begin{function}{\seqVarMapFunction}
%\begin{syntax}
-%\cs{SeqVarMapFunction} \meta{sequence} \meta{function}
+%\cs{seqVarMapFunction} \meta{sequence} \meta{function}
%\end{syntax}
%Applies \meta{function} to every \meta{item} stored in the
%\meta{sequence}. The \meta{function} will receive one argument for
%each iteration. The \meta{items} are returned from left to right.
-%To pass further arguments to the \meta{function}, see \cs{SeqVarMapTokens}.
-%The function \cs{SeqVarMapInline} is faster than
-%\cs{SeqVarMapFunction} for sequences with more than about $10$ items.
+%To pass further arguments to the \meta{function}, see \cs{seqVarMapTokens}.
+%The function \cs{seqVarMapInline} is faster than
+%\cs{seqVarMapFunction} for sequences with more than about $10$ items.
%\end{function}
-\begin{function}{\SeqVarMapInline}
+\begin{function}{\seqVarMapInline}
\begin{syntax}
-\cs{SeqVarMapInline} \meta{sequence} \Arg{inline function}
+\cs{seqVarMapInline} \meta{sequence} \Arg{inline function}
\end{syntax}
Applies \meta{inline function} to every \meta{item} stored
within the \meta{sequence}. The \meta{inline function} should
@@ -6136,35 +6136,35 @@
The \meta{items} are returned from left to right.
\begin{demohigh}
\IgnoreSpacesOn
-\SeqSetFromClist \lTmpkSeq {one,two,three}
-\TlClear \lTmpaTl
-\SeqVarMapInline \lTmpkSeq {
- \TlPutRight \lTmpaTl {(#1)}
+\seqSetFromClist \lTmpkSeq {one,two,three}
+\tlClear \lTmpaTl
+\seqVarMapInline \lTmpkSeq {
+ \tlPutRight \lTmpaTl {(#1)}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\SeqVarMapTokens}
+%\begin{function}{\seqVarMapTokens}
%\begin{syntax}
-%\cs{SeqVarMapTokens} \meta{sequence} \Arg{code}
+%\cs{seqVarMapTokens} \meta{sequence} \Arg{code}
%\end{syntax}
-%Analogue of \cs{SeqVarMapFunction} which maps several tokens
+%Analogue of \cs{seqVarMapFunction} which maps several tokens
%instead of a single function. The \meta{code} receives each item in
%the \meta{sequence} as a trailing brace group. For instance,
%\begin{verbatim}
-%\SeqVarMapTokens \lMySeq { \PrgReplicate { 2 } }
+%\seqVarMapTokens \lMySeq { \prgReplicate { 2 } }
%\end{verbatim}
%expands to twice each item in the \meta{sequence}: for each item in
%\verb|\l_my_seq| the function \cs{PrgReplicate} receives \verb|2| and
%\meta{item} as its two arguments. The function
-%\cs{SeqVarMapInline} is typically faster but it is not expandable.
+%\cs{seqVarMapInline} is typically faster but it is not expandable.
%\end{function}
-\begin{function}{\SeqVarMapVariable}
+\begin{function}{\seqVarMapVariable}
\begin{syntax}
-\cs{SeqVarMapVariable} \meta{sequence} \meta{variable} \Arg{code}
+\cs{seqVarMapVariable} \meta{sequence} \meta{variable} \Arg{code}
\end{syntax}
Stores each \meta{item} of the \meta{sequence} in turn in the (token
list) \meta{variable} and applies the \meta{code}. The \meta{code}
@@ -6175,19 +6175,19 @@
\meta{items} are returned from left to right.
\begin{demohigh}
\IgnoreSpacesOn
-\IntZero \lTmpaInt
-\SeqSetFromClist \lTmpaSeq {1,3,7}
-\SeqVarMapVariable \lTmpaSeq \lTmpiTl {
- \IntAdd \lTmpaInt {\lTmpiTl*\lTmpiTl}
+\intZero \lTmpaInt
+\seqSetFromClist \lTmpaSeq {1,3,7}
+\seqVarMapVariable \lTmpaSeq \lTmpiTl {
+ \intAdd \lTmpaInt {\lTmpiTl*\lTmpiTl}
}
-\IntUse \lTmpaInt
+\intUse \lTmpaInt
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\SeqVarMapIndexedFunction}
+%\begin{function}{\seqVarMapIndexedFunction}
%\begin{syntax}
-%\cs{SeqVarMapIndexedFunction} \meta{seq var} \meta{function}
+%\cs{seqVarMapIndexedFunction} \meta{seq var} \meta{function}
%\end{syntax}
%Applies \meta{function} to every entry in the \meta{sequence
%variable}. The \meta{function} should have signature |:nn|. It
@@ -6195,9 +6195,9 @@
%\verb|1| for the first entry, then \verb|2| and so on) and the \meta{item}.
%\end{function}
-%\begin{function}{\SeqVarMapIndexedInline}
+%\begin{function}{\seqVarMapIndexedInline}
%\begin{syntax}
-%\cs{SeqVarMapIndexedInline} \meta{seq var} \Arg{inline function}
+%\cs{seqVarMapIndexedInline} \meta{seq var} \Arg{inline function}
%\end{syntax}
%Applies \meta{inline function} to every entry in the \meta{sequence
%variable}. The \meta{inline function} should consist of code which
@@ -6205,9 +6205,9 @@
%and so on) as \verb|#1| and the \meta{item} as \verb|#2|.
%\end{function}
-%\begin{function}{\SeqMapBreak}
+%\begin{function}{\seqMapBreak}
%\begin{syntax}
-%\cs{SeqMapBreak}
+%\cs{seqMapBreak}
%\end{syntax}
%Used to terminate a seq map function before all
%entries in the \meta{sequence} have been processed. This
@@ -6232,9 +6232,9 @@
%\end{texnote}
%\end{function}
-%\begin{function}{\SeqMapBreakDo}
+%\begin{function}{\seqMapBreakDo}
%\begin{syntax}
-%\cs{SeqMapBreakDo} \Arg{code}
+%\cs{seqMapBreakDo} \Arg{code}
%\end{syntax}
%Used to terminate a seq map function before all
%entries in the \meta{sequence} have been processed, inserting
@@ -6296,49 +6296,49 @@
\section{Sequence Conditionals}
-\begin{function}{\SeqIfExist,\SeqIfExistT,\SeqIfExistF,\SeqIfExistTF}
+\begin{function}{\seqIfExist,\seqIfExistT,\seqIfExistF,\seqIfExistTF}
\begin{syntax}
-\cs{SeqIfExist} \meta{sequence}
-\cs{SeqIfExistT} \meta{sequence} \Arg{true code}
-\cs{SeqIfExistF} \meta{sequence} \Arg{false code}
-\cs{SeqIfExistTF} \meta{sequence} \Arg{true code} \Arg{false code}
+\cs{seqIfExist} \meta{sequence}
+\cs{seqIfExistT} \meta{sequence} \Arg{true code}
+\cs{seqIfExistF} \meta{sequence} \Arg{false code}
+\cs{seqIfExistTF} \meta{sequence} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{sequence} is currently defined. This does not
check that the \meta{sequence} really is a sequence variable.
\begin{demohigh}
-\SeqIfExistTF \lTmpaSeq {\Return{Yes}} {\Return{No}}
-\SeqIfExistTF \lFooUndefinedSeq {\Return{Yes}} {\Return{No}}
+\seqIfExistTF \lTmpaSeq {\prgReturn{Yes}} {\prgReturn{No}}
+\seqIfExistTF \lFooUndefinedSeq {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqVarIfEmpty,\SeqVarIfEmptyT,\SeqVarIfEmptyF,\SeqVarIfEmptyTF}
+\begin{function}{\seqVarIfEmpty,\seqVarIfEmptyT,\seqVarIfEmptyF,\seqVarIfEmptyTF}
\begin{syntax}
-\cs{SeqVarIfEmpty} \meta{sequence}
-\cs{SeqVarIfEmptyT} \meta{sequence} \Arg{true code}
-\cs{SeqVarIfEmptyF} \meta{sequence} \Arg{false code}
-\cs{SeqVarIfEmptyTF} \meta{sequence} \Arg{true code} \Arg{false code}
+\cs{seqVarIfEmpty} \meta{sequence}
+\cs{seqVarIfEmptyT} \meta{sequence} \Arg{true code}
+\cs{seqVarIfEmptyF} \meta{sequence} \Arg{false code}
+\cs{seqVarIfEmptyTF} \meta{sequence} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{sequence} is empty (containing no items).
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two}
-\SeqVarIfEmptyTF \lTmpaSeq {\Return{Empty}} {\Return{NonEmpty}}
-\SeqClear \lTmpaSeq
-\SeqVarIfEmptyTF \lTmpaSeq {\Return{Empty}} {\Return{NonEmpty}}
+\seqSetFromClist \lTmpaSeq {one,two}
+\seqVarIfEmptyTF \lTmpaSeq {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\seqClear \lTmpaSeq
+\seqVarIfEmptyTF \lTmpaSeq {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\SeqVarIfIn,\SeqVarIfInT,\SeqVarIfInF,\SeqVarIfInTF}
+\begin{function}{\seqVarIfIn,\seqVarIfInT,\seqVarIfInF,\seqVarIfInTF}
\begin{syntax}
-\cs{SeqVarIfIn} \meta{sequence} \Arg{item}
-\cs{SeqVarIfInT} \meta{sequence} \Arg{item} \Arg{true code}
-\cs{SeqVarIfInF} \meta{sequence} \Arg{item} \Arg{false code}
-\cs{SeqVarIfInTF} \meta{sequence} \Arg{item} \Arg{true code} \Arg{false code}
+\cs{seqVarIfIn} \meta{sequence} \Arg{item}
+\cs{seqVarIfInT} \meta{sequence} \Arg{item} \Arg{true code}
+\cs{seqVarIfInF} \meta{sequence} \Arg{item} \Arg{false code}
+\cs{seqVarIfInTF} \meta{sequence} \Arg{item} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{item} is present in the \meta{sequence}.
\begin{demohigh}
-\SeqSetFromClist \lTmpaSeq {one,two}
-\SeqVarIfInTF \lTmpaSeq {one} {\Return{Yes}} {\Return{Not}}
-\SeqVarIfInTF \lTmpaSeq {three} {\Return{Yes}} {\Return{Not}}
+\seqSetFromClist \lTmpaSeq {one,two}
+\seqVarIfInTF \lTmpaSeq {one} {\prgReturn{Yes}} {\prgReturn{Not}}
+\seqVarIfInTF \lTmpaSeq {three} {\prgReturn{Yes}} {\prgReturn{Not}}
\end{demohigh}
\end{function}
@@ -6348,7 +6348,7 @@
an unordered list of entries each of which consists of a \meta{key} and
an associated \meta{value}. The \meta{key} and \meta{value} may both
be any \meta{balanced text}, the \meta{key} is processed using
-\cs{TlToStr}, meaning that category codes are ignored. It is possible to
+\cs{tlToStr}, meaning that category codes are ignored. It is possible to
map functions to property lists such that the function is applied to every
key--value pair within the list.
@@ -6355,7 +6355,7 @@
Each entry in a property list must have a unique \meta{key}: if an entry is
added to a property list which already contains the \meta{key} then the new
entry overwrites the existing one. The \meta{keys} are compared on a
-string basis, using the same method as \cs{StrIfEq}.
+string basis, using the same method as \cs{strIfEq}.
%Property lists are intended for storing key-based information for use within
%code. This is in contrast to key--value lists, which are a form of
@@ -6383,43 +6383,43 @@
\section{Creating and Using Property Lists}
-\begin{function}{\PropNew}
+\begin{function}{\propNew}
\begin{syntax}
-\cs{PropNew} \meta{property list}
+\cs{propNew} \meta{property list}
\end{syntax}
Creates a new \meta{property list} or raises an error if the name is
already taken. The declaration is global. The \meta{property list}
initially contains no entries.
\begin{codehigh}
-\PropNew \lFooSomeProp
+\propNew \lFooSomeProp
\end{codehigh}
\end{function}
-\begin{function}{\PropConstFromKeyval}
+\begin{function}{\propConstFromKeyval}
\begin{syntax}
-\cs{PropConstFromKeyval} \meta{prop var}
-\{
-~ \meta{key1} \verb|=| \meta{value1} \verb|,|
-~ \meta{key2} \verb|=| \meta{value2} \verb|,| $\cdots$
-\}
+\cs{propConstFromKeyval} \meta{prop var}
+~ \{
+~ ~ \meta{key1} \verb|=| \meta{value1} \verb|,|
+~ ~ \meta{key2} \verb|=| \meta{value2} \verb|,| $\cdots$
+~ \}
\end{syntax}
Creates a new constant \meta{prop var} or raises an error if the
name is already taken. The \meta{prop var} is set globally to
contain key--value pairs given in the second argument, processed in
-the way described for \cs{PropSetFromKeyval}. If duplicate
+the way described for \cs{propSetFromKeyval}. If duplicate
keys appear only the last of the values is kept.
This function correctly detects the \verb|=| and \verb|,| signs provided they
have the standard category code $12$ or they are active.
\begin{codehigh}
-\PropConstFromKeyval \cFooSomeProp {key1=one,key2=two,key3=three}
+\propConstFromKeyval \cFooSomeProp {key1=one,key2=two,key3=three}
\end{codehigh}
%Notice that in contrast to most keyval lists (\emph{e.g.} those in
%\pkg{l3keys}), each key here \emph{must} be followed with an \texttt{=} sign.
\end{function}
-\begin{function}{\PropToKeyval}
+\begin{function}{\propToKeyval}
\begin{syntax}
-\cs{PropToKeyval} \meta{property list}
+\cs{propToKeyval} \meta{property list}
\end{syntax}
Returns the \meta{property list} in a key--value notation. Keep in mind
that a \meta{property list} is \emph{unordered}, while key--value interfaces
@@ -6431,37 +6431,37 @@
%It also needs exactly two steps of expansion.
%\end{texnote}
\begin{codehigh}
-\PropToKeyval \lTmpaProp
+\propToKeyval \lTmpaProp
\end{codehigh}
\end{function}
\section{Viewing Property Lists}
-\begin{function}{\PropVarLog}
+\begin{function}{\propVarLog}
\begin{syntax}
-\cs{PropVarLog} \meta{property list}
+\cs{propVarLog} \meta{property list}
\end{syntax}
Writes the entries in the \meta{property list} in the log file.
\begin{codehigh}
-\PropVarLog \lTmpaProp
+\propVarLog \lTmpaProp
\end{codehigh}
\end{function}
-\begin{function}{\PropVarShow}
+\begin{function}{\propVarShow}
\begin{syntax}
-\cs{PropVarShow} \meta{property list}
+\cs{propVarShow} \meta{property list}
\end{syntax}
Displays the entries in the \meta{property list} in the terminal.
\begin{codehigh}
-\PropVarShow \lTmpaProp
+\propVarShow \lTmpaProp
\end{codehigh}
\end{function}
\section{Setting Property Lists}
-\begin{function}{\PropSetFromKeyval}
+\begin{function}{\propSetFromKeyval}
\begin{syntax}
-\cs{PropSetFromKeyval} \meta{prop var}
+\cs{propSetFromKeyval} \meta{prop var}
\{
~ \meta{key1} \verb|=| \meta{value1} \verb|,|
~ \meta{key2} \verb|=| \meta{value2} \verb|,| $\cdots$
@@ -6474,53 +6474,53 @@
and if the result of trimming spaces consists of a single brace
group then a set of outer braces is removed. This enables both the
\meta{key} and the \meta{value} to contain spaces, commas or equal
-signs. The \meta{key} is then processed by \cs{TlToStr}.
+signs. The \meta{key} is then processed by \cs{tlToStr}.
This function correctly detects the \verb|=| and \verb|,| signs provided they
have the standard category code $12$ or they are active.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
\end{codehigh}
%Notice that in contrast to most keyval lists (\emph{e.g.} those in
%\pkg{l3keys}), each key here \emph{must} be followed with an \texttt{=} sign.
\end{function}
-\begin{function}{\PropSetEq}
+\begin{function}{\propSetEq}
\begin{syntax}
-\cs{PropSetEq} \meta{property list_1} \meta{property list_2}
+\cs{propSetEq} \meta{property list_1} \meta{property list_2}
\end{syntax}
Sets the content of \meta{property list_1} equal to that of
\meta{property list_2}.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropSetEq \lTmpbProp \lTmpaProp
-\PropVarLog \lTmpbProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propSetEq \lTmpbProp \lTmpaProp
+\propVarLog \lTmpbProp
\end{codehigh}
\end{function}
-\begin{function}{\PropClear}
+\begin{function}{\propClear}
\begin{syntax}
-\cs{PropClear} \meta{property list}
+\cs{propClear} \meta{property list}
\end{syntax}
Clears all entries from the \meta{property list}.
\begin{codehigh}
-\PropClear \lTmpaProp
+\propClear \lTmpaProp
\end{codehigh}
\end{function}
-\begin{function}{\PropClearNew}
+\begin{function}{\propClearNew}
\begin{syntax}
-\cs{PropClearNew} \meta{property list}
+\cs{propClearNew} \meta{property list}
\end{syntax}
-Ensures that the \meta{property list} exists globally by applying \cs{PropNew}
-if necessary, then applies \cs{PropClear} to leave the list empty.
+Ensures that the \meta{property list} exists globally by applying \cs{propNew}
+if necessary, then applies \cs{propClear} to leave the list empty.
\begin{codehigh}
-\PropClearNew \lFooSomeProp
+\propClearNew \lFooSomeProp
\end{codehigh}
\end{function}
-\begin{function}{\PropConcat}
+\begin{function}{\propConcat}
\begin{syntax}
-\cs{PropConcat} \meta{prop var_1} \meta{prop var_2} \meta{prop var_3}
+\cs{propConcat} \meta{prop var_1} \meta{prop var_2} \meta{prop var_3}
\end{syntax}
Combines the key--value pairs of \meta{prop var_2} and
\meta{prop var_3}, and saves the result in \meta{prop var_1}. If a
@@ -6527,16 +6527,16 @@
key appears in both \meta{prop var_2} and \meta{prop var_3} then the
last value, namely the value in \meta{prop var_3} is kept.
\begin{codehigh}
-\PropSetFromKeyval \lTmpbProp {key1=one,key2=two}
-\PropSetFromKeyval \lTmpcProp {key3=three,key4=four}
-\PropConcat \lTmpaProp \lTmpbProp \lTmpcProp
-\PropVarLog \lTmpaProp
+\propSetFromKeyval \lTmpbProp {key1=one,key2=two}
+\propSetFromKeyval \lTmpcProp {key3=three,key4=four}
+\propConcat \lTmpaProp \lTmpbProp \lTmpcProp
+\propVarLog \lTmpaProp
\end{codehigh}
\end{function}
-\begin{function}{\PropPut}
+\begin{function}{\propPut}
\begin{syntax}
-\cs{PropPut} \meta{property list} \Arg{key} \Arg{value}
+\cs{propPut} \meta{property list} \Arg{key} \Arg{value}
\end{syntax}
Adds an entry to the \meta{property list} which may be accessed
using the \meta{key} and which has \meta{value}. If the \meta{key}
@@ -6543,32 +6543,32 @@
is already present in the \meta{property list}, the existing entry
is overwritten by the new \meta{value}. Both the \meta{key} and
\meta{value} may contain any \meta{balanced text}. The \meta{key} is
-stored after processing with \cs{TlToStr}, meaning that category
+stored after processing with \cs{tlToStr}, meaning that category
codes are ignored.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropPut \lTmpaProp {key1} {newone}
-\PropVarLog \lTmpaProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propPut \lTmpaProp {key1} {newone}
+\propVarLog \lTmpaProp
\end{codehigh}
\end{function}
-\begin{function}{\PropPutIfNew}
+\begin{function}{\propPutIfNew}
\begin{syntax}
-\cs{PropPutIfNew} \meta{property list} \Arg{key} \Arg{value}
+\cs{propPutIfNew} \meta{property list} \Arg{key} \Arg{value}
\end{syntax}
If the \meta{key} is present in the \meta{property list} then no
action is taken. Otherwise, a new entry is added as described for
-\cs{PropPut}.
+\cs{propPut}.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropPutIfNew \lTmpaProp {key1} {newone}
-\PropVarLog \lTmpaProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propPutIfNew \lTmpaProp {key1} {newone}
+\propVarLog \lTmpaProp
\end{codehigh}
\end{function}
-\begin{function}{\PropPutFromKeyval}
+\begin{function}{\propPutFromKeyval}
\begin{syntax}
-\cs{PropPutFromKeyval} \meta{prop var}
+\cs{propPutFromKeyval} \meta{prop var}
\{
~ \meta{key1} \verb|=| \meta{value1} \verb|,|
~ \meta{key2} \verb|=| \meta{value2} \verb|,| $\cdots$
@@ -6576,28 +6576,28 @@
\end{syntax}
Updates the \meta{prop var} by adding entries for each key--value
pair given in the second argument. The addition is done through
-\cs{PropPut}, hence if the \meta{prop var} already contains
+\cs{propPut}, hence if the \meta{prop var} already contains
some of the keys, the corresponding values are discarded and
replaced by those given in the key--value list. If duplicate keys
appear in the key--value list then only the last of the values is kept.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropPutFromKeyval \lTmpaProp {key1=newone,key3=three}
-\PropVarLog \lTmpaProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propPutFromKeyval \lTmpaProp {key1=newone,key3=three}
+\propVarLog \lTmpaProp
\end{codehigh}
%The function is equivalent to storing the key--value pairs in a
-%temporary property variable using \cs{PropSetFromKeyval}, then
+%temporary property variable using \cs{propSetFromKeyval}, then
%combining \meta{prop var} with the temporary variable using
-%\cs{PropConcat}. In particular, the \meta{keys} and
+%\cs{propConcat}. In particular, the \meta{keys} and
%\meta{values} are space-trimmed and unbraced as described in
-%\cs{PropSetFromKeyval}. This function correctly detects
+%\cs{propSetFromKeyval}. This function correctly detects
%the \verb|=| and \verb|,| signs provided they
%have the standard category code $12$ or they are active.
\end{function}
-\begin{function}{\PropVarRemove}
+\begin{function}{\propVarRemove}
\begin{syntax}
-\cs{PropVarRemove} \meta{property list} \Arg{key}
+\cs{propVarRemove} \meta{property list} \Arg{key}
\end{syntax}
Removes the entry listed under \meta{key} from the
\meta{property list}. If the \meta{key} is
@@ -6605,37 +6605,37 @@
\emph{i.e} there is no need to test for the existence of a key before
deleting it.
\begin{codehigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropVarRemove \lTmpaProp {key2}
-\PropVarLog \lTmpaProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propVarRemove \lTmpaProp {key2}
+\propVarLog \lTmpaProp
\end{codehigh}
\end{function}
\section{Recovering Values from Property Lists}
-\begin{function}{\PropVarCount}
+\begin{function}{\propVarCount}
\begin{syntax}
-\cs{PropVarCount} \meta{property list}
+\cs{propVarCount} \meta{property list}
\end{syntax}
Returns the number of key--value pairs in the \meta{property list}
as an \meta{integer denotation}.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropVarCount \lTmpaProp
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propVarCount \lTmpaProp
\end{demohigh}
\end{function}
-\begin{function}{\PropVarItem}
+\begin{function}{\propVarItem}
\begin{syntax}
-\cs{PropVarItem} \meta{property list} \Arg{key}
+\cs{propVarItem} \meta{property list} \Arg{key}
\end{syntax}
Returns the \meta{value} corresponding to the \meta{key} in
the \meta{property list}. If the \meta{key} is missing,
nothing is returned.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\TlSet \lTmpaTl {\PropVarItem \lTmpaProp {key2}}
-\TlUse \lTmpaTl
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\tlSet \lTmpaTl {\propVarItem \lTmpaProp {key2}}
+\tlUse \lTmpaTl
\end{demohigh}
%\begin{texnote}
%This function is slower than the non-expandable analogue
@@ -6647,9 +6647,9 @@
%\end{texnote}
\end{function}
-\begin{function}{\PropGet}
+\begin{function}{\propGet}
\begin{syntax}
-\cs{PropGet} \meta{property list} \Arg{key} \meta{token list variable}
+\cs{propGet} \meta{property list} \Arg{key} \meta{token list variable}
\end{syntax}
Recovers the \meta{value} stored with \meta{key} from the \meta{property list},
and places this in the \meta{token list variable}.
@@ -6658,17 +6658,17 @@
to the special marker \cs{qNoValue}.
The assignment of the \meta{token list variable} is local.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropGet \lTmpaProp {key2} \lTmpaTl
-\TlUse \lTmpaTl
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propGet \lTmpaProp {key2} \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
\end{function}
-\begin{function}{\PropGetT,\PropGetF,\PropGetTF}
+\begin{function}{\propGetT,\propGetF,\propGetTF}
\begin{syntax}
-\cs{PropGetT} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code}
-\cs{PropGetF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{false code}
-\cs{PropGetTF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{propGetT} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code}
+\cs{propGetF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{false code}
+\cs{propGetTF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{key} is not present in the \meta{property list}, leaves
the \meta{false code} in the input stream. The value of the
@@ -6679,14 +6679,14 @@
\meta{property list}, then leaves the \meta{true code} in the input
stream. The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropGetTF \lTmpaProp {key2} \lTmpaTl {\Return{Yes}} {\Return{No}}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propGetTF \lTmpaProp {key2} \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\PropPop}
+\begin{function}{\propPop}
\begin{syntax}
-\cs{PropPop} \meta{property list} \Arg{key} \meta{token list variable}
+\cs{propPop} \meta{property list} \Arg{key} \meta{token list variable}
\end{syntax}
Recovers the \meta{value} stored with \meta{key} from the \meta{property list},
and places this in the \meta{token list variable}.
@@ -6696,18 +6696,18 @@
The \meta{key} and \meta{value} are then deleted from the property list.
The assignment of the \meta{token list variable} is local.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropPop \lTmpaProp {key2} \lTmpaTl
-Pop: \TlUse \lTmpaTl.
-Count: \PropVarCount \lTmpaProp.
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propPop \lTmpaProp {key2} \lTmpaTl
+Pop: \tlUse \lTmpaTl.
+Count: \propVarCount \lTmpaProp.
\end{demohigh}
\end{function}
-\begin{function}{\PropPopT,\PropPopF,\PropPopTF}
+\begin{function}{\propPopT,\propPopF,\propPopTF}
\begin{syntax}
-\cs{PropPopT} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code}
-\cs{PropPopF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{false code}
-\cs{PropPopTF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code} \Arg{false code}
+\cs{propPopT} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code}
+\cs{propPopF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{false code}
+\cs{propPopTF} \meta{property list} \Arg{key} \meta{token list variable} \Arg{true code} \Arg{false code}
\end{syntax}
If the \meta{key} is not present in the \meta{property list}, leaves
the \meta{false code} in the input stream. The value of the
@@ -6717,8 +6717,8 @@
in the \meta{token list variable}, \emph{i.e.} removes the item from
The \meta{token list variable} is assigned locally.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
-\PropPopTF \lTmpaProp {key2} \lTmpaTl {\Return{Yes}} {\Return{No}}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two,key3=three}
+\propPopTF \lTmpaProp {key2} \lTmpaTl {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
@@ -6728,9 +6728,9 @@
%local assignments made by the \meta{function} or \meta{code} discussed
%below remain in effect after the loop.
-%\begin{function}{\PropVarMapFunction}
+%\begin{function}{\propVarMapFunction}
%\begin{syntax}
-%\cs{PropVarMapFunction} \meta{property list} \meta{function}
+%\cs{propVarMapFunction} \meta{property list} \meta{function}
%\end{syntax}
%Applies \meta{function} to every \meta{entry} stored in the
%\meta{property list}. The \meta{function} receives two arguments for
@@ -6741,9 +6741,9 @@
%\cs{prop_map_tokens:Nn}.
%\end{function}
-\begin{function}{\PropVarMapInline}
+\begin{function}{\propVarMapInline}
\begin{syntax}
-\cs{PropVarMapInline} \meta{property list} \Arg{inline function}
+\cs{propVarMapInline} \meta{property list} \Arg{inline function}
\end{syntax}
Applies \meta{inline function} to every \meta{entry} stored
within the \meta{property list}. The \meta{inline function} should
@@ -6753,36 +6753,36 @@
should not be relied upon.
\begin{demohigh}
\IgnoreSpacesOn
-\PropSetFromKeyval \lTmpkProp {key1=one,key2=two,key3=three}
-\TlClear \lTmpaTl
-\PropVarMapInline \lTmpkProp {
- \TlPutRight \lTmpaTl {(#1=#2)}
+\propSetFromKeyval \lTmpkProp {key1=one,key2=two,key3=three}
+\tlClear \lTmpaTl
+\propVarMapInline \lTmpkProp {
+ \tlPutRight \lTmpaTl {(#1=#2)}
}
-\TlUse \lTmpaTl
+\tlUse \lTmpaTl
\IgnoreSpacesOff
\end{demohigh}
\end{function}
-%\begin{function}{\PropVarMapTokens}
+%\begin{function}{\propVarMapTokens}
%\begin{syntax}
-%\cs{PropVarMapTokens} \meta{property list} \Arg{code}
+%\cs{propVarMapTokens} \meta{property list} \Arg{code}
%\end{syntax}
-%Analogue of \cs{PropVarMapFunction} which maps several tokens
+%Analogue of \cs{propVarMapFunction} which maps several tokens
%instead of a single function. The \meta{code} receives each
%key--value pair in the \meta{property list} as two trailing brace
%groups. For instance,
%\begin{verbatim}
-%\PropVarMapTokens \lMyProp { \StrIfEqT { mykey } }
+%\propVarMapTokens \lMyProp { \strIfEqT { mykey } }
%\end{verbatim}
%expands to the value corresponding to \texttt{mykey}: for each
-%pair in \verb|\lMyProp| the function \cs{StrIfEqT} receives
+%pair in \verb|\lMyProp| the function \cs{strIfEqT} receives
%\texttt{mykey}, the \meta{key} and the \meta{value} as its three
-%arguments. For that specific task, \cs{PropVarItem} is faster.
+%arguments. For that specific task, \cs{propVarItem} is faster.
%\end{function}
-%\begin{function}{\PropMapBreak}
+%\begin{function}{\propMapBreak}
%\begin{syntax}
-%\cs{PropMapBreak}
+%\cs{propMapBreak}
%\end{syntax}
%Used to terminate a prop map function before all
%entries in the \meta{property list} have been processed. This
@@ -6807,9 +6807,9 @@
%\end{texnote}
%\end{function}
-%\begin{function}{\PropMapBreakDo}
+%\begin{function}{\propMapBreakDo}
%\begin{syntax}
-%\cs{PropMapBreakDo} \Arg{code}
+%\cs{propMapBreakDo} \Arg{code}
%\end{syntax}
%Used to terminate a prop map function before all
%entries in the \meta{property list} have been processed, inserting
@@ -6837,54 +6837,54 @@
\section{Property List Conditionals}
-\begin{function}{\PropIfExist,\PropIfExistT,\PropIfExistF,\PropIfExistTF}
+\begin{function}{\propIfExist,\propIfExistT,\propIfExistF,\propIfExistTF}
\begin{syntax}
-\cs{PropIfExist} \meta{property list}
-\cs{PropIfExistT} \meta{property list} \Arg{true code}
-\cs{PropIfExistF} \meta{property list} \Arg{false code}
-\cs{PropIfExistTF} \meta{property list} \Arg{true code} \Arg{false code}
+\cs{propIfExist} \meta{property list}
+\cs{propIfExistT} \meta{property list} \Arg{true code}
+\cs{propIfExistF} \meta{property list} \Arg{false code}
+\cs{propIfExistTF} \meta{property list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{property list} is currently defined. This does not
check that the \meta{property list} really is a property list variable.
\begin{demohigh}
-\PropIfExistTF \lTmpaProp {\Return{Yes}} {\Return{No}}
-\PropIfExistTF \lFooUndefinedProp {\Return{Yes}} {\Return{No}}
+\propIfExistTF \lTmpaProp {\prgReturn{Yes}} {\prgReturn{No}}
+\propIfExistTF \lFooUndefinedProp {\prgReturn{Yes}} {\prgReturn{No}}
\end{demohigh}
\end{function}
-\begin{function}{\PropVarIfEmpty,\PropVarIfEmptyT,\PropVarIfEmptyF,\PropVarIfEmptyTF}
+\begin{function}{\propVarIfEmpty,\propVarIfEmptyT,\propVarIfEmptyF,\propVarIfEmptyTF}
\begin{syntax}
-\cs{PropVarIfEmpty} \meta{property list}
-\cs{PropVarIfEmptyT} \meta{property list} \Arg{true code}
-\cs{PropVarIfEmptyF} \meta{property list} \Arg{false code}
-\cs{PropVarIfEmptyTF} \meta{property list} \Arg{true code} \Arg{false code}
+\cs{propVarIfEmpty} \meta{property list}
+\cs{propVarIfEmptyT} \meta{property list} \Arg{true code}
+\cs{propVarIfEmptyF} \meta{property list} \Arg{false code}
+\cs{propVarIfEmptyTF} \meta{property list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{property list} is empty (containing no entries).
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropVarIfEmptyTF \lTmpaProp {\Return{Empty}} {\Return{NonEmpty}}
-\PropClear \lTmpaProp
-\PropVarIfEmptyTF \lTmpaProp {\Return{Empty}} {\Return{NonEmpty}}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propVarIfEmptyTF \lTmpaProp {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
+\propClear \lTmpaProp
+\propVarIfEmptyTF \lTmpaProp {\prgReturn{Empty}} {\prgReturn{NonEmpty}}
\end{demohigh}
\end{function}
-\begin{function}{\PropVarIfIn,\PropVarIfInT,\PropVarIfInF,\PropVarIfInTF}
+\begin{function}{\propVarIfIn,\propVarIfInT,\propVarIfInF,\propVarIfInTF}
\begin{syntax}
-\cs{PropVarIfIn} \meta{property list} \Arg{key}
-\cs{PropVarIfInT} \meta{property list} \Arg{key} \Arg{true code}
-\cs{PropVarIfInF} \meta{property list} \Arg{key} \Arg{false code}
-\cs{PropVarIfInTF} \meta{property list} \Arg{key} \Arg{true code} \Arg{false code}
+\cs{propVarIfIn} \meta{property list} \Arg{key}
+\cs{propVarIfInT} \meta{property list} \Arg{key} \Arg{true code}
+\cs{propVarIfInF} \meta{property list} \Arg{key} \Arg{false code}
+\cs{propVarIfInTF} \meta{property list} \Arg{key} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{key} is present in the \meta{property list},
-making the comparison using the method described by \cs{StrIfEqTF}.
+making the comparison using the method described by \cs{strIfEqTF}.
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropVarIfInTF \lTmpaProp {key1} {\Return{Yes}} {\Return{Not}}
-\PropVarIfInTF \lTmpaProp {key3} {\Return{Yes}} {\Return{Not}}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propVarIfInTF \lTmpaProp {key1} {\prgReturn{Yes}} {\prgReturn{Not}}
+\propVarIfInTF \lTmpaProp {key3} {\prgReturn{Yes}} {\prgReturn{Not}}
\end{demohigh}
%\begin{texnote}
%This function iterates through every key--value pair in the
-%\meta{property list} and is therefore slower than using \cs{PropGetTF}.
+%\meta{property list} and is therefore slower than using \cs{propGetTF}.
%\end{texnote}
\end{function}
@@ -6903,16 +6903,16 @@
occurrence of \enquote{\texttt{at}} with \enquote{\texttt{is}}
in the token list variable \cs{lTmpaTl}.
\begin{demohigh}
-\TlSet \lTmpaTl {That cat.}
-\RegexReplaceOnce {at} {is} \lTmpaTl
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {That cat.}
+\regexReplaceOnce {at} {is} \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
A more complicated example is
a pattern to emphasize each word and add a comma after it:
\begin{demohigh}
-\TlSet \lTmpaTl {That cat.}
-\RegexReplaceAll {\w+} {\c{underline} \cB\{ \0 \cE\} ,} \lTmpaTl
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {That cat.}
+\regexReplaceAll {\w+} {\c{underline} \cB\{ \0 \cE\} ,} \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
The |\w| sequence represents any \enquote{word} character, and |+|
indicates that the |\w| sequence should be repeated as many times as
@@ -6923,10 +6923,10 @@
If a regular expression is to be used several times,
it can be compiled once, and stored in a regex
-variable using \cs{RegexSet}. For example,
+variable using \cs{regexSet}. For example,
\begin{codehigh}
-\RegexNew \lFooRegex
-\RegexSet \lFooRegex {\c{begin} \cB. (\c[^BE].*) \cE.}
+\regexNew \lFooRegex
+\regexSet \lFooRegex {\c{begin} \cB. (\c[^BE].*) \cE.}
\end{codehigh}
stores in \cs{lFooRegex} a regular expression which matches the
starting marker for an environment: \cs[no-index]{begin}, followed by a
@@ -6961,9 +6961,9 @@
code and so should only be used for short-term storage.
\end{variable}
-\begin{function}{\RegexNew}
+\begin{function}{\regexNew}
\begin{syntax}
-\cs{RegexNew} \meta{regex var}
+\cs{regexNew} \meta{regex var}
\end{syntax}
Creates a new \meta{regex var} or raises an error if the
name is already taken. The declaration is global. The
@@ -6970,22 +6970,22 @@
\meta{regex var} is initially such that it never matches.
\end{function}
-\begin{function}{\RegexSet}
+\begin{function}{\regexSet}
\begin{syntax}
-\cs{RegexSet} \meta{regex var} \Arg{regex}
+\cs{regexSet} \meta{regex var} \Arg{regex}
\end{syntax}
Stores a compiled version of the \meta{regular expression} in the
\meta{regex var}. For instance, this function can be
used as
\begin{codehigh}
-\RegexNew \lMyRegex
-\RegexSet \lMyRegex {my\ (simple\ )? reg(ex|ular\ expression)}
+\regexNew \lMyRegex
+\regexSet \lMyRegex {my\ (simple\ )? reg(ex|ular\ expression)}
\end{codehigh}
\end{function}
-\begin{function}{\RegexConst}
+\begin{function}{\regexConst}
\begin{syntax}
-\cs{RegexConst} \meta{regex var} \Arg{regex}
+\cs{regexConst} \meta{regex var} \Arg{regex}
\end{syntax}
Creates a new constant \meta{regex var} or raises an error if the name
is already taken. The value of the \meta{regex var} is set
@@ -6992,16 +6992,16 @@
globally to the compiled version of the \meta{regular expression}.
\end{function}
-\begin{function}{\RegexLog,\RegexVarLog,\RegexShow,\RegexVarShow}
+\begin{function}{\regexLog,\regexVarLog,\regexShow,\regexVarShow}
\begin{syntax}
-\cs{RegexLog} \Arg{regex}
-\cs{RegexVarLog} \meta{regex var}
-\cs{RegexShow} \Arg{regex}
-\cs{RegexVarShow} \meta{regex var}
+\cs{regexLog} \Arg{regex}
+\cs{regexVarLog} \meta{regex var}
+\cs{regexShow} \Arg{regex}
+\cs{regexVarShow} \meta{regex var}
\end{syntax}
Displays in the terminal or writes in the log file (respectively)
how \pkg{l3regex} interprets the \meta{regex}. For instance,
-\cs{RegexShow} \verb+{\A X|Y}+ shows
+\cs{regexShow} \verb+{\A X|Y}+ shows
\begin{codehigh}
+-branch
anchor at start (\A)
@@ -7015,35 +7015,35 @@
\section{Regular Expression Matching}
-\begin{function}{\RegexMatch,\RegexMatchT,\RegexMatchF,\RegexMatchTF}
+\begin{function}{\regexMatch,\regexMatchT,\regexMatchF,\regexMatchTF}
\begin{syntax}
-\cs{RegexMatch} \Arg{regex} \Arg{token list}
-\cs{RegexMatchT} \Arg{regex} \Arg{token list} \Arg{true code}
-\cs{RegexMatchF} \Arg{regex} \Arg{token list} \Arg{false code}
-\cs{RegexMatchTF} \Arg{regex} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{regexMatch} \Arg{regex} \Arg{token list}
+\cs{regexMatchT} \Arg{regex} \Arg{token list} \Arg{true code}
+\cs{regexMatchF} \Arg{regex} \Arg{token list} \Arg{false code}
+\cs{regexMatchTF} \Arg{regex} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{regular expression} matches any part
of the \meta{token list}. For instance,
\begin{demohigh}
-\RegexMatchTF {b [cde]*} {abecdcx} {\Print{True}} {\Print{False}}
-\RegexMatchTF {[b-dq-w]} {example} {\Print{True}} {\Print{False}}
+\regexMatchTF {b [cde]*} {abecdcx} {\prgPrint{True}} {\prgPrint{False}}
+\regexMatchTF {[b-dq-w]} {example} {\prgPrint{True}} {\prgPrint{False}}
\end{demohigh}
\end{function}
-\begin{function}{\RegexVarMatch,\RegexVarMatchT,\RegexVarMatchF,\RegexVarMatchTF}
+\begin{function}{\regexVarMatch,\regexVarMatchT,\regexVarMatchF,\regexVarMatchTF}
\begin{syntax}
-\cs{RegexVarMatch} \meta{regex var} \Arg{token list}
-\cs{RegexVarMatchT} \meta{regex var} \Arg{token list} \Arg{true code}
-\cs{RegexVarMatchF} \meta{regex var} \Arg{token list} \Arg{false code}
-\cs{RegexVarMatchTF} \meta{regex var} \Arg{token list} \Arg{true code} \Arg{false code}
+\cs{regexVarMatch} \meta{regex var} \Arg{token list}
+\cs{regexVarMatchT} \meta{regex var} \Arg{token list} \Arg{true code}
+\cs{regexVarMatchF} \meta{regex var} \Arg{token list} \Arg{false code}
+\cs{regexVarMatchTF} \meta{regex var} \Arg{token list} \Arg{true code} \Arg{false code}
\end{syntax}
Tests whether the \meta{regex var} matches any part of the \meta{token list}.
\end{function}
-\begin{function}{\RegexCount,\RegexVarCount}
+\begin{function}{\regexCount,\regexVarCount}
\begin{syntax}
-\cs{RegexCount} \Arg{regex} \Arg{token list} \meta{int var}
-\cs{RegexVarCount} \meta{regex var} \Arg{token list} \meta{int var}
+\cs{regexCount} \Arg{regex} \Arg{token list} \meta{int var}
+\cs{regexVarCount} \meta{regex var} \Arg{token list} \meta{int var}
\end{syntax}
Sets \meta{int var} within the current \TeX{} group level
equal to the number of times
@@ -7056,15 +7056,15 @@
can match an empty token list: then we count one match between each
pair of characters. For instance,
\begin{demohigh}
-\IntNew \lFooInt
-\RegexCount {(b+|c)} {abbababcbb} \lFooInt
-\IntUse \lFooInt
+\intNew \lFooInt
+\regexCount {(b+|c)} {abbababcbb} \lFooInt
+\intUse \lFooInt
\end{demohigh}
\end{function}
-\begin{function}{\RegexMatchCase}
+\begin{function}{\regexMatchCase}
\begin{syntax}
-\cs{RegexMatchCase}
+\cs{regexMatchCase}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{code case_2}
@@ -7086,14 +7086,14 @@
position then the next starting position is attempted. If none of
the \meta{regex} match anywhere in the \meta{token list} then
nothing is left in the input stream. Note that this differs from
-nested \cs{RegexMatch} statements since all \meta{regex} are
+nested \cs{regexMatch} statements since all \meta{regex} are
attempted at each position rather than attempting to match
\meta{regex_1} at every position before moving on to \meta{regex_2}.
\end{function}
-\begin{function}{\RegexMatchCaseT}
+\begin{function}{\regexMatchCaseT}
\begin{syntax}
-\cs{RegexMatchCaseT}
+\cs{regexMatchCaseT}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{code case_2}
@@ -7111,9 +7111,9 @@
as a regex variable or as an explicit regular expression.
\end{function}
-\begin{function}{\RegexMatchCaseF}
+\begin{function}{\regexMatchCaseF}
\begin{syntax}
-\cs{RegexMatchCaseF}
+\cs{regexMatchCaseF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{code case_2}
@@ -7132,9 +7132,9 @@
as a regex variable or as an explicit regular expression.
\end{function}
-\begin{function}{\RegexMatchCaseTF}
+\begin{function}{\regexMatchCaseTF}
\begin{syntax}
-\cs{RegexMatchCaseTF}
+\cs{regexMatchCaseTF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{code case_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{code case_2}
@@ -7155,12 +7155,12 @@
\section{Regular Expression Submatch Extraction}
-\begin{function}{\RegexExtractOnce,\RegexExtractOnceT,\RegexExtractOnceF,\RegexExtractOnceTF}
+\begin{function}{\regexExtractOnce,\regexExtractOnceT,\regexExtractOnceF,\regexExtractOnceTF}
\begin{syntax}
-\cs{RegexExtractOnce} \Arg{regex} \Arg{token list} \meta{seq var}
-\cs{RegexExtractOnceT} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexExtractOnceF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexExtractOnceTF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexExtractOnce} \Arg{regex} \Arg{token list} \meta{seq var}
+\cs{regexExtractOnceT} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexExtractOnceF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexExtractOnceTF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Finds the first match of the \meta{regular expression} in the
\meta{token list}. If it exists, the match is stored as the first
@@ -7173,7 +7173,7 @@
\par
For instance, assume that you type
\begin{codehigh}
-\RegexExtractOnce {\A(La)?TeX(!*)\Z} {LaTeX!!!} \lTmpaSeq
+\regexExtractOnce {\A(La)?TeX(!*)\Z} {LaTeX!!!} \lTmpaSeq
\end{codehigh}
Then the regular expression (anchored at the start with |\A| and
at the end with |\Z|) must match the whole token list. The first
@@ -7181,16 +7181,16 @@
group, |(!*)|, matches |!!!|. Thus, \cs{lTmpaSeq} contains as a result
the items |{LaTeX!!!}|, |{La}|, and |{!!!}|.
Note that the $n$-th item of \cs{lTmpaSeq}, as obtained using
-\cs{SeqVarItem}, correspond to the submatch numbered $(n-1)$ in
-functions such as \cs{RegexReplaceOnce}.
+\cs{seqVarItem}, correspond to the submatch numbered $(n-1)$ in
+functions such as \cs{regexReplaceOnce}.
\end{function}
-\begin{function}{\RegexVarExtractOnce,\RegexVarExtractOnceT,\RegexVarExtractOnceF,\RegexVarExtractOnceTF}
+\begin{function}{\regexVarExtractOnce,\regexVarExtractOnceT,\regexVarExtractOnceF,\regexVarExtractOnceTF}
\begin{syntax}
-\cs{RegexVarExtractOnce} \meta{regex var} \Arg{token list} \meta{seq var}
-\cs{RegexVarExtractOnceT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexVarExtractOnceF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexVarExtractOnceTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexVarExtractOnce} \meta{regex var} \Arg{token list} \meta{seq var}
+\cs{regexVarExtractOnceT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexVarExtractOnceF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexVarExtractOnceTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Finds the first match of the \meta{regex var} in the
\meta{token list}. If it exists, the match is stored as the first
@@ -7202,17 +7202,17 @@
\meta{false code} otherwise.
\end{function}
-\begin{function}{\RegexExtractAll,\RegexExtractAllT,\RegexExtractAllF,\RegexExtractAllTF}
+\begin{function}{\regexExtractAll,\regexExtractAllT,\regexExtractAllF,\regexExtractAllTF}
\begin{syntax}
-\cs{RegexExtractAll} \Arg{regex} \Arg{token list} \meta{seq var}
-\cs{RegexExtractAllT} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexExtractAllF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexExtractAllTF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexExtractAll} \Arg{regex} \Arg{token list} \meta{seq var}
+\cs{regexExtractAllT} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexExtractAllF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexExtractAllTF} \Arg{regex} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Finds all matches of the \meta{regular expression}
in the \meta{token list}, and stores all the submatch information
in a single sequence (concatenating the results of
-multiple \cs{RegexExtractOnce} calls).
+multiple \cs{regexExtractOnce} calls).
The \meta{seq var} is assigned locally. If there is no match,
the \meta{seq var} is cleared.
The testing versions insert the \meta{true code} into the input
@@ -7219,23 +7219,23 @@
stream if a match was found, and the \meta{false code} otherwise.
For instance, assume that you type
\begin{codehigh}
-\RegexExtractAll {\w+} {Hello, world!} \lTmpaSeq
+\regexExtractAll {\w+} {Hello, world!} \lTmpaSeq
\end{codehigh}
Then the regular expression matches twice, the resulting
sequence contains the two items |{Hello}| and |{world}|.
\end{function}
-\begin{function}{\RegexVarExtractAll,\RegexVarExtractAllT,\RegexVarExtractAllF,\RegexVarExtractAllTF}
+\begin{function}{\regexVarExtractAll,\regexVarExtractAllT,\regexVarExtractAllF,\regexVarExtractAllTF}
\begin{syntax}
-\cs{RegexVarExtractAll} \meta{regex var} \Arg{token list} \meta{seq var}
-\cs{RegexVarExtractAllT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexVarExtractAllF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexVarExtractAllTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexVarExtractAll} \meta{regex var} \Arg{token list} \meta{seq var}
+\cs{regexVarExtractAllT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexVarExtractAllF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexVarExtractAllTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Finds all matches of the \meta{regex var}
in the \meta{token list}, and stores all the submatch information
in a single sequence (concatenating the results of
-multiple \cs{RegexVarExtractOnce} calls).
+multiple \cs{regexVarExtractOnce} calls).
The \meta{seq var} is assigned locally. If there is no match,
the \meta{seq var} is cleared.
The testing versions insert the \meta{true code} into the input
@@ -7242,12 +7242,12 @@
stream if a match was found, and the \meta{false code} otherwise.
\end{function}
-\begin{function}{\RegexSplit,\RegexSplitT,\RegexSplitF,\RegexSplitTF}
+\begin{function}{\regexSplit,\regexSplitT,\regexSplitF,\regexSplitTF}
\begin{syntax}
-\cs{RegexSplit} \Arg{regular expression} \Arg{token list} \meta{seq var}
-\cs{RegexSplitT} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexSplitF} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexSplitTF} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexSplit} \Arg{regular expression} \Arg{token list} \meta{seq var}
+\cs{regexSplitT} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexSplitF} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexSplitTF} \Arg{regular expression} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Splits the \meta{token list} into a sequence of parts, delimited by
matches of the \meta{regular expression}. If the \meta{regular expression}
@@ -7261,19 +7261,19 @@
stream if a match was found, and the \meta{false code} otherwise.
For example, after
\begin{codehigh}
-\SeqNew \lPathSeq
-\RegexSplit {/} {the/path/for/this/file.tex} \lPathSeq
+\seqNew \lPathSeq
+\regexSplit {/} {the/path/for/this/file.tex} \lPathSeq
\end{codehigh}
the sequence |\lPathSeq| contains the items |{the}|, |{path}|,
|{for}|, |{this}|, and |{file.tex}|.
\end{function}
-\begin{function}{\RegexVarSplit,\RegexVarSplitT,\RegexVarSplitF,\RegexVarSplitTF}
+\begin{function}{\regexVarSplit,\regexVarSplitT,\regexVarSplitF,\regexVarSplitTF}
\begin{syntax}
-\cs{RegexVarSplit} \meta{regex var} \Arg{token list} \meta{seq var}
-\cs{RegexVarSplitT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
-\cs{RegexVarSplitF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
-\cs{RegexVarSplitTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
+\cs{regexVarSplit} \meta{regex var} \Arg{token list} \meta{seq var}
+\cs{regexVarSplitT} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code}
+\cs{regexVarSplitF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{false code}
+\cs{regexVarSplitTF} \meta{regex var} \Arg{token list} \meta{seq var} \Arg{true code} \Arg{false code}
\end{syntax}
Splits the \meta{token list} into a sequence of parts, delimited by
matches of the \meta{regular expression}. If the \meta{regex var}
@@ -7289,12 +7289,12 @@
\section{Regular Expression Replacement}
-\begin{function}{\RegexReplaceOnce,\RegexReplaceOnceT,\RegexReplaceOnceT,\RegexReplaceOnceTF}
+\begin{function}{\regexReplaceOnce,\regexReplaceOnceT,\regexReplaceOnceT,\regexReplaceOnceTF}
\begin{syntax}
-\cs{RegexReplaceOnce} \Arg{regular expression} \Arg{replacement} \meta{tl var}
-\cs{RegexReplaceOnceT} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code}
-\cs{RegexReplaceOnceF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{false code}
-\cs{RegexReplaceOnceTF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{regexReplaceOnce} \Arg{regular expression} \Arg{replacement} \meta{tl var}
+\cs{regexReplaceOnceT} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code}
+\cs{regexReplaceOnceF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{false code}
+\cs{regexReplaceOnceTF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Searches for the \meta{regular expression} in the contents of the
\meta{tl var} and replaces the first match with the
@@ -7304,12 +7304,12 @@
The result is assigned locally to \meta{tl var}.
\end{function}
-\begin{function}{\RegexReplaceOnce,\RegexReplaceOnceT,\RegexReplaceOnceT,\RegexReplaceOnceTF}
+\begin{function}{\regexReplaceOnce,\regexReplaceOnceT,\regexReplaceOnceT,\regexReplaceOnceTF}
\begin{syntax}
-\cs{RegexVarReplaceOnce} \meta{regex var} \Arg{replacement} \meta{tl var}
-\cs{RegexVarReplaceOnceT} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code}
-\cs{RegexVarReplaceOnceF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{false code}
-\cs{RegexVarReplaceOnceTF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{regexVarReplaceOnce} \meta{regex var} \Arg{replacement} \meta{tl var}
+\cs{regexVarReplaceOnceT} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code}
+\cs{regexVarReplaceOnceF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{false code}
+\cs{regexVarReplaceOnceTF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Searches for the \meta{regex var} in the contents of the
\meta{tl var} and replaces the first match with the
@@ -7319,12 +7319,12 @@
The result is assigned locally to \meta{tl var}.
\end{function}
-\begin{function}{\RegexReplaceAll,\RegexReplaceAllT,\RegexReplaceAllF,\RegexReplaceAllTF}
+\begin{function}{\regexReplaceAll,\regexReplaceAllT,\regexReplaceAllF,\regexReplaceAllTF}
\begin{syntax}
-\cs{RegexReplaceAll} \Arg{regular expression} \Arg{replacement} \meta{tl var}
-\cs{RegexReplaceAllT} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code}
-\cs{RegexReplaceAllF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{false code}
-\cs{RegexReplaceAllTF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{regexReplaceAll} \Arg{regular expression} \Arg{replacement} \meta{tl var}
+\cs{regexReplaceAllT} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code}
+\cs{regexReplaceAllF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{false code}
+\cs{regexReplaceAllTF} \Arg{regular expression} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Replaces all occurrences of the \meta{regex var} in the
contents of the \meta{tl var}
@@ -7335,12 +7335,12 @@
locally to \meta{tl~var}.
\end{function}
-\begin{function}{\RegexVarReplaceAll,\RegexVarReplaceAllT,\RegexVarReplaceAllF,\RegexVarReplaceAllTF}
+\begin{function}{\regexVarReplaceAll,\regexVarReplaceAllT,\regexVarReplaceAllF,\regexVarReplaceAllTF}
\begin{syntax}
-\cs{RegexVarReplaceAll} \meta{regex var} \Arg{replacement} \meta{tl var}
-\cs{RegexVarReplaceAllT} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code}
-\cs{RegexVarReplaceAllF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{false code}
-\cs{RegexVarReplaceAllTF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
+\cs{regexVarReplaceAll} \meta{regex var} \Arg{replacement} \meta{tl var}
+\cs{regexVarReplaceAllT} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code}
+\cs{regexVarReplaceAllF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{false code}
+\cs{regexVarReplaceAllTF} \meta{regex var} \Arg{replacement} \meta{tl var} \Arg{true code} \Arg{false code}
\end{syntax}
Replaces all occurrences of the \meta{regular expression} in the
contents of the \meta{tl var}
@@ -7351,9 +7351,9 @@
locally to \meta{tl var}.
\end{function}
-\begin{function}{\RegexReplaceCaseOnce}
+\begin{function}{\regexReplaceCaseOnce}
\begin{syntax}
-\cs{RegexReplaceCaseOnce}
+\cs{regexReplaceCaseOnce}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7371,14 +7371,14 @@
In detail, for each starting position in the \meta{token list}, each
of the \meta{regex} is searched in turn. If one of them matches
then it is replaced by the corresponding \meta{replacement} as
-described for \cs{RegexReplaceOnce}. This is equivalent to
-checking with \cs{RegexMatchCase} which \meta{regex} matches,
-then performing the replacement with \cs{RegexReplaceOnce}.
+described for \cs{regexReplaceOnce}. This is equivalent to
+checking with \cs{regexMatchCase} which \meta{regex} matches,
+then performing the replacement with \cs{regexReplaceOnce}.
\end{function}
-\begin{function}{\RegexReplaceCaseOnceT}
+\begin{function}{\regexReplaceCaseOnceT}
\begin{syntax}
-\cs{RegexReplaceCaseOnceT}
+\cs{regexReplaceCaseOnceT}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7396,9 +7396,9 @@
variable or as an explicit regular expression.
\end{function}
-\begin{function}{\RegexReplaceCaseOnceF}
+\begin{function}{\regexReplaceCaseOnceF}
\begin{syntax}
-\cs{RegexReplaceCaseOnceF}
+\cs{regexReplaceCaseOnceF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7416,9 +7416,9 @@
variable or as an explicit regular expression.
\end{function}
-\begin{function}{\RegexReplaceCaseOnceTF}
+\begin{function}{\regexReplaceCaseOnceTF}
\begin{syntax}
-\cs{RegexReplaceCaseOnceTF}
+\cs{regexReplaceCaseOnceTF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7437,9 +7437,9 @@
variable or as an explicit regular expression.
\end{function}
-\begin{function}{\RegexReplaceCaseAll}
+\begin{function}{\regexReplaceCaseAll}
\begin{syntax}
-\cs{RegexReplaceCaseAll}
+\cs{regexReplaceCaseAll}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7459,8 +7459,8 @@
replacement). For instance
%% FIXME
%\begin{codehigh}
-%\TlSet \lTmpaTl {Hello, world!}
-%\RegexReplaceCaseAll
+%\tlSet \lTmpaTl {Hello, world!}
+%\regexReplaceCaseAll
% {
% {[A-Za-z]+} {``\0''}
% {\b} {---}
@@ -7468,8 +7468,8 @@
% } \lTmpaTl
%\end{codehigh}
\begin{codehigh}
-\TlSet \lTmpaTl {Hello, world!}
-\RegexReplaceCaseAll
+\tlSet \lTmpaTl {Hello, world!}
+\regexReplaceCaseAll
{
{[A-Za-z]+} {``\0''}
{\b} {---}
@@ -7481,12 +7481,12 @@
the word-boundary assertion |\b| did not match at the start of words
because the case |[A-Za-z]+| matched at these positions. To change
this, one could simply swap the order of the two cases in the
-argument of \cs{RegexReplaceCaseAll}.
+argument of \cs{regexReplaceCaseAll}.
\end{function}
-\begin{function}{\RegexReplaceCaseAllT}
+\begin{function}{\regexReplaceCaseAllT}
\begin{syntax}
-\cs{RegexReplaceCaseAllT}
+\cs{regexReplaceCaseAllT}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7502,9 +7502,9 @@
is left in the input stream if any replacement was made.
\end{function}
-\begin{function}{\RegexReplaceCaseAllF}
+\begin{function}{\regexReplaceCaseAllF}
\begin{syntax}
-\cs{RegexReplaceCaseAllF}
+\cs{regexReplaceCaseAllF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7520,9 +7520,9 @@
in the input stream if not any replacement was made.
\end{function}
-\begin{function}{\RegexReplaceCaseAllTF}
+\begin{function}{\regexReplaceCaseAllTF}
\begin{syntax}
-\cs{RegexReplaceCaseAllTF}
+\cs{regexReplaceCaseAllTF}
~ ~ |{|
~ ~ ~ ~ \Arg{regex_1} \Arg{replacement_1}
~ ~ ~ ~ \Arg{regex_2} \Arg{replacement_2}
@@ -7544,7 +7544,7 @@
\subsection{Regular Expression Examples}
We start with a few examples, and encourage the reader to apply
-\cs{RegexShow} to these regular expressions.
+\cs{regexShow} to these regular expressions.
\begin{itemize}
\item |Cat| matches the word \enquote{Cat} capitalized in this way,
but also matches the beginning of the word \enquote{Cattle}: use
@@ -7583,9 +7583,9 @@
\item |\G.*?\K| at the beginning of a regular expression matches and
discards (due to |\K|) everything between the end of the previous
match (|\G|) and what is matched by the rest of the regular
- expression; this is useful in \cs{RegexReplaceAll} when the
+ expression; this is useful in \cs{regexReplaceAll} when the
goal is to extract matches or submatches in a finer way than with
- \cs{RegexExtractAll}.
+ \cs{regexExtractAll}.
\end{itemize}
While it is impossible for a regular expression to match only integer
expressions, \newline\verb*"[\+\-\(]*\d+\)*([\+\-*/][\+\-\(]*\d+\)*)*" matches among
@@ -7735,19 +7735,19 @@
opening parenthesis, starting at $1$. The contents of those groups
corresponding to the \enquote{best} match (leftmost longest)
can be extracted and stored in a sequence of token lists using for
-instance \cs{RegexExtractOnceTF}.
+instance \cs{regexExtractOnceTF}.
The |\K| escape sequence resets the beginning of the match to the
current position in the token list. This only affects what is reported
as the full match. For instance,
\begin{codehigh}
-\RegexExtractAll {a \K .} {a123aaxyz} \lFooSeq
+\regexExtractAll {a \K .} {a123aaxyz} \lFooSeq
\end{codehigh}
results in \cs{lFooSeq} containing the items |{1}| and |{a}|: the
true matches are |{a1}| and |{aa}|, but they are trimmed by the use of
|\K|. The |\K| command does not affect capturing groups: for instance,
\begin{codehigh}
-\RegexExtractOnce {(. \K c)+ \d} {acbc3} \lFooSeq
+\regexExtractOnce {(. \K c)+ \d} {acbc3} \lFooSeq
\end{codehigh}
results in \cs{lFooSeq} containing the items |{c3}| and |{bc}|: the
true match is |{acbc3}|, with first submatch |{bc}|, but |\K| resets
@@ -7832,8 +7832,8 @@
machinery directly: if \cs{lTmpaTl} contains
\verb"B|C" then the following two lines show the same result:
\begin{codehigh}
-\RegexShow {A \u{lTmpaTl} D}
-\RegexShow {A B | C D}
+\regexShow {A \u{lTmpaTl} D}
+\regexShow {A B | C D}
\end{codehigh}
\subsection{Miscellaneous}
@@ -7851,7 +7851,7 @@
End of the subject token list.
\item[\\G] Start of the current match. This is only different from |^|
in the case of multiple matches: for instance
- |\RegexCount {\G a} {aaba} \lTmpaInt| yields $2$, but
+ |\regexCount {\G a} {aaba} \lTmpaInt| yields $2$, but
replacing |\G| by |^| would result in \cs{lTmpaInt} holding the
value $1$.
\end{l3regex-syntax}
@@ -7895,9 +7895,9 @@
For instance,
\begin{demohigh}
-\TlSet \lTmpaTl {Hello, world!}
-\RegexReplaceAll {([er]?l|o) .} {(\0--\1)} \lTmpaTl
-\TlUse \lTmpaTl
+\tlSet \lTmpaTl {Hello, world!}
+\regexReplaceAll {([er]?l|o) .} {(\0--\1)} \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
The submatches are numbered according to the order in which the
@@ -7943,18 +7943,18 @@
Matches can also be used within the arguments of |\c| and |\u|. For
instance,
\begin{demohigh}
-\TlSet \lMyOneTl {first}
-\TlSet \lMyTwoTl {\underline{second}}
-\TlSet \lTmpaTl {One,Two,One,One}
-\RegexReplaceAll {[^,]+} {\u{lMy\0Tl}} \lTmpaTl
-\TlUse \lTmpaTl
+\tlSet \lMyOneTl {first}
+\tlSet \lMyTwoTl {\underline{second}}
+\tlSet \lTmpaTl {One,Two,One,One}
+\regexReplaceAll {[^,]+} {\u{lMy\0Tl}} \lTmpaTl
+\tlUse \lTmpaTl
\end{demohigh}
Regex replacement is also a convenient way to produce token lists
with arbitrary category codes. For instance
\begin{codehigh}
-\TlClear \lTmpaTl
-\RegexReplaceAll { } {\cU\% \cA\~} \lTmpaTl
+\tlClear \lTmpaTl
+\regexReplaceAll { } {\cU\% \cA\~} \lTmpaTl
\end{codehigh}
results in \cs{lTmpaTl} containing the percent character
with category code $7$ (superscript) and an active tilde character.
@@ -7961,75 +7961,75 @@
\chapter{Token Manipulation (\texttt{Token})}
-\begin{function}{\CharLowercase,\CharUppercase,\CharTitlecase,\CharFoldcase}
+\begin{function}{\charLowercase,\charUppercase,\charTitlecase,\charFoldcase}
\begin{syntax}
-\cs{CharLowercase} \meta{char}
-\cs{CharUppercase} \meta{char}
-\cs{CharTitlecase} \meta{char}
-\cs{CharFoldcase} \meta{char}
+\cs{charLowercase} \meta{char}
+\cs{charUppercase} \meta{char}
+\cs{charTitlecase} \meta{char}
+\cs{charFoldcase} \meta{char}
\end{syntax}
Converts the \meta{char} to the equivalent case-changed character
-as detailed by the function name (see %\cs{StrFoldcase} and
-\cs{TextTitlecase} for details of these terms). The case mapping
-is carried out with no context-dependence (\emph{cf.} \cs{TextUppercase},
+as detailed by the function name (see %\cs{strFoldcase} and
+\cs{textTitlecase} for details of these terms). The case mapping
+is carried out with no context-dependence (\emph{cf.} \cs{textUppercase},
\emph{etc.}) These functions generate characters with the category code
of the \meta{char} (i.e. only the character code changes).
\end{function}
-\begin{function}{\CharStrLowercase,\CharStrUppercase,\CharStrTitlecase,\CharStrFoldcase}
+\begin{function}{\charStrLowercase,\charStrUppercase,\charStrTitlecase,\charStrFoldcase}
\begin{syntax}
-\cs{CharStrLowercase} \meta{char}
-\cs{CharStrUppercase} \meta{char}
-\cs{CharStrTitlecase} \meta{char}
-\cs{CharStrFoldcase} \meta{char}
+\cs{charStrLowercase} \meta{char}
+\cs{charStrUppercase} \meta{char}
+\cs{charStrTitlecase} \meta{char}
+\cs{charStrFoldcase} \meta{char}
\end{syntax}
Converts the \meta{char} to the equivalent case-changed character
-as detailed by the function name (see %\cs{StrFoldcase} and
-\cs{TextTitlecase} for details of these terms). The case mapping
-is carried out with no context-dependence (\emph{cf.} \cs{TextUppercase},
+as detailed by the function name (see %\cs{strFoldcase} and
+\cs{textTitlecase} for details of these terms). The case mapping
+is carried out with no context-dependence (\emph{cf.} \cs{textUppercase},
\emph{etc.}) These functions generate \enquote{other} (category code $12$)
characters.
\end{function}
-\begin{function}{\CharSetLccode}
+\begin{function}{\charSetLccode}
\begin{syntax}
-\cs{CharSetLccode} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{charSetLccode} \Arg{intexpr_1} \Arg{intexpr_2}
\end{syntax}
Sets up the behaviour of the \meta{character} when
-found inside \cs{TextLowercase}, such that \meta{character_1}
+found inside \cs{textLowercase}, such that \meta{character_1}
will be converted into \meta{character_2}. The two \meta{characters}
may be specified using an \meta{integer expression} for the character code
concerned. This may include the \TeX{} \verb|`|\meta{character}
method for converting a single character into its character code:
\begin{codehigh}
-\CharSetLccode {`\A} {`\a} % Standard behaviour
-\CharSetLccode {`\A} {`\A + 32}
-\CharSetLccode {65} {97}
+\charSetLccode {`\A} {`\a} % Standard behaviour
+\charSetLccode {`\A} {`\A + 32}
+\charSetLccode {65} {97}
\end{codehigh}
The setting applies within the current \TeX{} group.
\end{function}
-\begin{function}{\CharSetUccode}
+\begin{function}{\charSetUccode}
\begin{syntax}
-\cs{CharSetUccode} \Arg{intexpr_1} \Arg{intexpr_2}
+\cs{charSetUccode} \Arg{intexpr_1} \Arg{intexpr_2}
\end{syntax}
Sets up the behaviour of the \meta{character} when
-found inside \cs{TextUppercase}, such that \meta{character_1}
+found inside \cs{textUppercase}, such that \meta{character_1}
will be converted into \meta{character_2}. The two \meta{characters}
may be specified using an \meta{integer expression} for the character code
concerned. This may include the \TeX{} \verb|`|\meta{character}
method for converting a single character into its character code:
\begin{codehigh}
-\CharSetUccode {`\a} {`\A} % Standard behaviour
-\CharSetUccode {`\a} {`\a - 32}
-\CharSetUccode {97} {65}
+\charSetUccode {`\a} {`\A} % Standard behaviour
+\charSetUccode {`\a} {`\a - 32}
+\charSetUccode {97} {65}
\end{codehigh}
The setting applies within the current \TeX{} group.
\end{function}
-\begin{function}{\CharValueLccode}
+\begin{function}{\charValueLccode}
\begin{syntax}
-\cs{CharValueLccode} \Arg{integer expression}
+\cs{charValueLccode} \Arg{integer expression}
\end{syntax}
Returns the current lower case code of the \meta{character} with
character code given by the
@@ -8036,9 +8036,9 @@
\meta{integer expression}.
\end{function}
-\begin{function}{\CharValueUccode}
+\begin{function}{\charValueUccode}
\begin{syntax}
-\cs{CharValueUccode} \Arg{integer expression}
+\cs{charValueUccode} \Arg{integer expression}
\end{syntax}
Returns the current upper case code of the \meta{character} with
character code given by the
@@ -8045,9 +8045,9 @@
\meta{integer expression}.
\end{function}
-%\begin{function}{\CharShowValueLccode}
+%\begin{function}{\charShowValueLccode}
%\begin{syntax}
-%\cs{CharShowValueLccode} \Arg{integer expression}
+%\cs{charShowValueLccode} \Arg{integer expression}
%\end{syntax}
%Displays the current lower case code of the \meta{character} with
%character code given by the \meta{integer expression} on the
@@ -8054,9 +8054,9 @@
%terminal.
%\end{function}
%
-%\begin{function}{\CharShowValueUccode}
+%\begin{function}{\charShowValueUccode}
%\begin{syntax}
-%\cs{CharShowValueUccode} \Arg{integer expression}
+%\cs{charShowValueUccode} \Arg{integer expression}
%\end{syntax}
%Displays the current upper case code of the \meta{character} with
%character code given by the \meta{integer expression} on the
@@ -8089,12 +8089,12 @@
%Importantly, notice that these functions are intended for working with
%user \emph{text for typesetting}. For case changing programmatic data see
-%the \pkg{Str} module and discussion there of \cs{StrLowercase},
-%\cs{StrUppercase} and \cs{StrFoldcase}.
+%the \pkg{Str} module and discussion there of \cs{strLowercase},
+%\cs{strUppercase} and \cs{strFoldcase}.
-\begin{function}{\TextExpand}
+\begin{function}{\textExpand}
\begin{syntax}
-\cs{TextExpand} \Arg{text}
+\cs{textExpand} \Arg{text}
\end{syntax}
Takes user input \meta{text} and expands the content.
Protected commands (typically formatting) are left in place,
@@ -8106,14 +8106,14 @@
%\cs{l_text_accents_tl} and \cs{l_text_letterlike_tl} are excluded from expansion.
\end{function}
-\begin{function}{\TextLowercase,\TextUppercase,\TextTitlecase,\TextTitlecaseFirst}
+\begin{function}{\textLowercase,\textUppercase,\textTitlecase,\textTitlecaseFirst}
\begin{syntax}
-\cs{TextLowercase} \Arg{tokens}
-\cs{TextUppercase} \Arg{tokens}
-\cs{TextTitlecase} \Arg{tokens}
-\cs{TextTitlecaseFirst} \Arg{tokens}
+\cs{textLowercase} \Arg{tokens}
+\cs{textUppercase} \Arg{tokens}
+\cs{textTitlecase} \Arg{tokens}
+\cs{textTitlecaseFirst} \Arg{tokens}
\end{syntax}
-Takes user input \meta{text} first applies \cs{TextExpand}, then
+Takes user input \meta{text} first applies \cs{textExpand}, then
transforms the case of character tokens as specified by the
function name. The category code of letters are not changed by this
process (at least where they can be represented by the engine as a single
@@ -8127,9 +8127,9 @@
\texttt{IJ}.
\par
For titlecasing, note that there are two functions available. The
-function \cs{TextTitlecase} applies (broadly) uppercasing to the first
+function \cs{textTitlecase} applies (broadly) uppercasing to the first
letter of the input, then lowercasing to the remainder. In contrast,
-\cs{TextTitlecaseFirst} \emph{only} carries out the uppercasing operation,
+\cs{textTitlecaseFirst} \emph{only} carries out the uppercasing operation,
and leaves the balance of the input unchanged.
%Determining whether non-letter characters at the start of text should switch
%from upper- to lowercasing is controllable.
@@ -8144,10 +8144,10 @@
\par
Case changing does not take place within math mode material. For example:
\begin{demohigh}
-\TextUppercase {Text $y=mx+c$ with {Braces}}
+\textUppercase {Text $y=mx+c$ with {Braces}}
\end{demohigh}
\begin{demohigh}
-\TextLowercase {Text $Y=mX+c$ with {Braces}}
+\textLowercase {Text $Y=mX+c$ with {Braces}}
\end{demohigh}
%The arguments of commands listed in \cs{l_text_case_exclude_arg_tl}
%are excluded from case changing; the latter are entirely non-textual
@@ -8154,14 +8154,14 @@
%content (such as labels).
\end{function}
-\begin{function}{\TextLangLowercase,\TextLangUppercase,\TextLangTitlecase,\TextLangTitlecaseFirst}
+\begin{function}{\textLangLowercase,\textLangUppercase,\textLangTitlecase,\textLangTitlecaseFirst}
\begin{syntax}
-\cs{TextLangLowercase} \Arg{language} \Arg{tokens}
-\cs{TextLangUppercase} \Arg{language} \Arg{tokens}
-\cs{TextLangTitlecase} \Arg{language} \Arg{tokens}
-\cs{TextLangTitlecaseFirst} \Arg{language} \Arg{tokens}
+\cs{textLangLowercase} \Arg{language} \Arg{tokens}
+\cs{textLangUppercase} \Arg{language} \Arg{tokens}
+\cs{textLangTitlecase} \Arg{language} \Arg{tokens}
+\cs{textLangTitlecaseFirst} \Arg{language} \Arg{tokens}
\end{syntax}
-Takes user input \meta{text} first applies \cs{TextExpand}, then
+Takes user input \meta{text} first applies \cs{textExpand}, then
transforms the case of character tokens as specified by the
function name. The category code of letters are not changed by this
process (at least where they can be represented by the engine as a single
@@ -8203,7 +8203,7 @@
\chapter{Files (\texttt{File})}
This module provides functions for working with external files.
-%Some of these functions apply to an entire file, and have prefix \cs{File},
+%Some of these functions apply to an entire file, and have prefix \cs{file},
%while others are used to work with files on a line by line basis and have
%prefix \cs{Ior} (reading) or \cs{Iow} (writing).
@@ -8228,36 +8228,36 @@
\section{File Operation Functions}
-\begin{function}{\FileInput}
+\begin{function}{\fileInput}
\begin{syntax}
-\cs{FileInput} \Arg{file name}
+\cs{fileInput} \Arg{file name}
\end{syntax}
Searches for \meta{file name} in the path as detailed for
-\cs{FileIfExistTF}, and if found reads in the file and
+\cs{fileIfExistTF}, and if found reads in the file and
returns the contents. All files read are recorded
for information and the file name stack is updated by this
function. An error is raised if the file is not found.
\end{function}
-\begin{function}{\FileIfExistInput,\FileIfExistInputF}
+\begin{function}{\fileIfExistInput,\fileIfExistInputF}
\begin{syntax}
-\cs{FileIfExistInput} \Arg{file name}
-\cs{FileIfExistInputF} \Arg{file name} \Arg{false code}
+\cs{fileIfExistInput} \Arg{file name}
+\cs{fileIfExistInputF} \Arg{file name} \Arg{false code}
\end{syntax}
Searches for \meta{file name} using the current \TeX{} search path.
%and the additional paths included in \cs{l_file_search_path_seq}.
If found then reads in the file and returns the contents as described
-for \cs{FileInput}, otherwise inserts the \meta{false code}.
+for \cs{fileInput}, otherwise inserts the \meta{false code}.
Note that these functions do not raise
-an error if the file is not found, in contrast to \cs{FileInput}.
+an error if the file is not found, in contrast to \cs{fileInput}.
\end{function}
-\begin{function}{\FileGet,\FileGetT,\FileGetF,\FileGetTF}
+\begin{function}{\fileGet,\fileGetT,\fileGetF,\fileGetTF}
\begin{syntax}
-\cs{FileGet} \Arg{filename} \Arg{setup} \meta{tl}
-\cs{FileGetT} \Arg{filename} \Arg{setup} \meta{tl} \Arg{true code}
-\cs{FileGetF} \Arg{filename} \Arg{setup} \meta{tl} \Arg{false code}
-\cs{FileGetTF} \Arg{filename} \Arg{setup} \meta{tl} \Arg{true code} \Arg{false code}
+\cs{fileGet} \Arg{filename} \Arg{setup} \meta{tl}
+\cs{fileGetT} \Arg{filename} \Arg{setup} \meta{tl} \Arg{true code}
+\cs{fileGetF} \Arg{filename} \Arg{setup} \meta{tl} \Arg{false code}
+\cs{fileGetTF} \Arg{filename} \Arg{setup} \meta{tl} \Arg{true code} \Arg{false code}
\end{syntax}
Defines \meta{tl} to the contents of \meta{filename}.
Category codes may need to be set appropriately via the \meta{setup}
@@ -8268,20 +8268,20 @@
otherwise.
\end{function}
-\begin{function}{\FileIfExist,\FileIfExistT,\FileIfExistF,\FileIfExistTF}
+\begin{function}{\fileIfExist,\fileIfExistT,\fileIfExistF,\fileIfExistTF}
\begin{syntax}
-\cs{FileIfExist} \Arg{file name}
-\cs{FileIfExistT} \Arg{file name} \Arg{true code}
-\cs{FileIfExistF} \Arg{file name} \Arg{false code}
-\cs{FileIfExistTF} \Arg{file name} \Arg{true code} \Arg{false code}
+\cs{fileIfExist} \Arg{file name}
+\cs{fileIfExistT} \Arg{file name} \Arg{true code}
+\cs{fileIfExistF} \Arg{file name} \Arg{false code}
+\cs{fileIfExistTF} \Arg{file name} \Arg{true code} \Arg{false code}
\end{syntax}
Searches for \meta{file name} using the current \TeX{} search path.
%and the additional paths controlled by \cs{l_file_search_path_seq}.
\end{function}
-%\begin{function}{\FileInputStop}
+%\begin{function}{\fileInputStop}
%\begin{syntax}
-%\cs{FileInputStop}
+%\cs{fileInputStop}
%\end{syntax}
%Ends the reading of a file started by \cs{file_input:n} or similar before
%the end of the file is reached. Where the file reading is being terminated
@@ -8310,7 +8310,7 @@
in the code. This would result in an endless loop!
Quarks can be used as error return values for functions that receive erroneous input.
-For example, in the function \cs{PropGet} to retrieve a value stored
+For example, in the function \cs{propGet} to retrieve a value stored
in some key of a property list, if the key does not exist then the return value
is the quark \cs{qNoValue}.
As mentioned above, such quarks are extremely fragile and it is imperative
@@ -8323,38 +8323,38 @@
\begin{variable}{\qNoValue}
A canonical value for a missing value, when one is requested from
a data structure. This is therefore used as a \enquote{return} value
-by functions such as \cs{PropGet} if there is no data to return.
+by functions such as \cs{propGet} if there is no data to return.
\end{variable}
\section{Quark Conditionals}
-\begin{function}{\QuarkVarIfNoValue,\QuarkVarIfNoValueT,\QuarkVarIfNoValueF,\QuarkVarIfNoValueTF}
+\begin{function}{\quarkVarIfNoValue,\quarkVarIfNoValueT,\quarkVarIfNoValueF,\quarkVarIfNoValueTF}
\begin{syntax}
-\cs{QuarkVarIfNoValue} \meta{token}
-\cs{QuarkVarIfNoValueT} \meta{token} \Arg{true code}
-\cs{QuarkVarIfNoValueF} \meta{token} \Arg{false code}
-\cs{QuarkVarIfNoValueTF} \meta{token} \Arg{true code} \Arg{false code}
+\cs{quarkVarIfNoValue} \meta{token}
+\cs{quarkVarIfNoValueT} \meta{token} \Arg{true code}
+\cs{quarkVarIfNoValueF} \meta{token} \Arg{false code}
+\cs{quarkVarIfNoValueTF} \meta{token} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \meta{token} is equal to \cs{qNoValue}.
\begin{demohigh}
-\ClistGet \cEmptyClist \lTmpaTl
-\QuarkVarIfNoValueTF \lTmpaTl {\Return{NoValue}} {\Return{SomeValue}}
+\clistGet \cEmptyClist \lTmpaTl
+\quarkVarIfNoValueTF \lTmpaTl {\prgReturn{NoValue}} {\prgReturn{SomeValue}}
\end{demohigh}
\begin{demohigh}
-\SeqPop \cEmptySeq \lTmpaTl
-\QuarkVarIfNoValueTF \lTmpaTl {\Return{NoValue}} {\Return{SomeValue}}
+\seqPop \cEmptySeq \lTmpaTl
+\quarkVarIfNoValueTF \lTmpaTl {\prgReturn{NoValue}} {\prgReturn{SomeValue}}
\end{demohigh}
\begin{demohigh}
-\PropSetFromKeyval \lTmpaProp {key1=one,key2=two}
-\PropGet \lTmpaProp {key3} \lTmpaTl
-\QuarkVarIfNoValueTF \lTmpaTl {\Return{NoValue}} {\Return{SomeValue}}
+\propSetFromKeyval \lTmpaProp {key1=one,key2=two}
+\propGet \lTmpaProp {key3} \lTmpaTl
+\quarkVarIfNoValueTF \lTmpaTl {\prgReturn{NoValue}} {\prgReturn{SomeValue}}
\end{demohigh}
\end{function}
-%\begin{function}{\QuarkIfNoValue,\QuarkIfNoValueTF}
+%\begin{function}{\quarkIfNoValue,\quarkIfNoValueTF}
%\begin{syntax}
-%\cs{QuarkIfNoValue} \Arg{token list}
-%\cs{QuarkIfNoValueTF} \Arg{token list} \Arg{true code} \Arg{false code}
+%\cs{quarkIfNoValue} \Arg{token list}
+%\cs{quarkIfNoValueTF} \Arg{token list} \Arg{true code} \Arg{false code}
%\end{syntax}
%Tests if the \meta{token list} contains only \cs{qNoValue}
%(distinct from \meta{token list} being empty or containing
@@ -8368,12 +8368,12 @@
package. To allow these to be integrated cleanly into \pkg{functional} code, a set
of legacy interfaces are provided here.
-\begin{function}{\LegacyIf,\LegacyIfT,\LegacyIfF,\LegacyIfTF}
+\begin{function}{\legacyIf,\legacyIfT,\legacyIfF,\legacyIfTF}
\begin{syntax}
-\cs{LegacyIf} \Arg{name}
-\cs{LegacyIfT} \Arg{name} \Arg{true code}
-\cs{LegacyIfF} \Arg{name} \Arg{false code}
-\cs{LegacyIfTF} \Arg{name} \Arg{true code} \Arg{false code}
+\cs{legacyIf} \Arg{name}
+\cs{legacyIfT} \Arg{name} \Arg{true code}
+\cs{legacyIfF} \Arg{name} \Arg{false code}
+\cs{legacyIfTF} \Arg{name} \Arg{true code} \Arg{false code}
\end{syntax}
Tests if the \LaTeXe{}/plain \TeX{} conditional (generated by \tn{newif})
if \texttt{true} or \texttt{false} and branches \hbox{accordingly}. The
@@ -8380,27 +8380,27 @@
\meta{name} of the conditional should \emph{omit} the leading \texttt{if}.
\begin{demohigh}
\newif \ifFooBar
-\LegacyIfTF {FooBar} {\Return{True!}} {\Return{False!}}
+\legacyIfTF {FooBar} {\prgReturn{True!}} {\prgReturn{False!}}
\end{demohigh}
\end{function}
-\begin{function}{\LegacyIfSetTrue,\LegacyIfSetFalse}
+\begin{function}{\legacyIfSetTrue,\legacyIfSetFalse}
\begin{syntax}
-\cs{LegacyIfSetTrue} \Arg{name}
-\cs{LegacyIfSetFalse} \Arg{name}
+\cs{legacyIfSetTrue} \Arg{name}
+\cs{legacyIfSetFalse} \Arg{name}
\end{syntax}
Sets the \LaTeXe{}/plain \TeX{} conditional \verb|\if|\meta{name}
(generated by \tn{newif}) to be \texttt{true} or \texttt{false}.
\begin{demohigh}
\newif \ifFooBar
-\LegacyIfSetTrue {FooBar}
-\LegacyIfTF {FooBar} {\Return{True!}} {\Return{False!}}
+\legacyIfSetTrue {FooBar}
+\legacyIfTF {FooBar} {\prgReturn{True!}} {\prgReturn{False!}}
\end{demohigh}
\end{function}
-\begin{function}{\LegacyIfSet}
+\begin{function}{\legacyIfSet}
\begin{syntax}
-\cs{LegacyIfSet} \Arg{name} \Arg{boolexpr}
+\cs{legacyIfSet} \Arg{name} \Arg{boolexpr}
\end{syntax}
Sets the \LaTeXe{}/plain \TeX{} conditional \verb|\if|\meta{name}
(generated by \tn{newif}) to the result of evaluating the
@@ -8407,8 +8407,8 @@
\meta{boolean expression}.
\begin{demohigh}
\newif \ifFooBar
-\LegacyIfSet {FooBar} {\cFalseBool}
-\LegacyIfTF {FooBar} {\Return{True!}} {\Return{False!}}
+\legacyIfSet {FooBar} {\cFalseBool}
+\legacyIfTF {FooBar} {\prgReturn{True!}} {\prgReturn{False!}}
\end{demohigh}
\end{function}
Modified: trunk/Master/texmf-dist/tex/latex/functional/functional.sty
===================================================================
--- trunk/Master/texmf-dist/tex/latex/functional/functional.sty 2022-05-22 20:22:34 UTC (rev 63367)
+++ trunk/Master/texmf-dist/tex/latex/functional/functional.sty 2022-05-22 20:22:48 UTC (rev 63368)
@@ -14,7 +14,7 @@
\NeedsTeXFormat{LaTeX2e}[2018-04-01]
\RequirePackage{expl3}
-\ProvidesExplPackage{functional}{2022-05-14}{2022F}
+\ProvidesExplPackage{functional}{2022-05-22}{2022G}
{^^JIntuitive Functional Programming Interface for LaTeX2}
\cs_generate_variant:Nn \iow_log:n { V }
@@ -169,6 +169,7 @@
}
\cs_generate_variant:Nn \__fun_new_function:Nnn { cne }
+\cs_set_eq:NN \prgNewFunction \__fun_new_function:Nnn
\cs_set_eq:NN \PrgNewFunction \__fun_new_function:Nnn
\tl_new:N \g__fun_last_result_tl
@@ -243,6 +244,7 @@
}
}
+\cs_set_eq:NN \prgNewConditional \__fun_new_conditional:Nnn
\cs_set_eq:NN \PrgNewConditional \__fun_new_conditional:Nnn
\int_new:N \g__fun_nesting_level_int
@@ -577,21 +579,30 @@
%%> \subsection{Creating Some Useful Functions}
%%% --------------------------------------------------------
-\PrgNewFunction \PrgSetEqFunction { N N }
+\NewDocumentCommand \fun at NewTwoFunctions {mmmm}
{
+ \prgNewFunction #1 {#3} {#4}
+ \AtBeginDocument { \cs_if_exist:NF #2 { \prgNewFunction #2 {#3} {#4} } }
+ }
+
+\NewDocumentCommand \fun at NewTwoConditionals {mmmm}
+ {
+ \prgNewConditional #1 {#3} {#4}
+ \AtBeginDocument { \cs_if_exist:NF #2 { \prgNewConditional #2 {#3} {#4} } }
+ }
+
+\fun at NewTwoFunctions \prgSetEqFunction \PrgSetEqFunction { N N }
+ {
\cs_set_eq:NN #1 #2
\cs_set_eq:cc { __fun_defined_ \cs_to_str:N #1 : w }
{ __fun_defined_ \cs_to_str:N #2 : w }
}
-\cs_if_exist:NF \Do { \PrgNewFunction \Do { n } { #1 } }
-\PrgNewFunction \PrgDo { n } { #1 }
+\fun at NewTwoFunctions \prgDo \Do {n} {#1}
-\cs_set_eq:NN \Break \prg_break:
-\cs_set_eq:NN \PrgBreak \prg_break:
+\cs_set_eq:NN \prgBreak \prg_break:
-\cs_set_eq:NN \BreakDo \prg_break:n
-\cs_set_eq:NN \PrgBreakDo \prg_break:n
+\cs_set_eq:NN \prgBreakDo \prg_break:n
%%% --------------------------------------------------------
%%> \subsection{Return Values and Return Processors}
@@ -603,7 +614,7 @@
}
\cs_generate_variant:Nn \__fun_put_result:n { V, e, f, o }
-\PrgNewFunction \Return { m }
+\fun at NewTwoFunctions \prgReturn \Return { m }
{
\__fun_put_result:n { #1 }
}
@@ -702,7 +713,7 @@
%%> \subsection{Printing Contents to the Input Stream}
%%% --------------------------------------------------------
-\PrgNewFunction \PrgPrint { m }
+\fun at NewTwoFunctions \prgPrint \Print { m }
{
\tl_log:n {running PrgPrint}
\int_set_eq:NN \l__fun_return_level_int \g__fun_nesting_level_int
@@ -711,8 +722,6 @@
\tl_gclear:N \gResultTl
}
-\PrgSetEqFunction \Print \PrgPrint
-
%%% --------------------------------------------------------
%%> \subsection{Filling Arguments into Inline Commands}
%%% --------------------------------------------------------
@@ -719,27 +728,28 @@
%% To make better tracing log, we want to expand the return value once,
%% but at the same time avoid evaluating the leading function in \gResultTl,
-%% therefore we need to use \tl_set:Nn command instead of \TlSet function.
+%% therefore we need to use \tl_set:Nn command instead of \tlSet function.
-\PrgNewFunction \PrgRunOneArgCode { m n }
+\fun at NewTwoFunctions \prgRunOneArgCode \PrgRunOneArgCode { m n }
{
\cs_set:Npn \__fun_one_arg_cmd:n ##1 {#2}
\exp_args:NNo \tl_set:Nn \gResultTl { \__fun_one_arg_cmd:n {#1} }
}
-\PrgNewFunction \PrgRunTwoArgCode { m m n }
+\fun at NewTwoFunctions \prgRunTwoArgCode \PrgRunTwoArgCode { m m n }
{
\cs_set:Npn \__fun_two_arg_cmd:nn ##1 ##2 {#3}
\exp_args:NNo \tl_set:Nn \gResultTl { \__fun_two_arg_cmd:nn {#1} {#2} }
}
-\PrgNewFunction \PrgRunThreeArgCode { m m m n }
+\fun at NewTwoFunctions \prgRunThreeArgCode \PrgRunThreeArgCode { m m m n }
{
\cs_set:Npn \__fun_three_arg_cmd:nnn ##1 ##2 ##3 {#4}
- \exp_args:NNo \tl_set:Nn \gResultTl { \__fun_three_arg_cmd:nnn {#1} {#2} {#3} }
+ \exp_args:NNo \tl_set:Nn \gResultTl
+ { \__fun_three_arg_cmd:nnn {#1} {#2} {#3} }
}
-\PrgNewFunction \PrgRunFourArgCode { m m m m n }
+\fun at NewTwoFunctions \prgRunFourArgCode \PrgRunFourArgCode { m m m m n }
{
\cs_set:Npn \__fun_four_arg_cmd:nnnn ##1 ##2 ##3 ##4 {#5}
\exp_args:NNo \tl_set:Nn \gResultTl
@@ -787,7 +797,8 @@
{ \prg_return_true: }
}
-\PrgNewFunction \Local { } { \bool_gset_true:N \g__fun_variable_local_bool }
+\fun at NewTwoFunctions \prgLocal \Local { }
+ { \bool_gset_true:N \g__fun_variable_local_bool }
%% We must not put an assignment inside a group
\cs_new_protected:Npn \__fun_do_assignment:Nnn #1 #2 #3
@@ -801,34 +812,38 @@
%%> \section{Interfaces for Argument Using (Use)}
%%% --------------------------------------------------------
-\PrgNewFunction \Name { m }
+\fun at NewTwoFunctions \expName \Name { m }
{
\exp_args:Nc \__fun_put_result:n { #1 }
}
-\PrgSetEqFunction \ExpName \Name
-\PrgNewFunction \Value { M }
+\fun at NewTwoFunctions \expValue \Value { M }
{
\__fun_put_result:V #1
}
-\PrgSetEqFunction \ExpValue \Value
-\PrgNewFunction \Expand { m }
+\fun at NewTwoFunctions \expWhole \Expand { m }
{
\__fun_put_result:e { #1 }
}
-\PrgSetEqFunction \ExpWhole \Expand
-\PrgNewFunction \ExpPartial { m }
+\prgNewFunction \expPartial { m }
{
\__fun_put_result:f { #1 }
}
-\PrgNewFunction \ExpOnce { m }
+\prgNewFunction \expOnce { m }
{
\__fun_put_result:o { #1 }
}
+\cs_set_eq:NN \unExpand \exp_not:n
+\cs_set_eq:NN \noExpand \exp_not:N
+\cs_set_eq:NN \onlyName \exp_not:c
+\cs_set_eq:NN \onlyValue \exp_not:V
+\cs_set_eq:NN \onlyPartial \exp_not:f
+\cs_set_eq:NN \onlyOnce \exp_not:o
+
\cs_set_eq:NN \UnExpand \exp_not:n
\cs_set_eq:NN \NoExpand \exp_not:N
\cs_set_eq:NN \OnlyName \exp_not:c
@@ -836,13 +851,13 @@
\cs_set_eq:NN \OnlyPartial \exp_not:f
\cs_set_eq:NN \OnlyOnce \exp_not:o
-\PrgNewFunction \UseOne { n } { \Return { #1 } }
+\fun at NewTwoFunctions \useOne \UseOne { n } { \prgReturn {#1} }
-\PrgNewFunction \GobbleOne { n } { \Return { } }
+\fun at NewTwoFunctions \gobbleOne \GobbleOne { n } { }
-\PrgNewFunction \UseGobble { n n } { \UseOne { #1 } }
+\fun at NewTwoFunctions \useGobble \UseGobble { n n } { \prgReturn {#1} }
-\PrgNewFunction \GobbleUse { n n } { \UseOne { #2 } }
+\fun at NewTwoFunctions \gobbleUse \GobbleUse { n n } { \prgReturn {#2} }
%%% --------------------------------------------------------
%%> \section{Interfaces for Control Structures (Bool)}
@@ -859,86 +874,87 @@
\bool_new:N \gTmpiBool \bool_new:N \gTmpjBool \bool_new:N \gTmpkBool
\bool_new:N \g at FunTmpxBool \bool_new:N \g at FunTmpyBool \bool_new:N \g at FunTmpzBool
-\PrgNewFunction \BoolNew { M } { \bool_new:N #1 }
+\fun at NewTwoFunctions \boolNew \BoolNew { M } { \bool_new:N #1 }
-\PrgNewFunction \BoolConst { M e } { \bool_const:Nn #1 {#2} }
+\fun at NewTwoFunctions \boolConst \BoolConst { M e } { \bool_const:Nn #1 {#2} }
-\PrgNewFunction \BoolSet { M e } {
+\fun at NewTwoFunctions \boolSet \BoolSet { M e } {
\__fun_do_assignment:Nnn #1
{ \bool_gset:Nn #1 {#2} } { \bool_set:Nn #1 {#2} }
}
-\PrgNewFunction \BoolSetTrue { M }
+\fun at NewTwoFunctions \boolSetTrue \BoolSetTrue { M }
{
\__fun_do_assignment:Nnn #1 { \bool_gset_true:N #1 } { \bool_set_true:N #1 }
}
-\PrgNewFunction \BoolSetFalse { M }
+\fun at NewTwoFunctions \boolSetFalse \BoolSetFalse { M }
{
\__fun_do_assignment:Nnn #1 { \bool_gset_false:N #1 } { \bool_set_false:N #1 }
}
-\PrgNewFunction \BoolSetEq { M M }
+\fun at NewTwoFunctions \boolSetEq \BoolSetEq { M M }
{
\__fun_do_assignment:Nnn #1
{ \bool_gset_eq:NN #1 #2 } { \bool_set_eq:NN #1 #2 }
}
-\PrgNewFunction \BoolLog { e } { \bool_log:n {#1} }
+\fun at NewTwoFunctions \boolLog \BoolLog { e } { \bool_log:n {#1} }
-\PrgNewFunction \BoolVarLog { M } { \bool_log:N #1 }
+\fun at NewTwoFunctions \boolVarLog \BoolVarLog { M } { \bool_log:N #1 }
-\PrgNewFunction \BoolShow { e } { \bool_show:n {#1} }
+\fun at NewTwoFunctions \boolShow \BoolShow { e } { \bool_show:n {#1} }
-\PrgNewFunction \BoolVarShow { M } { \bool_show:N #1 }
+\fun at NewTwoFunctions \boolVarShow \BoolVarShow { M } { \bool_show:N #1 }
-\PrgNewConditional \BoolIfExist { M }
+\fun at NewTwoConditionals \boolIfExist \BoolIfExist { M }
{
- \bool_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \bool_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \BoolVarIf { M } { \Return {#1} }
+\fun at NewTwoConditionals \boolVarIf \BoolVarIf { M } { \prgReturn {#1} }
-\PrgNewConditional \BoolVarNot { M }
+\fun at NewTwoConditionals \boolVarNot \BoolVarNot { M }
{
\bool_if:NTF #1
- { \Return { \cFalseBool } } { \Return { \cTrueBool } }
+ { \prgReturn { \cFalseBool } } { \prgReturn { \cTrueBool } }
}
-\PrgNewConditional \BoolVarAnd { M M }
+\fun at NewTwoConditionals \boolVarAnd \BoolVarAnd { M M }
{
\bool_lazy_and:nnTF {#1} {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \BoolVarOr { M M }
+\fun at NewTwoConditionals \boolVarOr \BoolVarOr { M M }
{
\bool_lazy_or:nnTF {#1} {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \BoolVarXor { M M }
+\fun at NewTwoConditionals \boolVarXor \BoolVarXor { M M }
{
\bool_xor:nnTF {#1} {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewFunction \BoolVarDoUntil { N n }
+\fun at NewTwoFunctions \boolVarDoUntil \BoolVarDoUntil { N n }
{
\bool_do_until:Nn #1 {#2}
}
-\PrgNewFunction \BoolVarDoWhile { N n }
+\fun at NewTwoFunctions \boolVarDoWhile \BoolVarDoWhile { N n }
{
\bool_do_while:Nn #1 {#2}
}
-\PrgNewFunction \BoolVarUntilDo { N n }
+\fun at NewTwoFunctions \boolVarUntilDo \BoolVarUntilDo { N n }
{
\bool_until_do:Nn #1 {#2}
}
-\PrgNewFunction \BoolVarWhileDo { N n }
+\fun at NewTwoFunctions \boolVarWhileDo \BoolVarWhileDo { N n }
{
\bool_while_do:Nn #1 {#2}
}
@@ -959,186 +975,214 @@
\tl_new:N \gTmpiTl \tl_new:N \gTmpjTl \tl_new:N \gTmpkTl
\tl_new:N \g at FunTmpxTl \tl_new:N \g at FunTmpyTl \tl_new:N \g at FunTmpzTl
-\PrgNewFunction \TlNew { M } { \tl_new:N #1 }
+\fun at NewTwoFunctions \tlNew \TlNew { M } { \tl_new:N #1 }
-\PrgNewFunction \TlLog { m } { \tl_log:n { #1 } }
+\fun at NewTwoFunctions \tlLog \TlLog { m } { \tl_log:n { #1 } }
-\PrgNewFunction \TlVarLog { M } { \tl_log:N #1 }
+\fun at NewTwoFunctions \tlVarLog \TlVarLog { M } { \tl_log:N #1 }
-\PrgNewFunction \TlShow { m } { \tl_show:n { #1 } }
+\fun at NewTwoFunctions \tlShow \TlShow { m } { \tl_show:n { #1 } }
-\PrgNewFunction \TlVarShow { M } { \tl_show:N #1 }
+\fun at NewTwoFunctions \tlVarShow \TlVarShow { M } { \tl_show:N #1 }
-\PrgNewFunction \TlUse { M } { \Return { \Value #1 } }
+\fun at NewTwoFunctions \tlUse \TlUse { M } { \prgReturn { \expValue #1 } }
-\PrgNewFunction \TlToStr { m } { \Expand { \tl_to_str:n { #1 } } }
+\fun at NewTwoFunctions \tlToStr \TlToStr { m }
+ { \expWhole { \tl_to_str:n { #1 } } }
-\PrgNewFunction \TlVarToStr { M } { \Expand { \tl_to_str:N #1 } }
+\fun at NewTwoFunctions \tlVarToStr \TlVarToStr { M }
+ { \expWhole { \tl_to_str:N #1 } }
-\PrgNewFunction \TlConst { M m } { \tl_const:Nn #1 { #2 } }
+\fun at NewTwoFunctions \tlConst \TlConst { M m } { \tl_const:Nn #1 { #2 } }
-\PrgNewFunction \TlSet { M m }
+\fun at NewTwoFunctions \tlSet \TlSet { M m }
{
\__fun_do_assignment:Nnn #1 { \tl_gset:Nn #1 {#2} } { \tl_set:Nn #1 {#2} }
}
-\PrgNewFunction \TlSetEq { M M }
+\fun at NewTwoFunctions \tlSetEq \TlSetEq { M M }
{
\__fun_do_assignment:Nnn #1 { \tl_gset_eq:NN #1 #2 } { \tl_set_eq:NN #1 #2 }
}
-\PrgNewFunction \TlConcat { M M M }
+\fun at NewTwoFunctions \tlConcat \TlConcat { M M M }
{
\__fun_do_assignment:Nnn #1
{ \tl_gconcat:NNN #1 #2 #3 } { \tl_concat:NNN #1 #2 #3 }
}
-\PrgNewFunction \TlClear { M }
+\fun at NewTwoFunctions \tlClear \TlClear { M }
{
\__fun_do_assignment:Nnn #1 { \tl_gclear:N #1 } { \tl_clear:N #1 }
}
-\PrgNewFunction \TlClearNew { M }
+\fun at NewTwoFunctions \tlClearNew \TlClearNew { M }
{
\__fun_do_assignment:Nnn #1 { \tl_gclear_new:N #1 } { \tl_clear_new:N #1 }
}
-\PrgNewFunction \TlPutLeft { M m }
+\fun at NewTwoFunctions \tlPutLeft \TlPutLeft { M m }
{
\__fun_do_assignment:Nnn #1
{ \tl_gput_left:Nn #1 {#2} } { \tl_put_left:Nn #1 {#2} }
}
-\PrgNewFunction \TlPutRight { M m }
+\fun at NewTwoFunctions \tlPutRight \TlPutRight { M m }
{
\__fun_do_assignment:Nnn #1
{ \tl_gput_right:Nn #1 {#2} } { \tl_put_right:Nn #1 {#2} }
}
-\PrgNewFunction \TlVarReplaceOnce { M m m }
+\fun at NewTwoFunctions \tlVarReplaceOnce \TlVarReplaceOnce { M m m }
{
\__fun_do_assignment:Nnn #1
{ \tl_greplace_once:Nnn #1 {#2} {#3} } { \tl_replace_once:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \TlVarReplaceAll { M m m }
+\fun at NewTwoFunctions \tlVarReplaceAll \TlVarReplaceAll { M m m }
{
\__fun_do_assignment:Nnn #1
{ \tl_greplace_all:Nnn #1 {#2} {#3} } { \tl_replace_all:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \TlVarRemoveOnce { M m }
+\fun at NewTwoFunctions \tlVarRemoveOnce \TlVarRemoveOnce { M m }
{
\__fun_do_assignment:Nnn #1
{ \tl_gremove_once:Nn #1 {#2} } { \tl_remove_once:Nn #1 {#2} }
}
-\PrgNewFunction \TlVarRemoveAll { M m }
+\fun at NewTwoFunctions \tlVarRemoveAll \TlVarRemoveAll { M m }
{
\__fun_do_assignment:Nnn #1
{ \tl_gremove_all:Nn #1 {#2} } { \tl_remove_all:Nn #1 {#2} }
}
-\PrgNewFunction \TlTrimSpaces { m } { \Expand { \tl_trim_spaces:n { #1 } } }
+\fun at NewTwoFunctions \tlTrimSpaces \TlTrimSpaces { m }
+ { \expWhole { \tl_trim_spaces:n { #1 } } }
-\PrgNewFunction \TlVarTrimSpaces { M }
+\fun at NewTwoFunctions \tlVarTrimSpaces \TlVarTrimSpaces { M }
{
- \__fun_do_assignment:Nnn #1 { \tl_gtrim_spaces:N #1 } { \tl_trim_spaces:N #1 }
+ \__fun_do_assignment:Nnn #1
+ { \tl_gtrim_spaces:N #1 } { \tl_trim_spaces:N #1 }
}
-\PrgNewFunction \TlCount { m } { \Expand { \tl_count:n { #1 } } }
+\fun at NewTwoFunctions \tlCount \TlCount { m }
+ { \expWhole { \tl_count:n { #1 } } }
-\PrgNewFunction \TlVarCount { M } { \Expand { \tl_count:N #1 } }
+\fun at NewTwoFunctions \tlVarCount \TlVarCount { M }
+ { \expWhole { \tl_count:N #1 } }
-\PrgNewFunction \TlHead { m } { \Expand { \tl_head:n { #1 } } }
+\fun at NewTwoFunctions \tlHead \TlHead { m }
+ { \expWhole { \tl_head:n { #1 } } }
-\PrgNewFunction \TlVarHead { M } { \Expand { \tl_head:N #1 } }
+\fun at NewTwoFunctions \tlVarHead \TlVarHead { M }
+ { \expWhole { \tl_head:N #1 } }
-\PrgNewFunction \TlTail { m } { \Expand { \tl_tail:n { #1 } } }
+\fun at NewTwoFunctions \tlTail \TlTail { m }
+ { \expWhole { \tl_tail:n { #1 } } }
-\PrgNewFunction \TlVarTail { M } { \Expand { \tl_tail:N #1 } }
+\fun at NewTwoFunctions \tlVarTail \TlVarTail { M }
+ { \expWhole { \tl_tail:N #1 } }
-\PrgNewFunction \TlItem { m m } { \Expand { \tl_item:nn {#1} {#2} } }
+\fun at NewTwoFunctions \tlItem \TlItem { m m }
+ { \expWhole { \tl_item:nn {#1} {#2} } }
-\PrgNewFunction \TlVarItem { M m } { \Expand { \tl_item:Nn #1 {#2} } }
+\fun at NewTwoFunctions \tlVarItem \TlVarItem { M m }
+ { \expWhole { \tl_item:Nn #1 {#2} } }
-\PrgNewFunction \TlRandItem { m } { \Expand { \tl_rand_item:n {#1} } }
+\fun at NewTwoFunctions \tlRandItem \TlRandItem { m }
+ { \expWhole { \tl_rand_item:n {#1} } }
-\PrgNewFunction \TlVarRandItem { M } { \Expand { \tl_rand_item:N #1 } }
+\fun at NewTwoFunctions \tlVarRandItem \TlVarRandItem { M }
+ { \expWhole { \tl_rand_item:N #1 } }
-\PrgNewFunction \TlVarCase { M m } { \tl_case:Nn {#1} {#2} }
-\PrgNewFunction \TlVarCaseT { M m n } { \tl_case:NnT {#1} {#2} {#3} }
-\PrgNewFunction \TlVarCaseF { M m n } { \tl_case:NnF {#1} {#2} {#3} }
-\PrgNewFunction \TlVarCaseTF { M m n n } { \tl_case:NnTF {#1} {#2} {#3} {#4} }
+\fun at NewTwoFunctions \tlVarCase \TlVarCase { M m }
+ { \tl_case:Nn {#1} {#2} }
+\fun at NewTwoFunctions \tlVarCaseT \TlVarCaseT { M m n }
+ { \tl_case:NnT {#1} {#2} {#3} }
+\fun at NewTwoFunctions \tlVarCaseF \TlVarCaseF { M m n }
+ { \tl_case:NnF {#1} {#2} {#3} }
+\fun at NewTwoFunctions \tlVarCaseTF \TlVarCaseTF { M m n n }
+ { \tl_case:NnTF {#1} {#2} {#3} {#4} }
-\PrgNewFunction \TlMapInline { m n }
+\fun at NewTwoFunctions \tlMapInline \TlMapInline { m n }
{
\tl_map_inline:nn {#1} {#2}
}
-\PrgNewFunction \TlVarMapInline { M n }
+\fun at NewTwoFunctions \tlVarMapInline \TlVarMapInline { M n }
{
\tl_map_inline:Nn #1 {#2}
}
-\PrgNewFunction \TlMapVariable { m M n }
+\fun at NewTwoFunctions \tlMapVariable \TlMapVariable { m M n }
{
\tl_map_variable:nNn {#1} #2 {#3}
}
-\PrgNewFunction \TlVarMapVariable { M M n }
+\fun at NewTwoFunctions \tlVarMapVariable \TlVarMapVariable { M M n }
{
\tl_map_variable:NNn #1 #2 {#3}
}
-\PrgNewConditional \TlIfExist { M }
+\fun at NewTwoConditionals \tlIfExist \TlIfExist { M }
{
- \tl_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlIfEmpty { m }
+\fun at NewTwoConditionals \tlIfEmpty \TlIfEmpty { m }
{
- \tl_if_empty:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_empty:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlVarIfEmpty { M }
+\fun at NewTwoConditionals \tlVarIfEmpty \TlVarIfEmpty { M }
{
- \tl_if_empty:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_empty:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlIfBlank { m }
+\fun at NewTwoConditionals \tlIfBlank \TlIfBlank { m }
{
- \tl_if_blank:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_blank:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlIfEq { m m }
+\fun at NewTwoConditionals \tlIfEq \TlIfEq { m m }
{
- \tl_if_eq:nnTF {#1} {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_eq:nnTF {#1} {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlVarIfEq { M M }
+\fun at NewTwoConditionals \tlVarIfEq \TlVarIfEq { M M }
{
- \tl_if_eq:NNTF #1 #2 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_eq:NNTF #1 #2
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlIfIn { m m }
+\fun at NewTwoConditionals \tlIfIn \TlIfIn { m m }
{
- \tl_if_in:nnTF {#1} {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_in:nnTF {#1} {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlVarIfIn { M m }
+\fun at NewTwoConditionals \tlVarIfIn \TlVarIfIn { M m }
{
- \tl_if_in:NnTF #1 {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_in:NnTF #1 {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlIfSingle { m }
+\fun at NewTwoConditionals \tlIfSingle \TlIfSingle { m }
{
- \tl_if_single:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_single:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \TlVarIfSingle { M }
+\fun at NewTwoConditionals \tlVarIfSingle \TlVarIfSingle { M }
{
- \tl_if_single:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \tl_if_single:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -1167,77 +1211,80 @@
\str_new:N \gTmpiStr \str_new:N \gTmpjStr \str_new:N \gTmpkStr
\str_new:N \g at FunTmpxStr \str_new:N \g at FunTmpyStr \str_new:N \g at FunTmpzStr
-\PrgNewFunction \StrNew { M } { \str_new:N #1 }
+\fun at NewTwoFunctions \strNew \StrNew { M } { \str_new:N #1 }
-\PrgNewFunction \StrLog { m } { \str_log:n { #1 } }
+\fun at NewTwoFunctions \strLog \StrLog { m } { \str_log:n { #1 } }
-\PrgNewFunction \StrVarLog { M } { \str_log:N #1 }
+\fun at NewTwoFunctions \strVarLog \StrVarLog { M } { \str_log:N #1 }
-\PrgNewFunction \StrShow { m } { \str_show:n { #1 } }
+\fun at NewTwoFunctions \strShow \StrShow { m } { \str_show:n { #1 } }
-\PrgNewFunction \StrVarShow { M } { \str_show:N #1 }
+\fun at NewTwoFunctions \strVarShow \StrVarShow { M } { \str_show:N #1 }
-\PrgNewFunction \StrUse { M } { \Return { \Value #1 } }
+\fun at NewTwoFunctions \strUse \StrUse { M } { \prgReturn { \expValue #1 } }
-\PrgNewFunction \StrConst { M m } { \str_const:Nn #1 {#2} }
+\fun at NewTwoFunctions \strConst \StrConst { M m } { \str_const:Nn #1 {#2} }
-\PrgNewFunction \StrSet { M m }
+\fun at NewTwoFunctions \strSet \StrSet { M m }
{
\__fun_do_assignment:Nnn #1 { \str_gset:Nn #1 {#2} } { \str_set:Nn #1 {#2} }
}
-\PrgNewFunction \StrSetEq { M M }
+\fun at NewTwoFunctions \strSetEq \StrSetEq { M M }
{
- \__fun_do_assignment:Nnn #1 { \str_gset_eq:NN #1 #2 } { \str_set_eq:NN #1 #2 }
+ \__fun_do_assignment:Nnn #1
+ { \str_gset_eq:NN #1 #2 } { \str_set_eq:NN #1 #2 }
}
-\PrgNewFunction \StrConcat { M M M }
+\fun at NewTwoFunctions \strConcat \StrConcat { M M M }
{
\__fun_do_assignment:Nnn #1
{ \str_gconcat:NNN #1 #2 #3 } { \str_concat:NNN #1 #2 #3 }
}
-\PrgNewFunction \StrClear { M }
+\fun at NewTwoFunctions \strClear \StrClear { M }
{
\__fun_do_assignment:Nnn #1 { \str_gclear:N #1 } { \str_clear:N #1 }
}
-\PrgNewFunction \StrClearNew { M }
+\fun at NewTwoFunctions \strClearNew \StrClearNew { M }
{
\__fun_do_assignment:Nnn #1 { \str_gclear_new:N #1 } { \str_clear_new:N #1 }
}
-\PrgNewFunction \StrPutLeft { M m }
+\fun at NewTwoFunctions \strPutLeft \StrPutLeft { M m }
{
\__fun_do_assignment:Nnn #1
{ \str_gput_left:Nn #1 {#2} } { \str_put_left:Nn #1 {#2} }
}
-\PrgNewFunction \StrPutRight { M m }
+\fun at NewTwoFunctions \strPutRight \StrPutRight { M m }
{
\__fun_do_assignment:Nnn #1
{ \str_gput_right:Nn #1 {#2} } { \str_put_right:Nn #1 {#2} }
}
-\PrgNewFunction \StrVarReplaceOnce { M m m }
+\fun at NewTwoFunctions \strVarReplaceOnce \StrVarReplaceOnce { M m m }
{
\__fun_do_assignment:Nnn #1
- { \str_greplace_once:Nnn #1 {#2} {#3} } { \str_replace_once:Nnn #1 {#2} {#3} }
+ { \str_greplace_once:Nnn #1 {#2} {#3} }
+ { \str_replace_once:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \StrVarReplaceAll { M m m }
+\fun at NewTwoFunctions \strVarReplaceAll \StrVarReplaceAll { M m m }
{
\__fun_do_assignment:Nnn #1
- { \str_greplace_all:Nnn #1 {#2} {#3} } { \str_replace_all:Nnn #1 {#2} {#3} }
+ { \str_greplace_all:Nnn #1 {#2} {#3} }
+ { \str_replace_all:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \StrVarRemoveOnce { M m }
+\fun at NewTwoFunctions \strVarRemoveOnce \StrVarRemoveOnce { M m }
{
\__fun_do_assignment:Nnn #1
{ \str_gremove_once:Nn #1 {#2} } { \str_remove_once:Nn #1 {#2} }
}
-\PrgNewFunction \StrVarRemoveAll { M m }
+\fun at NewTwoFunctions \strVarRemoveAll \StrVarRemoveAll { M m }
{
\__fun_do_assignment:Nnn #1
{ \str_gremove_all:Nn #1 {#2} } { \str_remove_all:Nn #1 {#2} }
@@ -1244,98 +1291,112 @@
}
%% Avoid naming confict with xstring package
-\cs_if_exist:NF \StrCount
- { \PrgNewFunction \StrCount { m } { \Expand { \str_count:n { #1 } } } }
+\fun at NewTwoFunctions \strCount \StrCount { m }
+ { \expWhole { \str_count:n { #1 } } }
%% Provide another name for \StrCount function
-\PrgNewFunction \StrSize { m } { \Expand { \str_count:n { #1 } } }
+\prgNewFunction \StrSize { m } { \expWhole { \str_count:n { #1 } } }
-\PrgNewFunction \StrVarCount { M } { \Expand { \str_count:N #1 } }
+\fun at NewTwoFunctions \strVarCount \StrVarCount { M }
+ { \expWhole { \str_count:N #1 } }
-\PrgNewFunction \StrHead { m } { \Expand { \str_head:n { #1 } } }
+\fun at NewTwoFunctions \strHead \StrHead { m }
+ { \expWhole { \str_head:n { #1 } } }
-\PrgNewFunction \StrVarHead { M } { \Expand { \str_head:N #1 } }
+\fun at NewTwoFunctions \strVarHead \StrVarHead { M }
+ { \expWhole { \str_head:N #1 } }
-\PrgNewFunction \StrTail { m } { \Expand { \str_tail:n { #1 } } }
+\fun at NewTwoFunctions \strTail \StrTail { m }
+ { \expWhole { \str_tail:n { #1 } } }
-\PrgNewFunction \StrVarTail { M } { \Expand { \str_tail:N #1 } }
+\fun at NewTwoFunctions \strVarTail \StrVarTail { M }
+ { \expWhole { \str_tail:N #1 } }
-\PrgNewFunction \StrItem { m m } { \Expand { \str_item:nn {#1} {#2} } }
+\fun at NewTwoFunctions \strItem \StrItem { m m }
+ { \expWhole { \str_item:nn {#1} {#2} } }
-\PrgNewFunction \StrVarItem { M m } { \Expand { \str_item:Nn #1 {#2} } }
+\fun at NewTwoFunctions \strVarItem \StrVarItem { M m }
+ { \expWhole { \str_item:Nn #1 {#2} } }
-\PrgNewFunction \StrCase { m m } { \str_case:nn {#1} {#2} }
-\PrgNewFunction \StrCaseT { m m n } { \str_case:nnT {#1} {#2} {#3} }
-\PrgNewFunction \StrCaseF { m m n } { \str_case:nnF {#1} {#2} {#3} }
-\PrgNewFunction \StrCaseTF { m m n n } { \str_case:nnTF {#1} {#2} {#3} {#4} }
+\fun at NewTwoFunctions \strCase \StrCase { m m }
+ { \str_case:nn {#1} {#2} }
+\fun at NewTwoFunctions \strCaseT \StrCaseT { m m n }
+ { \str_case:nnT {#1} {#2} {#3} }
+\fun at NewTwoFunctions \strCaseF \StrCaseF { m m n }
+ { \str_case:nnF {#1} {#2} {#3} }
+\fun at NewTwoFunctions \strCaseTF \StrCaseTF { m m n n }
+ { \str_case:nnTF {#1} {#2} {#3} {#4} }
-\PrgNewFunction \StrMapInline { m n }
+\fun at NewTwoFunctions \strMapInline \StrMapInline { m n }
{
\str_map_inline:nn {#1} {#2}
}
-\PrgNewFunction \StrVarMapInline { M n }
+\fun at NewTwoFunctions \strVarMapInline \StrVarMapInline { M n }
{
\str_map_inline:Nn #1 {#2}
}
-\PrgNewFunction \StrMapVariable { m M n }
+\fun at NewTwoFunctions \strMapVariable \StrMapVariable { m M n }
{
\str_map_variable:nNn {#1} #2 {#3}
}
-\PrgNewFunction \StrVarMapVariable { M M n }
+\fun at NewTwoFunctions \strVarMapVariable \StrVarMapVariable { M M n }
{
\str_map_variable:NNn #1 #2 {#3}
}
-\PrgNewConditional \StrIfExist { M }
+\fun at NewTwoConditionals \strIfExist \StrIfExist { M }
{
- \str_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \StrVarIfEmpty { M }
+\fun at NewTwoConditionals \strVarIfEmpty \StrVarIfEmpty { M }
{
- \str_if_empty:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_empty:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \StrIfEq { m m }
+\fun at NewTwoConditionals \strIfEq \StrIfEq { m m }
{
- \str_if_eq:nnTF {#1} {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_eq:nnTF {#1} {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \StrVarIfEq { M M }
+\fun at NewTwoConditionals \strVarIfEq \StrVarIfEq { M M }
{
- \str_if_eq:NNTF #1 #2 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_eq:NNTF #1 #2
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \StrIfIn { m m }
+\fun at NewTwoConditionals \strIfIn \StrIfIn { m m }
{
- \str_if_in:nnTF {#1} {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_in:nnTF {#1} {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \StrVarIfIn { M m }
+\fun at NewTwoConditionals \strVarIfIn \StrVarIfIn { M m }
{
- \str_if_in:NnTF #1 {#2} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \str_if_in:NnTF #1 {#2}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%% Avoid naming confict with xstring package
-\cs_if_exist:NF \StrCompare
+\fun at NewTwoConditionals \strCompare \StrCompare { m N m }
{
- \PrgNewConditional \StrCompare { m N m }
- {
- \str_compare:nNnTF {#1} #2 {#3}
- { \Return { \cTrueBool } }
- { \Return { \cFalseBool } }
- }
+ \str_compare:nNnTF {#1} #2 {#3}
+ { \prgReturn { \cTrueBool } }
+ { \prgReturn { \cFalseBool } }
}
%% Provide another name for \StrCompare function
-\PrgNewConditional \StrIfCompare { m N m }
+\prgNewConditional \StrIfCompare { m N m }
{
\str_compare:nNnTF {#1} #2 {#3}
- { \Return { \cTrueBool } }
- { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } }
+ { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -1356,139 +1417,157 @@
\int_new:N \gTmpiInt \int_new:N \gTmpjInt \int_new:N \gTmpkInt
\int_new:N \g at FunTmpxInt \int_new:N \g at FunTmpyInt \int_new:N \g at FunTmpzInt
-\PrgNewFunction \IntEval { e } { \Expand { \int_eval:n {#1} } }
+\fun at NewTwoFunctions \intEval \IntEval { e } { \expWhole { \int_eval:n {#1} } }
-\PrgNewFunction \IntMathAdd { e e } { \Expand { \int_eval:n { (#1) + (#2) } } }
+\fun at NewTwoFunctions \intMathAdd \IntMathAdd { e e }
+ { \expWhole { \int_eval:n { (#1) + (#2) } } }
-\PrgNewFunction \IntMathSub { e e } { \Expand { \int_eval:n { (#1) - (#2) } } }
+\fun at NewTwoFunctions \intMathSub \IntMathSub { e e }
+ { \expWhole { \int_eval:n { (#1) - (#2) } } }
-\PrgNewFunction \IntMathMult { e e } { \Expand { \int_eval:n { (#1) * (#2) } } }
+\fun at NewTwoFunctions \intMathMult \IntMathMult { e e }
+ { \expWhole { \int_eval:n { (#1) * (#2) } } }
-\PrgNewFunction \IntMathDiv { e e } { \Expand { \int_div_round:nn {#1} {#2} } }
+\fun at NewTwoFunctions \intMathDiv \IntMathDiv { e e }
+ { \expWhole { \int_div_round:nn {#1} {#2} } }
-\PrgNewFunction \IntMathDivTruncate { e e }
+\fun at NewTwoFunctions \intMathDivTruncate \IntMathDivTruncate { e e }
{
- \Expand { \int_div_truncate:nn {#1} {#2} }
+ \expWhole { \int_div_truncate:nn {#1} {#2} }
}
-\PrgNewFunction \IntMathSign { e } { \Expand { \int_sign:n {#1} } }
+\fun at NewTwoFunctions \intMathSign \IntMathSign { e }
+ { \expWhole { \int_sign:n {#1} } }
-\PrgNewFunction \IntMathAbs { e } { \Expand { \int_abs:n {#1} } }
+\fun at NewTwoFunctions \intMathAbs \IntMathAbs { e }
+ { \expWhole { \int_abs:n {#1} } }
-\PrgNewFunction \IntMathMax { e e } { \Expand { \int_max:nn {#1} {#2} } }
+\fun at NewTwoFunctions \intMathMax \IntMathMax { e e }
+ { \expWhole { \int_max:nn {#1} {#2} } }
-\PrgNewFunction \IntMathMin { e e } { \Expand { \int_min:nn {#1} {#2} } }
+\fun at NewTwoFunctions \intMathMin \IntMathMin { e e }
+ { \expWhole { \int_min:nn {#1} {#2} } }
-\PrgNewFunction \IntMathMod { e e } { \Expand { \int_mod:nn {#1} {#2} } }
+\fun at NewTwoFunctions \intMathMod \IntMathMod { e e }
+ { \expWhole { \int_mod:nn {#1} {#2} } }
-\PrgNewFunction \IntMathRand { e e } { \Expand { \int_rand:nn {#1} {#2} } }
+\fun at NewTwoFunctions \intMathRand \IntMathRand { e e }
+ { \expWhole { \int_rand:nn {#1} {#2} } }
-\PrgNewFunction \IntNew { M } { \int_new:N #1 }
+\fun at NewTwoFunctions \intNew \IntNew { M } { \int_new:N #1 }
-\PrgNewFunction \IntConst { M e } { \int_const:Nn #1 { #2 } }
+\fun at NewTwoFunctions \intConst \IntConst { M e } { \int_const:Nn #1 { #2 } }
-\PrgNewFunction \IntLog { e } { \int_log:n { #1 } }
+\fun at NewTwoFunctions \intLog \IntLog { e } { \int_log:n { #1 } }
-\PrgNewFunction \IntVarLog { M } { \int_log:N #1 }
+\fun at NewTwoFunctions \intVarLog \IntVarLog { M } { \int_log:N #1 }
-\PrgNewFunction \IntShow { e } { \int_show:n { #1 } }
+\fun at NewTwoFunctions \intShow \IntShow { e } { \int_show:n { #1 } }
-\PrgNewFunction \IntVarShow { M } { \int_show:N #1 }
+\fun at NewTwoFunctions \intVarShow \IntVarShow { M } { \int_show:N #1 }
-\PrgNewFunction \IntUse { M } { \Return { \Value #1 } }
+\fun at NewTwoFunctions \intUse \IntUse { M } { \prgReturn { \expValue #1 } }
-\PrgNewFunction \IntSet { M e }
+\fun at NewTwoFunctions \intSet \IntSet { M e }
{
\__fun_do_assignment:Nnn #1 { \int_gset:Nn #1 {#2} } { \int_set:Nn #1 {#2} }
}
-\PrgNewFunction \IntZero { M }
+\fun at NewTwoFunctions \intZero \IntZero { M }
{
\__fun_do_assignment:Nnn #1 { \int_gzero:N #1 } { \int_zero:N #1 }
}
-\PrgNewFunction \IntZeroNew { M }
+\fun at NewTwoFunctions \intZeroNew \IntZeroNew { M }
{
\__fun_do_assignment:Nnn #1 { \int_gzero_new:N #1 } { \int_zero_new:N #1 }
}
-\PrgNewFunction \IntSetEq { M M }
+\fun at NewTwoFunctions \intSetEq \IntSetEq { M M }
{
- \__fun_do_assignment:Nnn #1 { \int_gset_eq:NN #1 #2 } { \int_set_eq:NN #1 #2 }
+ \__fun_do_assignment:Nnn #1
+ { \int_gset_eq:NN #1 #2 } { \int_set_eq:NN #1 #2 }
}
-\PrgNewFunction \IntIncr { M }
+\fun at NewTwoFunctions \intIncr \IntIncr { M }
{
\__fun_do_assignment:Nnn #1 { \int_gincr:N #1 } { \int_incr:N #1 }
}
-\PrgNewFunction \IntDecr { M }
+\fun at NewTwoFunctions \intDecr \IntDecr { M }
{
\__fun_do_assignment:Nnn #1 { \int_gdecr:N #1 } { \int_decr:N #1 }
}
-\PrgNewFunction \IntAdd { M e }
+\fun at NewTwoFunctions \intAdd \IntAdd { M e }
{
\__fun_do_assignment:Nnn #1 { \int_gadd:Nn #1 {#2} } { \int_add:Nn #1 {#2} }
}
-\PrgNewFunction \IntSub { M e }
+\fun at NewTwoFunctions \intSub \IntSub { M e }
{
\__fun_do_assignment:Nnn #1 { \int_gsub:Nn #1 {#2} } { \int_sub:Nn #1 {#2} }
}
%% Command \prg_replicate:nn yields its result after two expansion steps
-\PrgNewFunction \IntReplicate { e m }
+\fun at NewTwoFunctions \intReplicate \IntReplicate { e m }
{
- \exp_args:NNo \exp_args:No \Return { \prg_replicate:nn {#1} {#2} }
+ \exp_args:NNo \exp_args:No \prgReturn { \prg_replicate:nn {#1} {#2} }
}
-\PrgNewFunction \IntStepInline { e e e n }
+\fun at NewTwoFunctions \intStepInline \IntStepInline { e e e n }
{
\int_step_inline:nnnn {#1} {#2} {#3} {#4}
}
-\PrgNewFunction \IntStepOneInline { e e n }
+\fun at NewTwoFunctions \intStepOneInline \IntStepOneInline { e e n }
{
\int_step_inline:nnn {#1} {#2} {#3}
}
-\PrgNewFunction \IntStepVariable { e e e M n }
+\fun at NewTwoFunctions \intStepVariable \IntStepVariable { e e e M n }
{
\int_step_variable:nnnNn {#1} {#2} {#3} #4 {#5}
}
-\PrgNewFunction \IntStepOneVariable { e e M n }
+\fun at NewTwoFunctions \intStepOneVariable \IntStepOneVariable { e e M n }
{
\int_step_variable:nnNn {#1} {#2} #3 {#4}
}
-\PrgNewConditional \IntIfExist { M }
+\fun at NewTwoConditionals \intIfExist \IntIfExist { M }
{
- \int_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \int_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \IntIfOdd { e }
+\fun at NewTwoConditionals \intIfOdd \IntIfOdd { e }
{
- \int_if_odd:nTF { #1 } { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \int_if_odd:nTF { #1 }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \IntIfEven { e }
+\fun at NewTwoConditionals \intIfEven \IntIfEven { e }
{
- \int_if_even:nTF { #1 } { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \int_if_even:nTF { #1 }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \IntCompare { e N e }
+\fun at NewTwoConditionals \intCompare \IntCompare { e N e }
{
\int_compare:nNnTF {#1} #2 {#3}
- { \Return { \cTrueBool } }
- { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } }
+ { \prgReturn { \cFalseBool } }
}
-\PrgNewFunction \IntCase { e m } { \int_case:nn {#1} {#2} }
-\PrgNewFunction \IntCaseT { e m n } { \int_case:nnT {#1} {#2} {#3} }
-\PrgNewFunction \IntCaseF { e m n } { \int_case:nnF {#1} {#2} {#3} }
-\PrgNewFunction \IntCaseTF { e m n n } { \int_case:nnTF {#1} {#2} {#3} {#4} }
+\fun at NewTwoFunctions \intCase \IntCase { e m }
+ { \int_case:nn {#1} {#2} }
+\fun at NewTwoFunctions \intCaseT \IntCaseT { e m n }
+ { \int_case:nnT {#1} {#2} {#3} }
+\fun at NewTwoFunctions \intCaseF \IntCaseF { e m n }
+ { \int_case:nnF {#1} {#2} {#3} }
+\fun at NewTwoFunctions \intCaseTF \IntCaseTF { e m n n }
+ { \int_case:nnTF {#1} {#2} {#3} {#4} }
%%% --------------------------------------------------------
%%> \section{Interfaces for Floating Point Numbers (Fp)}
@@ -1511,88 +1590,97 @@
\fp_new:N \gTmpiFp \fp_new:N \gTmpjFp \fp_new:N \gTmpkFp
\fp_new:N \g at FunTmpxFp \fp_new:N \g at FunTmpyFp \fp_new:N \g at FunTmpzFp
-\PrgNewFunction \FpEval { e } { \Expand { \fp_eval:n {#1} } }
+\fun at NewTwoFunctions \fpEval \FpEval { e } { \expWhole { \fp_eval:n {#1} } }
-\PrgNewFunction \FpMathAdd { e e } { \Expand { \fp_eval:n { (#1) + (#2) } } }
+\fun at NewTwoFunctions \fpMathAdd \FpMathAdd { e e }
+ { \expWhole { \fp_eval:n { (#1) + (#2) } } }
-\PrgNewFunction \FpMathSub { e e } { \Expand { \fp_eval:n { (#1) - (#2) } } }
+\fun at NewTwoFunctions \fpMathSub \FpMathSub { e e }
+ { \expWhole { \fp_eval:n { (#1) - (#2) } } }
-\PrgNewFunction \FpMathMult { e e } { \Expand { \fp_eval:n { (#1) * (#2) } } }
+\fun at NewTwoFunctions \fpMathMult \FpMathMult { e e }
+ { \expWhole { \fp_eval:n { (#1) * (#2) } } }
-\PrgNewFunction \FpMathDiv { e e } { \Expand { \fp_eval:n { (#1) / (#2) } } }
+\fun at NewTwoFunctions \fpMathDiv \FpMathDiv { e e }
+ { \expWhole { \fp_eval:n { (#1) / (#2) } } }
-\PrgNewFunction \FpMathSign { e } { \Expand { \fp_sign:n {#1} } }
+\fun at NewTwoFunctions \fpMathSign \FpMathSign { e }
+ { \expWhole { \fp_sign:n {#1} } }
-\PrgNewFunction \FpMathAbs { e } { \Expand { \fp_abs:n {#1} } }
+\fun at NewTwoFunctions \fpMathAbs \FpMathAbs { e }
+ { \expWhole { \fp_abs:n {#1} } }
-\PrgNewFunction \FpMathMax { e e } { \Expand { \fp_max:nn {#1} {#2} } }
+\fun at NewTwoFunctions \fpMathMax \FpMathMax { e e }
+ { \expWhole { \fp_max:nn {#1} {#2} } }
-\PrgNewFunction \FpMathMin { e e } { \Expand { \fp_min:nn {#1} {#2} } }
+\fun at NewTwoFunctions \fpMathMin \FpMathMin { e e }
+ { \expWhole { \fp_min:nn {#1} {#2} } }
-\PrgNewFunction \FpNew { M } { \fp_new:N #1 }
+\fun at NewTwoFunctions \fpNew \FpNew { M } { \fp_new:N #1 }
-\PrgNewFunction \FpConst { M e } { \fp_const:Nn #1 {#2} }
+\fun at NewTwoFunctions \fpConst \FpConst { M e } { \fp_const:Nn #1 {#2} }
-\PrgNewFunction \FpUse { M } { \Expand { \fp_use:N #1 } }
+\fun at NewTwoFunctions \fpUse \FpUse { M } { \expWhole { \fp_use:N #1 } }
-\PrgNewFunction \FpLog { e } { \fp_log:n {#1} }
+\fun at NewTwoFunctions \fpLog \FpLog { e } { \fp_log:n {#1} }
-\PrgNewFunction \FpVarLog { M } { \fp_log:N #1 }
+\fun at NewTwoFunctions \fpVarLog \FpVarLog { M } { \fp_log:N #1 }
-\PrgNewFunction \FpShow { e } { \fp_show:n {#1} }
+\fun at NewTwoFunctions \fpShow \FpShow { e } { \fp_show:n {#1} }
-\PrgNewFunction \FpVarShow { M } { \fp_show:N #1 }
+\fun at NewTwoFunctions \fpVarShow \FpVarShow { M } { \fp_show:N #1 }
-\PrgNewFunction \FpSet { M e }
+\fun at NewTwoFunctions \fpSet \FpSet { M e }
{
\__fun_do_assignment:Nnn #1 { \fp_gset:Nn #1 {#2} } { \fp_set:Nn #1 {#2} }
}
-\PrgNewFunction \FpSetEq { M M }
+\fun at NewTwoFunctions \fpSetEq \FpSetEq { M M }
{
\__fun_do_assignment:Nnn #1 { \fp_gset_eq:NN #1 #2 } { \fp_set_eq:NN #1 #2 }
}
-\PrgNewFunction \FpZero { M }
+\fun at NewTwoFunctions \fpZero \FpZero { M }
{
\__fun_do_assignment:Nnn #1 { \fp_gzero:N #1 } { \fp_zero:N #1 }
}
-\PrgNewFunction \FpZeroNew { M }
+\fun at NewTwoFunctions \fpZeroNew \FpZeroNew { M }
{
\__fun_do_assignment:Nnn #1 { \fp_gzero_new:N #1 } { \fp_zero_new:N #1 }
}
-\PrgNewFunction \FpAdd { M e }
+\fun at NewTwoFunctions \fpAdd \FpAdd { M e }
{
\__fun_do_assignment:Nnn #1 { \fp_gadd:Nn #1 {#2} } { \fp_add:Nn #1 {#2} }
}
-\PrgNewFunction \FpSub { M e }
+\fun at NewTwoFunctions \fpSub \FpSub { M e }
{
\__fun_do_assignment:Nnn #1 { \fp_gsub:Nn #1 {#2} } { \fp_sub:Nn #1 {#2} }
}
-\PrgNewFunction \FpStepInline { e e e n }
+\fun at NewTwoFunctions \fpStepInline \FpStepInline { e e e n }
{
\fp_step_inline:nnnn {#1} {#2} {#3} {#4}
}
-\PrgNewFunction \FpStepVariable { e e e M n }
+\fun at NewTwoFunctions \fpStepVariable \FpStepVariable { e e e M n }
{
\fp_step_variable:nnnNn {#1} {#2} {#3} #4 {#5}
}
-\PrgNewConditional \FpIfExist { M }
+\fun at NewTwoConditionals \fpIfExist \FpIfExist { M }
{
- \fp_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \fp_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \FpCompare { e N e }
+\fun at NewTwoConditionals \fpCompare \FpCompare { e N e }
{
\fp_compare:nNnTF {#1} #2 {#3}
- { \Return { \cTrueBool } }
- { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } }
+ { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -1610,124 +1698,130 @@
\dim_new:N \gTmpiDim \dim_new:N \gTmpjDim \dim_new:N \gTmpkDim
\dim_new:N \g at FunTmpxDim \dim_new:N \g at FunTmpyDim \dim_new:N \g at FunTmpzDim
-\PrgNewFunction \DimEval { m }
+\fun at NewTwoFunctions \dimEval \DimEval { m }
{
- \Return { \Expand { \dim_eval:n { #1 } } }
+ \prgReturn { \expWhole { \dim_eval:n { #1 } } }
}
-\PrgNewFunction \DimMathAdd { m m }
+\fun at NewTwoFunctions \dimMathAdd \DimMathAdd { m m }
{
\dim_set:Nn \l at FunTmpxDim { \dim_eval:n { (#1) + (#2) } }
- \Return { \Value \l at FunTmpxDim }
+ \prgReturn { \expValue \l at FunTmpxDim }
}
-\PrgNewFunction \DimMathSub { m m }
+\fun at NewTwoFunctions \dimMathSub \DimMathSub { m m }
{
\dim_set:Nn \l at FunTmpxDim { \dim_eval:n { (#1) - (#2) } }
- \Return { \Value \l at FunTmpxDim }
+ \prgReturn { \expValue \l at FunTmpxDim }
}
-\PrgNewFunction \DimMathSign { m }
+\fun at NewTwoFunctions \dimMathSign \DimMathSign { m }
{
- \Return { \Expand { \dim_sign:n { #1 } } }
+ \prgReturn { \expWhole { \dim_sign:n { #1 } } }
}
-\PrgNewFunction \DimMathAbs { m }
+\fun at NewTwoFunctions \dimMathAbs \DimMathAbs { m }
{
- \Return { \Expand { \dim_abs:n { #1 } } }
+ \prgReturn { \expWhole { \dim_abs:n { #1 } } }
}
-\PrgNewFunction \DimMathMax { m m }
+\fun at NewTwoFunctions \dimMathMax \DimMathMax { m m }
{
- \Return { \Expand { \dim_max:nn { #1 } { #2 } } }
+ \prgReturn { \expWhole { \dim_max:nn { #1 } { #2 } } }
}
-\PrgNewFunction \DimMathMin { m m }
+\fun at NewTwoFunctions \dimMathMin \DimMathMin { m m }
{
- \Return { \Expand { \dim_min:nn { #1 } { #2 } } }
+ \prgReturn { \expWhole { \dim_min:nn { #1 } { #2 } } }
}
-\PrgNewFunction \DimMathRatio { m m }
+\fun at NewTwoFunctions \dimMathRatio \DimMathRatio { m m }
{
- \Return { \Expand { \dim_ratio:nn { #1 } { #2 } } }
+ \prgReturn { \expWhole { \dim_ratio:nn { #1 } { #2 } } }
}
-\PrgNewFunction \DimNew { M } { \dim_new:N #1 }
+\fun at NewTwoFunctions \dimNew \DimNew { M } { \dim_new:N #1 }
-\PrgNewFunction \DimConst { M m } { \dim_const:Nn #1 {#2} }
+\fun at NewTwoFunctions \dimConst \DimConst { M m } { \dim_const:Nn #1 {#2} }
-\PrgNewFunction \DimUse { M } { \Return { \Value #1 } }
+\fun at NewTwoFunctions \dimUse \DimUse { M } { \prgReturn { \expValue #1 } }
-\PrgNewFunction \DimLog { m } { \dim_log:n { #1 } }
+\fun at NewTwoFunctions \dimLog \DimLog { m } { \dim_log:n { #1 } }
-\PrgNewFunction \DimVarLog { M } { \dim_log:N #1 }
+\fun at NewTwoFunctions \dimVarLog \DimVarLog { M } { \dim_log:N #1 }
-\PrgNewFunction \DimShow { m } { \dim_show:n { #1 } }
+\fun at NewTwoFunctions \dimShow \DimShow { m } { \dim_show:n { #1 } }
-\PrgNewFunction \DimVarShow { M } { \dim_show:N #1 }
+\fun at NewTwoFunctions \dimVarShow \DimVarShow { M } { \dim_show:N #1 }
-\PrgNewFunction \DimSet { M m }
+\fun at NewTwoFunctions \dimSet \DimSet { M m }
{
\__fun_do_assignment:Nnn #1 { \dim_gset:Nn #1 {#2} } { \dim_set:Nn #1 {#2} }
}
-\PrgNewFunction \DimSetEq { M M }
+\fun at NewTwoFunctions \dimSetEq \DimSetEq { M M }
{
- \__fun_do_assignment:Nnn #1 { \dim_gset_eq:NN #1 #2 } { \dim_set_eq:NN #1 #2 }
+ \__fun_do_assignment:Nnn #1
+ { \dim_gset_eq:NN #1 #2 } { \dim_set_eq:NN #1 #2 }
}
-\PrgNewFunction \DimZero { M }
+\fun at NewTwoFunctions \dimZero \DimZero { M }
{
\__fun_do_assignment:Nnn #1 { \dim_gzero:N #1 } { \dim_zero:N #1 }
}
-\PrgNewFunction \DimZeroNew { M }
+\fun at NewTwoFunctions \dimZeroNew \DimZeroNew { M }
{
\__fun_do_assignment:Nnn #1 { \dim_gzero_new:N #1 } { \dim_zero_new:N #1 }
}
-\PrgNewFunction \DimAdd { M m }
+\fun at NewTwoFunctions \dimAdd \DimAdd { M m }
{
\__fun_do_assignment:Nnn #1 { \dim_gadd:Nn #1 {#2} } { \dim_add:Nn #1 {#2} }
}
-\PrgNewFunction \DimSub { M m }
+\fun at NewTwoFunctions \dimSub \DimSub { M m }
{
\__fun_do_assignment:Nnn #1 { \dim_gsub:Nn #1 {#2} } { \dim_sub:Nn #1 {#2} }
}
-\PrgNewFunction \DimStepInline { m m m n }
+\fun at NewTwoFunctions \dimStepInline \DimStepInline { m m m n }
{
\dim_step_inline:nnnn { #1 } { #2 } { #3 } { #4 }
}
-\PrgNewFunction \DimStepVariable { m m m M n }
+\fun at NewTwoFunctions \dimStepVariable \DimStepVariable { m m m M n }
{
\dim_step_variable:nnnNn { #1 } { #2 } { #3 } #4 { #5 }
}
-\PrgNewConditional \DimIfExist { M }
+\fun at NewTwoConditionals \dimIfExist \DimIfExist { M }
{
- \dim_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \dim_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \DimCompare { m N m }
+\fun at NewTwoConditionals \dimCompare \DimCompare { m N m }
{
\dim_compare:nNnTF {#1} #2 {#3}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewFunction \DimCase { m m } { \dim_case:nn {#1} {#2} }
-\PrgNewFunction \DimCaseT { m m n } { \dim_case:nnT {#1} {#2} {#3} }
-\PrgNewFunction \DimCaseF { m m n } { \dim_case:nnF {#1} {#2} {#3} }
-\PrgNewFunction \DimCaseTF { m m n n } { \dim_case:nnTF {#1} {#2} {#3} {#4} }
+\fun at NewTwoFunctions \dimCase \DimCase { m m }
+ { \dim_case:nn {#1} {#2} }
+\fun at NewTwoFunctions \dimCaseT \DimCaseT { m m n }
+ { \dim_case:nnT {#1} {#2} {#3} }
+\fun at NewTwoFunctions \dimCaseF \DimCaseF { m m n }
+ { \dim_case:nnF {#1} {#2} {#3} }
+\fun at NewTwoFunctions \dimCaseTF \DimCaseTF { m m n n }
+ { \dim_case:nnTF {#1} {#2} {#3} {#4} }
%%% --------------------------------------------------------
%%> \section{Interfaces for Sorting Functions (Sort)}
%%% --------------------------------------------------------
-\cs_set_eq:NN \SortReturnSame \sort_return_same:
-\cs_set_eq:NN \SortReturnSwapped \sort_return_swapped:
+\cs_set_eq:NN \sortReturnSame \sort_return_same:
+\cs_set_eq:NN \sortReturnSwapped \sort_return_swapped:
%%% --------------------------------------------------------
%%> \section{Interfaces for Comma Separated Lists (Clist)}
@@ -1745,203 +1839,217 @@
\clist_set_eq:NN \cEmptyClist \c_empty_clist
-\PrgNewFunction \ClistNew { M } { \clist_new:N #1 }
+\fun at NewTwoFunctions \clistNew \ClistNew { M } { \clist_new:N #1 }
-\PrgNewFunction \ClistLog { m } { \clist_log:n { #1 } }
+\fun at NewTwoFunctions \clistLog \ClistLog { m } { \clist_log:n { #1 } }
-\PrgNewFunction \ClistVarLog { M } { \clist_log:N #1 }
+\fun at NewTwoFunctions \clistVarLog \ClistVarLog { M } { \clist_log:N #1 }
-\PrgNewFunction \ClistShow { m } { \clist_show:n { #1 } }
+\fun at NewTwoFunctions \clistShow \ClistShow { m } { \clist_show:n { #1 } }
-\PrgNewFunction \ClistVarShow { M } { \clist_show:N #1 }
+\fun at NewTwoFunctions \clistVarShow \ClistVarShow { M } { \clist_show:N #1 }
-\PrgNewFunction \ClistVarJoin { M m }
+\fun at NewTwoFunctions \clistVarJoin \ClistVarJoin { M m }
{
- \Expand { \clist_use:Nn #1 { #2 } }
+ \expWhole { \clist_use:Nn #1 { #2 } }
}
-\PrgNewFunction \ClistVarJoinExtended { M m m m }
+\fun at NewTwoFunctions \clistVarJoinExtended \ClistVarJoinExtended { M m m m }
{
- \Expand { \clist_use:Nnnn #1 { #2 } { #3 } { #4 } }
+ \expWhole { \clist_use:Nnnn #1 { #2 } { #3 } { #4 } }
}
-\PrgNewFunction \ClistJoin { m m }
+\fun at NewTwoFunctions \clistJoin \ClistJoin { m m }
{
- \Expand { \clist_use:nn { #1 } { #2 } }
+ \expWhole { \clist_use:nn { #1 } { #2 } }
}
-\PrgNewFunction \ClistJoinExtended { m m m m }
+\fun at NewTwoFunctions \clistJoinExtended \ClistJoinExtended { m m m m }
{
- \Expand { \clist_use:nnnn { #1 } { #2 } { #3 } { #4 } }
+ \expWhole { \clist_use:nnnn { #1 } { #2 } { #3 } { #4 } }
}
-\PrgNewFunction \ClistConst { M m } { \clist_const:Nn #1 { #2 } }
+\fun at NewTwoFunctions \clistConst \ClistConst { M m }
+ { \clist_const:Nn #1 { #2 } }
-\PrgNewFunction \ClistSet { M m }
+\fun at NewTwoFunctions \clistSet \ClistSet { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gset:Nn #1 {#2} } { \clist_set:Nn #1 {#2} }
}
-\PrgNewFunction \ClistSetEq { M M }
+\fun at NewTwoFunctions \clistSetEq \ClistSetEq { M M }
{
\__fun_do_assignment:Nnn #1
{ \clist_gset_eq:NN #1 #2 } { \clist_set_eq:NN #1 #2 }
}
-\PrgNewFunction \ClistSetFromSeq { M M }
+\fun at NewTwoFunctions \clistSetFromSeq \ClistSetFromSeq { M M }
{
\__fun_do_assignment:Nnn #1
{ \clist_gset_from_seq:NN #1 #2 } { \clist_set_from_seq:NN #1 #2 }
}
-\PrgNewFunction \ClistConcat { M M M }
+\fun at NewTwoFunctions \clistConcat \ClistConcat { M M M }
{
\__fun_do_assignment:Nnn #1
{ \clist_gconcat:NNN #1 #2 #3 } { \clist_concat:NNN #1 #2 #3 }
}
-\PrgNewFunction \ClistClear { M }
+\fun at NewTwoFunctions \clistClear \ClistClear { M }
{
\__fun_do_assignment:Nnn #1 { \clist_gclear:N #1 } { \clist_clear:N #1 }
}
-\PrgNewFunction \ClistClearNew { M }
+\fun at NewTwoFunctions \clistClearNew \ClistClearNew { M }
{
- \__fun_do_assignment:Nnn #1 { \clist_gclear_new:N #1 } { \clist_clear_new:N #1 }
+ \__fun_do_assignment:Nnn #1
+ { \clist_gclear_new:N #1 } { \clist_clear_new:N #1 }
}
-\PrgNewFunction \ClistPutLeft { M m }
+\fun at NewTwoFunctions \clistPutLeft \ClistPutLeft { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gput_left:Nn #1 {#2} } { \clist_put_left:Nn #1 {#2} }
}
-\PrgNewFunction \ClistPutRight { M m }
+\fun at NewTwoFunctions \clistPutRight \ClistPutRight { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gput_right:Nn #1 {#2} } { \clist_put_right:Nn #1 {#2} }
}
-\PrgNewFunction \ClistVarRemoveDuplicates { M }
+\fun at NewTwoFunctions \clistVarRemoveDuplicates \ClistVarRemoveDuplicates { M }
{
\__fun_do_assignment:Nnn #1
{ \clist_gremove_duplicates:N #1 } { \clist_remove_duplicates:N #1 }
}
-\PrgNewFunction \ClistVarRemoveAll { M m }
+\fun at NewTwoFunctions \clistVarRemoveAll \ClistVarRemoveAll { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gremove_all:Nn #1 {#2} } { \clist_remove_all:Nn #1 {#2} }
}
-\PrgNewFunction \ClistVarReverse { M }
+\fun at NewTwoFunctions \clistVarReverse \ClistVarReverse { M }
{
\__fun_do_assignment:Nnn #1 { \clist_greverse:N #1 } { \clist_reverse:N #1 }
}
-\PrgNewFunction \ClistVarSort { M m }
+\fun at NewTwoFunctions \clistVarSort \ClistVarSort { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gsort:Nn #1 {#2} } { \clist_sort:Nn #1 {#2} }
}
-\PrgNewFunction \ClistCount { m } { \Expand { \clist_count:n { #1 } } }
+\fun at NewTwoFunctions \clistCount \ClistCount { m }
+ { \expWhole { \clist_count:n { #1 } } }
-\PrgNewFunction \ClistVarCount { M } { \Expand { \clist_count:N #1 } }
+\fun at NewTwoFunctions \clistVarCount \ClistVarCount { M }
+ { \expWhole { \clist_count:N #1 } }
-\PrgNewFunction \ClistGet { M M }
+\fun at NewTwoFunctions \clistGet \ClistGet { M M }
{
\clist_get:NN #1 #2
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \ClistGetT { M M n } { \clist_get:NNT #1 #2 {#3} }
-\PrgNewFunction \ClistGetF { M M n } { \clist_get:NNF #1 #2 {#3} }
-\PrgNewFunction \ClistGetTF { M M n n } { \clist_get:NNTF #1 #2 {#3} {#4} }
+\fun at NewTwoFunctions \clistGetT \ClistGetT { M M n }
+ { \clist_get:NNT #1 #2 {#3} }
+\fun at NewTwoFunctions \clistGetF \ClistGetF { M M n }
+ { \clist_get:NNF #1 #2 {#3} }
+\fun at NewTwoFunctions \clistGetTF \ClistGetTF { M M n n }
+ { \clist_get:NNTF #1 #2 {#3} {#4} }
-\PrgNewFunction \ClistPop { M M }
+\fun at NewTwoFunctions \clistPop \ClistPop { M M }
{
\__fun_do_assignment:Nnn #1
{ \clist_gpop:NN #1 #2 } { \clist_pop:NN #1 #2 }
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \ClistPopT { M M n }
+\fun at NewTwoFunctions \clistPopT \ClistPopT { M M n }
{
\__fun_do_assignment:Nnn #1
{ \clist_gpop:NNT #1 #2 {#3} } { \clist_pop:NNT #1 #2 {#3} }
}
-\PrgNewFunction \ClistPopF { M M n }
+\fun at NewTwoFunctions \clistPopF \ClistPopF { M M n }
{
\__fun_do_assignment:Nnn #1
{ \clist_gpop:NNF #1 #2 {#3} } { \clist_pop:NNF #1 #2 {#3} }
}
-\PrgNewFunction \ClistPopTF { M M n n }
+\fun at NewTwoFunctions \clistPopTF \ClistPopTF { M M n n }
{
\__fun_do_assignment:Nnn #1
{ \clist_gpop:NNTF #1 #2 {#3} {#4} } { \clist_pop:NNTF #1 #2 {#3} {#4} }
}
-\PrgNewFunction \ClistPush { M m }
+\fun at NewTwoFunctions \clistPush \ClistPush { M m }
{
\__fun_do_assignment:Nnn #1
{ \clist_gpush:Nn #1 {#2} } { \clist_push:Nn #1 {#2} }
}
-\PrgNewFunction \ClistItem { m m } { \Expand { \clist_item:nn {#1} {#2} } }
+\fun at NewTwoFunctions \clistItem \ClistItem { m m }
+ { \expWhole { \clist_item:nn {#1} {#2} } }
-\PrgNewFunction \ClistVarItem { M m } { \Expand { \clist_item:Nn #1 {#2} } }
+\fun at NewTwoFunctions \clistVarItem \ClistVarItem { M m }
+ { \expWhole { \clist_item:Nn #1 {#2} } }
-\PrgNewFunction \ClistRandItem { m } { \Expand { \clist_rand_item:n {#1} } }
+\fun at NewTwoFunctions \clistRandItem \ClistRandItem { m }
+ { \expWhole { \clist_rand_item:n {#1} } }
-\PrgNewFunction \ClistVarRandItem { M } { \Expand { \clist_rand_item:N #1 } }
+\fun at NewTwoFunctions \clistVarRandItem \ClistVarRandItem { M }
+ { \expWhole { \clist_rand_item:N #1 } }
-\PrgNewFunction \ClistMapInline { m n }
+\fun at NewTwoFunctions \clistMapInline \ClistMapInline { m n }
{
\clist_map_inline:nn {#1} {#2}
}
-\PrgNewFunction \ClistVarMapInline { M n }
+\fun at NewTwoFunctions \clistVarMapInline \ClistVarMapInline { M n }
{
\clist_map_inline:Nn #1 {#2}
}
-\PrgNewFunction \ClistMapVariable { m M n }
+\fun at NewTwoFunctions \clistMapVariable \ClistMapVariable { m M n }
{
\clist_map_variable:nNn {#1} #2 {#3}
}
-\PrgNewFunction \ClistVarMapVariable { M M n }
+\fun at NewTwoFunctions \clistVarMapVariable \ClistVarMapVariable { M M n }
{
\clist_map_variable:NNn #1 #2 {#3}
}
-\cs_set_eq:NN \ClistMapBreak \clist_map_break:
+\cs_set_eq:NN \clistMapBreak \clist_map_break:
-\PrgNewConditional \ClistIfExist { M }
+\fun at NewTwoConditionals \clistIfExist \ClistIfExist { M }
{
- \clist_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \clist_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \ClistIfEmpty { m }
+\fun at NewTwoConditionals \clistIfEmpty \ClistIfEmpty { m }
{
- \clist_if_empty:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \clist_if_empty:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \ClistVarIfEmpty { M }
+\fun at NewTwoConditionals \clistVarIfEmpty \ClistVarIfEmpty { M }
{
- \clist_if_empty:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \clist_if_empty:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \ClistIfIn { m m }
+\fun at NewTwoConditionals \clistIfIn \ClistIfIn { m m }
{
\clist_if_in:nnTF {#1} {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \ClistVarIfIn { M m }
+\fun at NewTwoConditionals \clistVarIfIn \ClistVarIfIn { M m }
{
\clist_if_in:NnTF #1 {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -1958,177 +2066,188 @@
\seq_set_eq:NN \cEmptySeq \c_empty_seq
-\PrgNewFunction \SeqNew { M } { \seq_new:N #1 }
+\fun at NewTwoFunctions \seqNew \SeqNew { M } { \seq_new:N #1 }
-\PrgNewFunction \SeqVarLog { M } { \seq_log:N #1 }
+\fun at NewTwoFunctions \seqVarLog \SeqVarLog { M } { \seq_log:N #1 }
-\PrgNewFunction \SeqVarShow { M } { \seq_show:N #1 }
+\fun at NewTwoFunctions \seqVarShow \SeqVarShow { M } { \seq_show:N #1 }
-\PrgNewFunction \SeqVarJoin { M m }
+\fun at NewTwoFunctions \seqVarJoin \SeqVarJoin { M m }
{
- \Expand { \seq_use:Nn #1 { #2 } }
+ \expWhole { \seq_use:Nn #1 { #2 } }
}
-\PrgNewFunction \SeqVarJoinExtended { M m m m }
+\fun at NewTwoFunctions \seqVarJoinExtended \SeqVarJoinExtended { M m m m }
{
- \Expand { \seq_use:Nnnn #1 { #2 } { #3 } { #4 } }
+ \expWhole { \seq_use:Nnnn #1 { #2 } { #3 } { #4 } }
}
-\PrgNewFunction \SeqJoin { m m }
+\fun at NewTwoFunctions \seqJoin \SeqJoin { m m }
{
- \Expand { \seq_use:nn { #1 } { #2 } }
+ \expWhole { \seq_use:nn { #1 } { #2 } }
}
-\PrgNewFunction \SeqJoinExtended { m m m m }
+\fun at NewTwoFunctions \seqJoinExtended \SeqJoinExtended { m m m m }
{
- \Expand { \seq_use:nnnn { #1 } { #2 } { #3 } { #4 } }
+ \expWhole { \seq_use:nnnn { #1 } { #2 } { #3 } { #4 } }
}
-\PrgNewFunction \SeqConstFromClist { M m } { \seq_const_from_clist:Nn #1 { #2 } }
+\fun at NewTwoFunctions \seqConstFromClist \SeqConstFromClist { M m }
+ { \seq_const_from_clist:Nn #1 { #2 } }
-\PrgNewFunction \SeqSetFromClist { M m }
+\fun at NewTwoFunctions \seqSetFromClist \SeqSetFromClist { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gset_from_clist:Nn #1 {#2} } { \seq_set_from_clist:Nn #1 {#2} }
}
-\PrgNewFunction \SeqSetEq { M M }
+\fun at NewTwoFunctions \seqSetEq \SeqSetEq { M M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gset_eq:NN #1 #2 } { \seq_set_eq:NN #1 #2 }
}
-\PrgNewFunction \SeqSetSplit { M m m }
+\fun at NewTwoFunctions \seqSetSplit \SeqSetSplit { M m m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gset_split:Nnn #1 {#2} {#3} } { \seq_set_split:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \SeqConcat { M M M }
+\fun at NewTwoFunctions \seqConcat \SeqConcat { M M M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gconcat:NNN #1 #2 #3 } { \seq_concat:NNN #1 #2 #3 }
}
-\PrgNewFunction \SeqClear { M }
+\fun at NewTwoFunctions \seqClear \SeqClear { M }
{
\__fun_do_assignment:Nnn #1 { \seq_gclear:N #1 } { \seq_clear:N #1 }
}
-\PrgNewFunction \SeqClearNew { M }
+\fun at NewTwoFunctions \seqClearNew \SeqClearNew { M }
{
\__fun_do_assignment:Nnn #1 { \seq_gclear_new:N #1 } { \seq_clear_new:N #1 }
}
-\PrgNewFunction \SeqPutLeft { M m }
+\fun at NewTwoFunctions \seqPutLeft \SeqPutLeft { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gput_left:Nn #1 {#2} } { \seq_put_left:Nn #1 {#2} }
}
-\PrgNewFunction \SeqPutRight { M m }
+\fun at NewTwoFunctions \seqPutRight \SeqPutRight { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gput_right:Nn #1 {#2} } { \seq_put_right:Nn #1 {#2} }
}
-\PrgNewFunction \SeqVarRemoveDuplicates { M }
+\fun at NewTwoFunctions \seqVarRemoveDuplicates \SeqVarRemoveDuplicates { M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gremove_duplicates:N #1 } { \seq_remove_duplicates:N #1 }
}
-\PrgNewFunction \SeqVarRemoveAll { M m }
+\fun at NewTwoFunctions \seqVarRemoveAll \SeqVarRemoveAll { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gremove_all:Nn #1 {#2} } { \seq_remove_all:Nn #1 {#2} }
}
-\PrgNewFunction \SeqVarReverse { M }
+\fun at NewTwoFunctions \seqVarReverse \SeqVarReverse { M }
{
\__fun_do_assignment:Nnn #1 { \seq_greverse:N #1 } { \seq_reverse:N #1 }
}
-\PrgNewFunction \SeqVarSort { M m }
+\fun at NewTwoFunctions \seqVarSort \SeqVarSort { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gsort:Nn #1 {#2} } { \seq_sort:Nn #1 {#2} }
}
-\PrgNewFunction \SeqVarCount { M } { \Expand { \seq_count:N #1 } }
+\fun at NewTwoFunctions \seqVarCount \SeqVarCount { M }
+ { \expWhole { \seq_count:N #1 } }
-\PrgNewFunction \SeqGet { M M }
+\fun at NewTwoFunctions \seqGet \SeqGet { M M }
{
\seq_get:NN #1 #2
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqGetT { M M n } { \seq_get:NNT #1 #2 {#3} }
-\PrgNewFunction \SeqGetF { M M n } { \seq_get:NNF #1 #2 {#3} }
-\PrgNewFunction \SeqGetTF { M M n n } { \seq_get:NNTF #1 #2 {#3} {#4} }
+\fun at NewTwoFunctions \seqGetT \SeqGetT { M M n }
+ { \seq_get:NNT #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetF \SeqGetF { M M n }
+ { \seq_get:NNF #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetTF \SeqGetTF { M M n n }
+ { \seq_get:NNTF #1 #2 {#3} {#4} }
-\PrgNewFunction \SeqPop { M M }
+\fun at NewTwoFunctions \seqPop \SeqPop { M M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop:NN #1 #2 } { \seq_pop:NN #1 #2 }
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqPopT { M M n }
+\fun at NewTwoFunctions \seqPopT \SeqPopT { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop:NNT #1 #2 {#3} } { \seq_pop:NNT #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopF { M M n }
+\fun at NewTwoFunctions \seqPopF \SeqPopF { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop:NNF #1 #2 {#3} } { \seq_pop:NNF #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopTF { M M n n }
+\fun at NewTwoFunctions \seqPopTF \SeqPopTF { M M n n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop:NNTF #1 #2 {#3} {#4} } { \seq_pop:NNTF #1 #2 {#3} {#4} }
}
-\PrgNewFunction \SeqPush { M m }
+\fun at NewTwoFunctions \seqPush \SeqPush { M m }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpush:Nn #1 {#2} } { \seq_push:Nn #1 {#2} }
}
-\PrgNewFunction \SeqGetLeft { M M }
+\fun at NewTwoFunctions \seqGetLeft \SeqGetLeft { M M }
{
\seq_get_left:NN #1 #2
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqGetLeftT { M M n } { \seq_get_left:NNT #1 #2 {#3} }
-\PrgNewFunction \SeqGetLeftF { M M n } { \seq_get_left:NNF #1 #2 {#3} }
-\PrgNewFunction \SeqGetLeftTF { M M n n } { \seq_get_left:NNTF #1 #2 {#3} {#4} }
+\fun at NewTwoFunctions \seqGetLeftT \SeqGetLeftT { M M n }
+ { \seq_get_left:NNT #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetLeftF \SeqGetLeftF { M M n }
+ { \seq_get_left:NNF #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetLeftTF \SeqGetLeftTF { M M n n }
+ { \seq_get_left:NNTF #1 #2 {#3} {#4} }
-\PrgNewFunction \SeqGetRight { M M }
+\fun at NewTwoFunctions \seqGetRight \SeqGetRight { M M }
{
\seq_get_right:NN #1 #2
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqGetRightT { M M n } { \seq_get_right:NNT #1 #2 {#3} }
-\PrgNewFunction \SeqGetRightF { M M n } { \seq_get_right:NNF #1 #2 {#3} }
-\PrgNewFunction \SeqGetRightTF { M M n n } { \seq_get_right:NNTF #1 #2 {#3} {#4} }
+\fun at NewTwoFunctions \seqGetRightT \SeqGetRightT { M M n }
+ { \seq_get_right:NNT #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetRightF \SeqGetRightF { M M n }
+ { \seq_get_right:NNF #1 #2 {#3} }
+\fun at NewTwoFunctions \seqGetRightTF \SeqGetRightTF { M M n n }
+ { \seq_get_right:NNTF #1 #2 {#3} {#4} }
-\PrgNewFunction \SeqPopLeft { M M }
+\fun at NewTwoFunctions \seqPopLeft \SeqPopLeft { M M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_left:NN #1 #2 } { \seq_pop_left:NN #1 #2 }
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqPopLeftT { M M n }
+\fun at NewTwoFunctions \seqPopLeftT \SeqPopLeftT { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_left:NNT #1 #2 {#3} } { \seq_pop_left:NNT #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopLeftF { M M n }
+\fun at NewTwoFunctions \seqPopLeftF \SeqPopLeftF { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_left:NNF #1 #2 {#3} } { \seq_pop_left:NNF #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopLeftTF { M M n n }
+\fun at NewTwoFunctions \seqPopLeftTF \SeqPopLeftTF { M M n n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_left:NNTF #1 #2 {#3} {#4} }
@@ -2135,23 +2254,23 @@
{ \seq_pop_left:NNTF #1 #2 {#3} {#4} }
}
-\PrgNewFunction \SeqPopRight { M M }
+\fun at NewTwoFunctions \seqPopRight \SeqPopRight { M M }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_right:NN #1 #2 } { \seq_pop_right:NN #1 #2 }
\__fun_quark_upgrade_no_value:N #2
}
-\PrgNewFunction \SeqPopRightT { M M n }
+\fun at NewTwoFunctions \seqPopRightT \SeqPopRightT { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_right:NNT #1 #2 {#3} } { \seq_pop_right:NNT #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopRightF { M M n }
+\fun at NewTwoFunctions \seqPopRightF \SeqPopRightF { M M n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_right:NNF #1 #2 {#3} } { \seq_pop_right:NNF #1 #2 {#3} }
}
-\PrgNewFunction \SeqPopRightTF { M M n n }
+\fun at NewTwoFunctions \seqPopRightTF \SeqPopRightTF { M M n n }
{
\__fun_do_assignment:Nnn #1
{ \seq_gpop_right:NNTF #1 #2 {#3} {#4} }
@@ -2158,36 +2277,40 @@
{ \seq_pop_right:NNTF #1 #2 {#3} {#4} }
}
-\PrgNewFunction \SeqVarItem { M m } { \Expand { \seq_item:Nn #1 {#2} } }
+\fun at NewTwoFunctions \seqVarItem \SeqVarItem { M m }
+ { \expWhole { \seq_item:Nn #1 {#2} } }
-\PrgNewFunction \SeqVarRandItem { M } { \Expand { \seq_rand_item:N #1 } }
+\fun at NewTwoFunctions \seqVarRandItem \SeqVarRandItem { M }
+ { \expWhole { \seq_rand_item:N #1 } }
-\PrgNewFunction \SeqVarMapInline { M n }
+\fun at NewTwoFunctions \seqVarMapInline \SeqVarMapInline { M n }
{
\seq_map_inline:Nn #1 {#2}
}
-\PrgNewFunction \SeqVarMapVariable { M M n }
+\fun at NewTwoFunctions \seqVarMapVariable \SeqVarMapVariable { M M n }
{
\seq_map_variable:NNn #1 #2 {#3}
}
-\cs_set_eq:NN \SeqMapBreak \seq_map_break:
+\cs_set_eq:NN \seqMapBreak \seq_map_break:
-\PrgNewConditional \SeqIfExist { M }
+\fun at NewTwoConditionals \seqIfExist \SeqIfExist { M }
{
- \seq_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \seq_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \SeqVarIfEmpty { M }
+\fun at NewTwoConditionals \seqVarIfEmpty \SeqVarIfEmpty { M }
{
- \seq_if_empty:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \seq_if_empty:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \SeqVarIfIn { M m }
+\fun at NewTwoConditionals \seqVarIfIn \SeqVarIfIn { M m }
{
\seq_if_in:NnTF #1 {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -2204,99 +2327,105 @@
\prop_set_eq:NN \cEmptyProp \c_empty_prop
-\PrgNewFunction \PropNew { M } { \prop_new:N #1 }
+\fun at NewTwoFunctions \propNew \PropNew { M } { \prop_new:N #1 }
-\PrgNewFunction \PropVarLog { M } { \prop_log:N #1 }
+\fun at NewTwoFunctions \propVarLog \PropVarLog { M } { \prop_log:N #1 }
-\PrgNewFunction \PropVarShow { M } { \prop_show:N #1 }
+\fun at NewTwoFunctions \propVarShow \PropVarShow { M } { \prop_show:N #1 }
-\PrgNewFunction \PropConstFromKeyval { M m }
+\fun at NewTwoFunctions \propConstFromKeyval \PropConstFromKeyval { M m }
{ \prop_const_from_keyval:Nn #1 { #2 } }
-\PrgNewFunction \PropSetFromKeyval { M m }
+\fun at NewTwoFunctions \propSetFromKeyval \PropSetFromKeyval { M m }
{
\__fun_do_assignment:Nnn #1
{ \prop_gset_from_keyval:Nn #1 {#2} } { \prop_set_from_keyval:Nn #1 {#2} }
}
-\PrgNewFunction \PropSetEq { M M }
+\fun at NewTwoFunctions \propSetEq \PropSetEq { M M }
{
\__fun_do_assignment:Nnn #1
{ \prop_gset_eq:NN #1 #2 } { \prop_set_eq:NN #1 #2 }
}
-\PrgNewFunction \PropClear { M }
+\fun at NewTwoFunctions \propClear \PropClear { M }
{
\__fun_do_assignment:Nnn #1 { \prop_gclear:N #1 } { \prop_clear:N #1 }
}
-\PrgNewFunction \PropClearNew { M }
+\fun at NewTwoFunctions \propClearNew \PropClearNew { M }
{
\__fun_do_assignment:Nnn #1 { \prop_gclear_new:N #1 } { \prop_clear_new:N #1 }
}
-\PrgNewFunction \PropConcat { M M M }
+\fun at NewTwoFunctions \propConcat \PropConcat { M M M }
{
\__fun_do_assignment:Nnn #1
{ \prop_gconcat:NNN #1 #2 #3 } { \prop_concat:NNN #1 #2 #3 }
}
-\PrgNewFunction \PropPut { M m m }
+\fun at NewTwoFunctions \propPut \PropPut { M m m }
{
\__fun_do_assignment:Nnn #1
{ \prop_gput:Nnn #1 {#2} {#3} } { \prop_put:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \PropPutIfNew { M m m }
+\fun at NewTwoFunctions \propPutIfNew \PropPutIfNew { M m m }
{
\__fun_do_assignment:Nnn #1
{ \prop_gput_if_new:Nnn #1 {#2} {#3} } { \prop_put_if_new:Nnn #1 {#2} {#3} }
}
-\PrgNewFunction \PropPutFromKeyval { M m }
+\fun at NewTwoFunctions \propPutFromKeyval \PropPutFromKeyval { M m }
{
\__fun_do_assignment:Nnn #1
{ \prop_gput_from_keyval:Nn #1 {#2} } { \prop_put_from_keyval:Nn #1 {#2} }
}
-\PrgNewFunction \PropVarRemove { M m }
+\fun at NewTwoFunctions \propVarRemove \PropVarRemove { M m }
{
\__fun_do_assignment:Nnn #1
{ \prop_gremove:Nn #1 {#2} } { \prop_remove:Nn #1 {#2} }
}
-\PrgNewFunction \PropVarCount { M } { \Expand { \prop_count:N #1 } }
+\fun at NewTwoFunctions \propVarCount \PropVarCount { M }
+ { \expWhole { \prop_count:N #1 } }
-\PrgNewFunction \PropVarItem { M m } { \Expand { \prop_item:Nn #1 {#2} } }
+\fun at NewTwoFunctions \propVarItem \PropVarItem { M m }
+ { \expWhole { \prop_item:Nn #1 {#2} } }
-\PrgNewFunction \PropToKeyval { M } { \Expand { \prop_to_keyval:N #1 } }
+\fun at NewTwoFunctions \propToKeyval \PropToKeyval { M }
+ { \expWhole { \prop_to_keyval:N #1 } }
-\PrgNewFunction \PropGet { M m M }
+\fun at NewTwoFunctions \propGet \PropGet { M m M }
{
\prop_get:NnN #1 {#2} #3
\__fun_quark_upgrade_no_value:N #3
}
-\PrgNewFunction \PropGetT { M m M n } { \prop_get:NnNT #1 {#2} #3 {#4} }
-\PrgNewFunction \PropGetF { M m M n } { \prop_get:NnNF #1 {#2} #3 {#4} }
-\PrgNewFunction \PropGetTF { M m M n n } { \prop_get:NnNTF #1 {#2} #3 {#4} {#5} }
+\fun at NewTwoFunctions \propGetT \PropGetT { M m M n }
+ { \prop_get:NnNT #1 {#2} #3 {#4} }
+\fun at NewTwoFunctions \propGetF \PropGetF { M m M n }
+ { \prop_get:NnNF #1 {#2} #3 {#4} }
+\fun at NewTwoFunctions \propGetTF \PropGetTF { M m M n n }
+ { \prop_get:NnNTF #1 {#2} #3 {#4} {#5} }
-\PrgNewFunction \PropPop { M m M }
+\fun at NewTwoFunctions \propPop \PropPop { M m M }
{
\__fun_do_assignment:Nnn #1
{ \prop_gpop:NnN #1 {#2} #3 } { \prop_pop:NnN #1 {#2} #3 }
\__fun_quark_upgrade_no_value:N #3
}
-\PrgNewFunction \PropPopT { M m M n }
+\fun at NewTwoFunctions \propPopT \PropPopT { M m M n }
{
\__fun_do_assignment:Nnn #1
{ \prop_gpop:NnNT #1 {#2} #3 {#4} } { \prop_pop:NnNT #1 {#2} #3 {#4} }
}
-\PrgNewFunction \PropPopF { M m M n }
+\fun at NewTwoFunctions \propPopF \PropPopF { M m M n }
{
\__fun_do_assignment:Nnn #1
{ \prop_gpop:NnNF #1 {#2} #3 {#4} } { \prop_pop:NnNF #1 {#2} #3 {#4} }
}
-\PrgNewFunction \PropPopTF { M m M n n }
+\fun at NewTwoFunctions \propPopTF \PropPopTF { M m M n n }
{
\__fun_do_assignment:Nnn #1
{ \prop_gpop:NnNTF #1 {#2} #3 {#4} {#5} }
@@ -2303,27 +2432,29 @@
{ \prop_pop:NnNTF #1 {#2} #3 {#4} {#5} }
}
-\PrgNewFunction \PropVarMapInline { M n }
+\fun at NewTwoFunctions \propVarMapInline \PropVarMapInline { M n }
{
\prop_map_inline:Nn #1 {#2}
}
-\cs_set_eq:NN \PropMapBreak \prop_map_break:
+\cs_set_eq:NN \propMapBreak \prop_map_break:
-\PrgNewConditional \PropIfExist { M }
+\fun at NewTwoConditionals \propIfExist \PropIfExist { M }
{
- \prop_if_exist:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \prop_if_exist:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \PropVarIfEmpty { M }
+\fun at NewTwoConditionals \propVarIfEmpty \PropVarIfEmpty { M }
{
- \prop_if_empty:NTF #1 { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \prop_if_empty:NTF #1
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \PropVarIfIn { M m }
+\fun at NewTwoConditionals \propVarIfIn \PropVarIfIn { M m }
{
\prop_if_in:NnTF #1 {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -2340,263 +2471,263 @@
\regex_new:N \l at FunTmpyRegex \regex_new:N \g at FunTmpyRegex
\regex_new:N \l at FunTmpzRegex \regex_new:N \g at FunTmpzRegex
-\PrgNewFunction \RegexNew { M } { \regex_new:N #1 }
+\fun at NewTwoFunctions \regexNew \RegexNew { M } { \regex_new:N #1 }
-\PrgNewFunction \RegexSet { M m }
+\fun at NewTwoFunctions \regexSet \RegexSet { M m }
{
\__fun_do_assignment:Nnn #1
{ \regex_gset:Nn #1 {#2} } { \regex_set:Nn #1 {#2} }
}
-\PrgNewFunction \RegexConst { M m } { \regex_const:Nn #1 {#2} }
+\fun at NewTwoFunctions \regexConst \RegexConst { M m } { \regex_const:Nn #1 {#2} }
-\PrgNewFunction \RegexLog { m } { \regex_log:n {#1} }
+\fun at NewTwoFunctions \regexLog \RegexLog { m } { \regex_log:n {#1} }
-\PrgNewFunction \RegexVarLog { M } { \regex_log:N #1 }
+\fun at NewTwoFunctions \regexVarLog \RegexVarLog { M } { \regex_log:N #1 }
-\PrgNewFunction \RegexShow { m } { \regex_show:n {#1} }
+\fun at NewTwoFunctions \regexShow \RegexShow { m } { \regex_show:n {#1} }
-\PrgNewFunction \RegexVarShow { M } { \regex_show:N #1 }
+\fun at NewTwoFunctions \regexVarShow \RegexVarShow { M } { \regex_show:N #1 }
-\PrgNewConditional \RegexMatch { m m }
+\fun at NewTwoConditionals \regexMatch \RegexMatch { m m }
{
\regex_match:nnTF {#1} {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewConditional \RegexVarMatch { M m }
+\fun at NewTwoConditionals \regexVarMatch \RegexVarMatch { M m }
{
\regex_match:NnTF #1 {#2}
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewFunction \RegexCount { m m M }
+\fun at NewTwoFunctions \regexCount \RegexCount { m m M }
{
\regex_count:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexVarCount { M m M }
+\fun at NewTwoFunctions \regexVarCount \RegexVarCount { M m M }
{
\regex_count:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexMatchCase { m m }
+\fun at NewTwoFunctions \regexMatchCase \RegexMatchCase { m m }
{
\regex_match_case:nn {#1} {#2}
}
-\PrgNewFunction \RegexMatchCaseT { m m n }
+\fun at NewTwoFunctions \regexMatchCaseT \RegexMatchCaseT { m m n }
{
\regex_match_case:nnT {#1} {#2} {#3}
}
-\PrgNewFunction \RegexMatchCaseF { m m n }
+\fun at NewTwoFunctions \regexMatchCaseF \RegexMatchCaseF { m m n }
{
\regex_match_case:nnF {#1} {#2} {#3}
}
-\PrgNewFunction \RegexMatchCaseTF { m m n n }
+\fun at NewTwoFunctions \regexMatchCaseTF \RegexMatchCaseTF { m m n n }
{
\regex_match_case:nnTF {#1} {#2} {#3} {#4}
}
-\PrgNewFunction \RegexExtractOnce { m m M }
+\fun at NewTwoFunctions \regexExtractOnce \RegexExtractOnce { m m M }
{
\regex_extract_once:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexExtractOnceT { m m M n }
+\fun at NewTwoFunctions \regexExtractOnceT \RegexExtractOnceT { m m M n }
{
\regex_extract_once:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexExtractOnceF { m m M n }
+\fun at NewTwoFunctions \regexExtractOnceF \RegexExtractOnceF { m m M n }
{
\regex_extract_once:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexExtractOnceTF { m m M n n }
+\fun at NewTwoFunctions \regexExtractOnceTF \RegexExtractOnceTF { m m M n n }
{
\regex_extract_once:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexVarExtractOnce { M m M }
+\fun at NewTwoFunctions \regexVarExtractOnce \RegexVarExtractOnce { M m M }
{
\regex_extract_once:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexVarExtractOnceT { M m M n }
+\fun at NewTwoFunctions \regexVarExtractOnceT \RegexVarExtractOnceT { M m M n }
{
\regex_extract_once:NnNT #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarExtractOnceF { M m M n }
+\fun at NewTwoFunctions \regexVarExtractOnceF \RegexVarExtractOnceF { M m M n }
{
\regex_extract_once:NnNF #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarExtractOnceTF { M m M n n }
+\fun at NewTwoFunctions \regexVarExtractOnceTF \RegexVarExtractOnceTF { M m M n n }
{
\regex_extract_once:NnNTF #1 {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexExtractAll { m m M }
+\fun at NewTwoFunctions \regexExtractAll \RegexExtractAll { m m M }
{
\regex_extract_all:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexExtractAllT { m m M n }
+\fun at NewTwoFunctions \regexExtractAllT \RegexExtractAllT { m m M n }
{
\regex_extract_all:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexExtractAllF { m m M n }
+\fun at NewTwoFunctions \regexExtractAllF \RegexExtractAllF { m m M n }
{
\regex_extract_all:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexExtractAllTF { m m M n n }
+\fun at NewTwoFunctions \regexExtractAllTF \RegexExtractAllTF { m m M n n }
{
\regex_extract_all:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexVarExtractAll { M m M }
+\fun at NewTwoFunctions \regexVarExtractAll \RegexVarExtractAll { M m M }
{
\regex_extract_all:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexVarExtractAllT { M m M n }
+\fun at NewTwoFunctions \regexVarExtractAllT \RegexVarExtractAllT { M m M n }
{
\regex_extract_all:NnNT #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarExtractAllF { M m M n }
+\fun at NewTwoFunctions \regexVarExtractAllF \RegexVarExtractAllF { M m M n }
{
\regex_extract_all:NnNF #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarExtractAllTF { M m M n n }
+\fun at NewTwoFunctions \regexVarExtractAllTF \RegexVarExtractAllTF { M m M n n }
{
\regex_extract_all:NnNTF #1 {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexSplit { m m M }
+\fun at NewTwoFunctions \regexSplit \RegexSplit { m m M }
{
\regex_split:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexSplitT { m m M n }
+\fun at NewTwoFunctions \regexSplitT \RegexSplitT { m m M n }
{
\regex_split:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexSplitF { m m M n }
+\fun at NewTwoFunctions \regexSplitF \RegexSplitF { m m M n }
{
\regex_split:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexSplitTF { m m M n n }
+\fun at NewTwoFunctions \regexSplitTF \RegexSplitTF { m m M n n }
{
\regex_split:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexVarSplit { M m M }
+\fun at NewTwoFunctions \regexVarSplit \RegexVarSplit { M m M }
{
\regex_split:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexVarSplitT { M m M n }
+\fun at NewTwoFunctions \regexVarSplitT \RegexVarSplitT { M m M n }
{
\regex_split:NnNT #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarSplitF { M m M n }
+\fun at NewTwoFunctions \regexVarSplitF \RegexVarSplitF { M m M n }
{
\regex_split:NnNF #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarSplitTF { M m M n n }
+\fun at NewTwoFunctions \regexVarSplitTF \RegexVarSplitTF { M m M n n }
{
\regex_split:NnNTF #1 {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexReplaceOnce { m m M }
+\fun at NewTwoFunctions \regexReplaceOnce \RegexReplaceOnce { m m M }
{
\regex_replace_once:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexReplaceOnceT { m m M n }
+\fun at NewTwoFunctions \regexReplaceOnceT \RegexReplaceOnceT { m m M n }
{
\regex_replace_once:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexReplaceOnceF { m m M n }
+\fun at NewTwoFunctions \regexReplaceOnceF \RegexReplaceOnceF { m m M n }
{
\regex_replace_once:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexReplaceOnceTF { m m M n n }
+\fun at NewTwoFunctions \regexReplaceOnceTF \RegexReplaceOnceTF { m m M n n }
{
\regex_replace_once:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexVarReplaceOnce { M m M }
+\fun at NewTwoFunctions \regexVarReplaceOnce \RegexVarReplaceOnce { M m M }
{
\regex_replace_once:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexVarReplaceOnceT { M m M n }
+\fun at NewTwoFunctions \regexVarReplaceOnceT \RegexVarReplaceOnceT { M m M n }
{
\regex_replace_once:NnNT #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarReplaceOnceF { M m M n }
+\fun at NewTwoFunctions \regexVarReplaceOnceF \RegexVarReplaceOnceF { M m M n }
{
\regex_replace_once:NnNF #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarReplaceOnceTF { M m M n n }
+\fun at NewTwoFunctions \regexVarReplaceOnceTF \RegexVarReplaceOnceTF { M m M n n }
{
\regex_replace_once:NnNTF #1 {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexReplaceAll { m m M }
+\fun at NewTwoFunctions \regexReplaceAll \RegexReplaceAll { m m M }
{
\regex_replace_all:nnN {#1} {#2} #3
}
-\PrgNewFunction \RegexReplaceAllT { m m M n }
+\fun at NewTwoFunctions \regexReplaceAllT \RegexReplaceAllT { m m M n }
{
\regex_replace_all:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexReplaceAllF { m m M n }
+\fun at NewTwoFunctions \regexReplaceAllF \RegexReplaceAllF { m m M n }
{
\regex_replace_all:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \RegexReplaceAllTF { m m M n n }
+\fun at NewTwoFunctions \regexReplaceAllTF \RegexReplaceAllTF { m m M n n }
{
\regex_replace_all:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexVarReplaceAll { M m M }
+\fun at NewTwoFunctions \regexVarReplaceAll \RegexVarReplaceAll { M m M }
{
\regex_replace_all:NnN #1 {#2} #3
}
-\PrgNewFunction \RegexVarReplaceAllT { M m M n }
+\fun at NewTwoFunctions \regexVarReplaceAllT \RegexVarReplaceAllT { M m M n }
{
\regex_replace_all:NnNT #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarReplaceAllF { M m M n }
+\fun at NewTwoFunctions \regexVarReplaceAllF \RegexVarReplaceAllF { M m M n }
{
\regex_replace_all:NnNF #1 {#2} #3 {#4}
}
-\PrgNewFunction \RegexVarReplaceAllTF { M m M n n }
+\fun at NewTwoFunctions \regexVarReplaceAllTF \RegexVarReplaceAllTF { M m M n n }
{
\regex_replace_all:NnNTF #1 {#2} #3 {#4} {#5}
}
-\PrgNewFunction \RegexReplaceCaseOnce { m M }
+\fun at NewTwoFunctions \regexReplaceCaseOnce \RegexReplaceCaseOnce { m M }
{
\regex_replace_case_once:nN {#1} #2
}
-\PrgNewFunction \RegexReplaceCaseOnceT { m M n }
+\fun at NewTwoFunctions \regexReplaceCaseOnceT \RegexReplaceCaseOnceT { m M n }
{
\regex_replace_case_once:nN {#1} #2 {#3}
}
-\PrgNewFunction \RegexReplaceCaseOnceF { m M n }
+\fun at NewTwoFunctions \regexReplaceCaseOnceF \RegexReplaceCaseOnceF { m M n }
{
\regex_replace_case_once:nN {#1} #2 {#3}
}
-\PrgNewFunction \RegexReplaceCaseOnceTF { m M n n }
+\fun at NewTwoFunctions \regexReplaceCaseOnceTF \RegexReplaceCaseOnceTF { m M n n }
{
\regex_replace_case_once:nN {#1} #2 {#3} {#4}
}
-\PrgNewFunction \RegexReplaceCaseAll { m M }
+\fun at NewTwoFunctions \regexReplaceCaseAll \RegexReplaceCaseAll { m M }
{
\regex_replace_case_all:nN {#1} #2
}
-\PrgNewFunction \RegexReplaceCaseAllT { m M n }
+\fun at NewTwoFunctions \regexReplaceCaseAllT \RegexReplaceCaseAllT { m M n }
{
\regex_replace_case_all:nN {#1} #2 {#3}
}
-\PrgNewFunction \RegexReplaceCaseAllF { m M n }
+\fun at NewTwoFunctions \regexReplaceCaseAllF \ { m M n }
{
\regex_replace_case_all:nN {#1} #2 {#3}
}
-\PrgNewFunction \RegexReplaceCaseAllTF { m M n n }
+\fun at NewTwoFunctions \regexReplaceCaseAllTF \RegexReplaceCaseAllTF { m M n n }
{
\regex_replace_case_all:nN {#1} #2 {#3} {#4}
}
@@ -2605,64 +2736,64 @@
%%> \section{Interfaces for Token Manipulation (Token)}
%%% --------------------------------------------------------
-\PrgNewFunction \CharLowercase { M }
+\fun at NewTwoFunctions \charLowercase \CharLowercase { M }
{
- \Expand { \char_lowercase:N #1 }
+ \expWhole { \char_lowercase:N #1 }
}
-\PrgNewFunction \CharUppercase { M }
+\fun at NewTwoFunctions \charUppercase \CharUppercase { M }
{
- \Expand { \char_uppercase:N #1 }
+ \expWhole { \char_uppercase:N #1 }
}
-\PrgNewFunction \CharTitlecase { M }
+\fun at NewTwoFunctions \charTitlecase \CharTitlecase { M }
{
- \Expand { \char_titlecase:N #1 }
+ \expWhole { \char_titlecase:N #1 }
}
-\PrgNewFunction \CharFoldcase { M }
+\fun at NewTwoFunctions \charFoldcase \CharFoldcase { M }
{
- \Expand { \char_foldcase:N #1 }
+ \expWhole { \char_foldcase:N #1 }
}
-\PrgNewFunction \CharStrLowercase { M }
+\fun at NewTwoFunctions \charStrLowercase \CharStrLowercase { M }
{
- \Expand { \char_str_lowercase:N #1 }
+ \expWhole { \char_str_lowercase:N #1 }
}
-\PrgNewFunction \CharStrUppercase { M }
+\fun at NewTwoFunctions \charStrUppercase \CharStrUppercase { M }
{
- \Expand { \char_str_uppercase:N #1 }
+ \expWhole { \char_str_uppercase:N #1 }
}
-\PrgNewFunction \CharStrTitlecase { M }
+\fun at NewTwoFunctions \charStrTitlecase \CharStrTitlecase { M }
{
- \Expand { \char_str_titlecase:N #1 }
+ \expWhole { \char_str_titlecase:N #1 }
}
-\PrgNewFunction \CharStrFoldcase { M }
+\fun at NewTwoFunctions \charStrFoldcase \CharStrFoldcase { M }
{
- \Expand { \char_str_foldcase:N #1 }
+ \expWhole { \char_str_foldcase:N #1 }
}
-\PrgNewFunction \CharSetLccode { m m }
+\fun at NewTwoFunctions \charSetLccode \CharSetLccode { m m }
{
\char_set_lccode:nn {#1} {#2}
}
-\PrgNewFunction \CharValueLccode { m }
+\fun at NewTwoFunctions \charValueLccode \CharValueLccode { m }
{
- \Expand { \char_value_lccode:n {#1} }
+ \expWhole { \char_value_lccode:n {#1} }
}
-\PrgNewFunction \CharSetUccode { m m }
+\fun at NewTwoFunctions \charSetUccode \CharSetUccode { m m }
{
\char_set_uccode:nn {#1} {#2}
}
-\PrgNewFunction \CharValueUccode { m }
+\fun at NewTwoFunctions \charValueUccode \CharValueUccode { m }
{
- \Expand { \char_value_uccode:n {#1} }
+ \expWhole { \char_value_uccode:n {#1} }
}
%%% --------------------------------------------------------
@@ -2669,49 +2800,49 @@
%%> \section{Interfaces for Text Processing (Text)}
%%% --------------------------------------------------------
-\PrgNewFunction \TextExpand { m }
+\fun at NewTwoFunctions \textExpand \TextExpand { m }
{
- \Expand { \text_expand:n {#1} }
+ \expWhole { \text_expand:n {#1} }
}
-\PrgNewFunction \TextLowercase { m }
+\fun at NewTwoFunctions \textLowercase \TextLowercase { m }
{
- \Expand { \text_lowercase:n {#1} }
+ \expWhole { \text_lowercase:n {#1} }
}
-\PrgNewFunction \TextUppercase { m }
+\fun at NewTwoFunctions \textUppercase \TextUppercase { m }
{
- \Expand { \text_uppercase:n {#1} }
+ \expWhole { \text_uppercase:n {#1} }
}
-\PrgNewFunction \TextTitlecase { m }
+\fun at NewTwoFunctions \textTitlecase \TextTitlecase { m }
{
- \Expand { \text_titlecase:n {#1} }
+ \expWhole { \text_titlecase:n {#1} }
}
-\PrgNewFunction \TextTitlecaseFirst { m }
+\fun at NewTwoFunctions \textTitlecaseFirst \TextTitlecaseFirst { m }
{
- \Expand { \text_titlecase_first:n {#1} }
+ \expWhole { \text_titlecase_first:n {#1} }
}
-\PrgNewFunction \TextLangLowercase { m m }
+\fun at NewTwoFunctions \textLangLowercase \TextLangLowercase { m m }
{
- \Expand { \text_lowercase:nn {#1} {#2} }
+ \expWhole { \text_lowercase:nn {#1} {#2} }
}
-\PrgNewFunction \TextLangUppercase { m m }
+\fun at NewTwoFunctions \textLangUppercase \TextLangUppercase { m m }
{
- \Expand { \text_uppercase:nn {#1} {#2} }
+ \expWhole { \text_uppercase:nn {#1} {#2} }
}
-\PrgNewFunction \TextLangTitlecase { m m }
+\fun at NewTwoFunctions \textLangTitlecase \TextLangTitlecase { m m }
{
- \Expand { \text_titlecase:nn {#1} {#2} }
+ \expWhole { \text_titlecase:nn {#1} {#2} }
}
-\PrgNewFunction \TextLangTitlecaseFirst { m m }
+\fun at NewTwoFunctions \textLangTitlecaseFirst \TextLangTitlecaseFirst { m m }
{
- \Expand { \text_titlecase_first:nn {#1} {#2} }
+ \expWhole { \text_titlecase_first:nn {#1} {#2} }
}
%%% --------------------------------------------------------
@@ -2720,52 +2851,53 @@
\msg_new:nnn { functional } { file-not-found } { File ~ "#1" ~ not ~ found! }
-\PrgNewFunction \FileInput { m }
+\fun at NewTwoFunctions \fileInput \FileInput { m }
{
\file_get:nnN {#1} {} \l at FunTmpxTl
\quark_if_no_value:NTF \l at FunTmpxTl
{ \msg_error:nnn { functional } { file-not-found } { #1 } }
- { \TlUse \l at FunTmpxTl }
+ { \tlUse \l at FunTmpxTl }
}
-\PrgNewFunction \FileIfExistInput { m }
+\fun at NewTwoFunctions \fileIfExistInput \FileIfExistInput { m }
{
\file_get:nnN {#1} {} \l at FunTmpxTl
- \quark_if_no_value:NF \l at FunTmpxTl { \TlUse \l at FunTmpxTl }
+ \quark_if_no_value:NF \l at FunTmpxTl { \tlUse \l at FunTmpxTl }
}
-\PrgNewFunction \FileIfExistInputF { m n }
+\fun at NewTwoFunctions \fileIfExistInputF \FileIfExistInputF { m n }
{
\file_get:nnN {#1} {} \l at FunTmpxTl
- \quark_if_no_value:NTF \l at FunTmpxTl { #2 } { \TlUse \l at FunTmpxTl }
+ \quark_if_no_value:NTF \l at FunTmpxTl { #2 } { \tlUse \l at FunTmpxTl }
}
-\cs_set_eq:NN \FileInputStop \file_input_stop:
+\cs_set_eq:NN \fileInputStop \file_input_stop:
-\PrgNewFunction \FileGet { m m M }
+\fun at NewTwoFunctions \fileGet \FileGet { m m M }
{
\file_get:nnN {#1} {#2} #3
\__fun_quark_upgrade_no_value:N #3
}
-\PrgNewFunction \FileGetT { m m M n }
+\fun at NewTwoFunctions \fileGetT \FileGetT { m m M n }
{
\file_get:nnNT {#1} {#2} #3 {#4}
}
-\PrgNewFunction \FileGetF { m m M n }
+\fun at NewTwoFunctions \fileGetF \FileGetF { m m M n }
{
\file_get:nnNF {#1} {#2} #3 {#4}
}
-\PrgNewFunction \FileGetTF { m m M n n }
+\fun at NewTwoFunctions \fileGetTF \FileGetTF { m m M n n }
{
\file_get:nnNTF {#1} {#2} #3 {#4} {#5}
}
-\PrgNewConditional \FileIfExist { m }
+\fun at NewTwoConditionals \fileIfExist \FileIfExist { m }
{
- \file_if_exist:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \file_if_exist:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -2779,10 +2911,10 @@
\quark_if_no_value:NT #1 { \tl_set_eq:NN #1 \qNoValue }
}
-\PrgNewConditional \QuarkVarIfNoValue { M }
+\fun at NewTwoConditionals \quarkVarIfNoValue \QuarkVarIfNoValue { M }
{
\tl_if_eq:NNTF \qNoValue #1
- { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
%%% --------------------------------------------------------
@@ -2789,24 +2921,25 @@
%%> \section{Interfaces to Legacy Concepts (Legacy)}
%%% --------------------------------------------------------
-\PrgNewConditional \LegacyIf { m }
+\fun at NewTwoConditionals \legacyIf \LegacyIf { m }
{
- \legacy_if:nTF {#1} { \Return { \cTrueBool } } { \Return { \cFalseBool } }
+ \legacy_if:nTF {#1}
+ { \prgReturn { \cTrueBool } } { \prgReturn { \cFalseBool } }
}
-\PrgNewFunction \LegacyIfSetTrue { m }
+\fun at NewTwoFunctions \legacyIfSetTrue \LegacyIfSetTrue { m }
{
\__fun_do_assignment:Nnn \c at name
{ \legacy_if_gset_true:n {#1} } { \legacy_if_set_true:n {#1} }
}
-\PrgNewFunction \LegacyIfSetFalse { m }
+\fun at NewTwoFunctions \legacyIfSetFalse \LegacyIfSetFalse { m }
{
\__fun_do_assignment:Nnn \c at name
{ \legacy_if_gset_false:n {#1} } { \legacy_if_set_false:n {#1} }
}
-\PrgNewFunction \LegacyIfSet { m m }
+\fun at NewTwoFunctions \legacyIfSet \LegacyIfSet { m m }
{
\__fun_do_assignment:Nnn \c at name
{ \legacy_if_gset:nn {#1} {#2} } { \legacy_if_set:nn {#1} {#2} }
More information about the tex-live-commits
mailing list.