Indefinite Number of Arguments?

Question

How do I pass an in(de)finite number of arguments?

I would like a command of the type:

\coollist{a}{b}{c}{d}{e}{f}... {y}{z}.

More specifically, I need a command \lexinfinite that would allow me to pass an indefinite number of items of the type {a,b,c}, corresponding to lexemes in a list, inside text (a being the italicized word, b the subscripted grammatical category, and c the translation):

\lexinfinite{a,b,c}{a',b',c'}{...}

MWE

\documentclass{article}

\usepackage{xspace}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lex}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\newcommand{\lexduo}[2]{\lex{#1}\space and\space\lex{#2}}
\newcommand{\lextrio}[3]{\lex{#1},\space\lex{#2}\space and\space\lex{#3}}

\begin{document}
    
    \lex{tree,n,arbre}, \lex{apple,n,pomme} and \lex{stuff,n,thing}
    
    \lexduo{tree,n,arbre}{apple,n,pomme}
    
    \lextrio{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}
    
\end{document}

Answer 1

I don’t understand the purpose of it, but is this what you want?

\documentclass{article}

\usepackage{xspace,xparse}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lexTRIPLE}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\DeclareDocumentCommand\lexEXTRA{g}{%
    \IfValueT{#1}{%
        ,\space\lexTRIPLE{#1}\lexEXTRA
    }%
}

\DeclareDocumentCommand\lex{m}{%
    \lexTRIPLE{#1}%
    \lexEXTRA
}

\begin{document}
    
    \lex{tree,n,arbre}, \lex{apple,n,pomme} and \lex{stuff,n,thing}
    
    \lex{tree,n,arbre}{apple,n,pomme}
    
    \lex{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}
    
\end{document}

---

A slightly less concise version which adds “and”:

\documentclass{article}

\usepackage{xspace,xparse}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lexTRIPLE}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\DeclareDocumentCommand\lexEXTRA{mg}{%
    \IfValueTF{#2}{%
        ,\space\lexTRIPLE{#1}\lexEXTRA{#2}%
    }{%
        \space and\space\lexTRIPLE{#1}%
    }%
}

\DeclareDocumentCommand\lex{mg}{%
    \lexTRIPLE{#1}%
    \IfValueT{#2}{%
        \lexEXTRA{#2}%
    }%
}

\begin{document}
    
    \lex{tree,n,arbre}, \lex{apple,n,pomme} and \lex{stuff,n,thing}
    
    \lex{tree,n,arbre}{apple,n,pomme}
    
    \lex{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}
    
\end{document}

Answer 2

You can define your macros using TeX primitives and elementary macros:

\documentclass{article}

\newcount\lexcount
\def\lexi#1,#2,#3,#4^{{\it #1}\if^#2^\else\uppercase{$_{\rm #2}$}\if^#3^\else~`#3'\fi\fi}
\def\lexinf {\lexcount=0 \def\lexinfS{}\futurelet\next\lexinfA}
\def\lexinfA {\ifx\next\bgroup \expandafter\lexinfB \else \expandafter\lexinfS \fi}
\def\lexinfB #1{\advance\lexcount by1 \addto\lexinfS{\lexinfC{#1}}\futurelet\next\lexinfA}
\def\lexinfC#1{\lexi #1,,,^\advance\lexcount by-1 \ifcase\lexcount \or \ and \else , \fi}
\long\def\addto#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}}

\begin{document}
    
    \lexinf{tree,n,arbre}

    \lexinf{tree,n,arbre}{apple,n,pomme}

    \lexinf{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}

    \lexinf{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}{last,x,uff}

\end{document}

Answer 3

Do you mean something like this? Or do you need somehow to incorporate the ellipsis (...) into the input/output?

\documentclass{article}
\usepackage{listofitems}
\newcommand\coolitlist[1]{%
  \readlist*\mylist{#1}%
  \foreachitem\z\in\mylist[]{%
    $\z$%
    \ifnum\zcnt<\listlen\mylist[]\relax, \fi
    \ifnum\zcnt=\numexpr\listlen\mylist[]-1\relax and \fi
  }%
}
\begin{document}
\coolitlist{a, b, c}

\coolitlist{a,b,c,d,e,f}
\end{document}

ADDENDUM

Perhaps this addition of \lexlist addresses the OP's comment for a list of \lex commands.

\documentclass{article}
\usepackage{listofitems,xspace}
\newcommand\coolitlist[1]{%
  \readlist*\mylist{#1}%
  \foreachitem\z\in\mylist[]{%
    $\z$%
    \ifnum\zcnt<\listlen\mylist[]\relax, \fi
    \ifnum\zcnt=\numexpr\listlen\mylist[]-1\relax and \fi
  }%
}
\newcommand\lexlist[1]{%
  \readlist*\mylist{#1}%
  \foreachitem\z\in\mylist[]{%
    \expandafter\lex\expandafter{\z}%
    \ifnum\zcnt<\listlen\mylist[]\relax, \fi
    \ifnum\zcnt=\numexpr\listlen\mylist[]-1\relax and \fi
  }%
}
\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lex}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\begin{document}
\coolitlist{a, b, c}

\coolitlist{a,b,c,d,e,f}

\lex{house,n,maison}

\lexlist{{house,n,maison},{arbre,n,tree},{stuff,n,thing}}
\end{document}

SECONDARY ANSWER

Per OP's request, this will have \lexlist absorb as many groups as are presented, so that groups need not be grouped, as in prior answer:

\documentclass{article}
\usepackage{listofitems,xspace}
\newtoks\lextoks
\ignoreemptyitems
\newcommand\coolitlist[1]{%
  \readlist*\mylist{#1}%
  \foreachitem\z\in\mylist[]{%
    $\z$%
    \ifnum\zcnt<\listlen\mylist[]\relax, \fi
    \ifnum\zcnt=\numexpr\listlen\mylist[]-1\relax and \fi
  }%
}
\newcommand\lexlist{\lextoks{}\lexlistA}
\newcommand\lexlistA{\futurelet\nexttok\lexlistB}
\newcommand\lexlistB{\ifx\nexttok\bgroup\expandafter\lexlistC
  \else\expandafter\lexlistD\expandafter{\the\lextoks}\fi}
\newcommand\lexlistC[1]{\lextoks\expandafter{\the\lextoks{#1},}%
  \lexlistA}
\newcommand\lexlistD[1]{%
  \readlist*\mylist{#1}%
  \foreachitem\z\in\mylist[]{%
    \expandafter\lex\expandafter{\z}%
    \ifnum\zcnt<\listlen\mylist[]\relax, \fi
    \ifnum\zcnt=\numexpr\listlen\mylist[]-1\relax and \fi
  }%
}
\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lex}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\begin{document}
\coolitlist{a, b, c}

\coolitlist{a,b,c,d,e,f}

\lex{house,n,maison}

\lexlist{house,n,maison}{arbre,n,tree}{stuff,n,thing} or else
  plain text
\end{document}

Answer 4

Further answer

The comments under “New answer” apply the same.

\documentclass{article}

\NewDocumentCommand{\lexeme}{>{\SplitArgument{2}{,}}m}{%
  \dolexeme#1%
}
\NewDocumentCommand{\dolexeme}{mmm}{%
  \textit{#1}%
  \IfValueT{#2}{\textsubscript{#2}}%
  \IfValueT{#3}{ (#3)}%
}

\ExplSyntaxOn

\NewDocumentCommand{\lex}{m}
 {
  \krebs_lex_listoflexemes:n { #1 }
 }

\seq_new:N \l__krebs_lex_in_seq
\seq_new:N \l__krebs_lex_out_seq

\cs_new_protected:Nn \krebs_lex_listoflexemes:n
 {
  \seq_set_split:Nnn \l__krebs_lex_in_seq { ; } { #1 }
  \seq_set_map:NNn \l__krebs_lex_out_seq \l__krebs_lex_in_seq { \lexeme{##1} }
  \seq_use:Nnnn \l__krebs_lex_out_seq { ~and~ } { ,~ } { ~and~ }
 }

\ExplSyntaxOff

\begin{document}

\lex{
  tree,n,arbre;
  apple,n,pomme;
  stuff,n,chose;
  invasion,n,invasion;
  ascension,n,ascension;
  last,a,dernier;
  x;
  y,q
}

\end{document}

New answer

This seems like an XYZ-problem: I want to do X with the Y method, but I present Z.

First and foremost: you gain nothing with an indefinite number of arguments, because the syntax is obscure and error prone.

Judging from your edited question, you want to loop over a set of comma separated lists, doing something (unspecified) to these lists.

My proposal is to have a clearer syntax that helps in confining the data and avoids “going on forever”.

\documentclass{article}

\ExplSyntaxOn

\NewDocumentCommand{\lex}{m}
 {
  \tl_map_function:nN { #1 } \krebs_cool_whatever:n
 }

\cs_new_protected:Nn \krebs_cool_whatever:n
 {
  !!\clist_use:nnnn { #1 } { ~and~ } { ,~ } { ~and~ }!! \par
 }

\ExplSyntaxOff

\begin{document}

\lex{
  {tree,n,arbre}
  {apple,n,pomme}
  {stuff,n,chose}
  {invasion,n,invasion}
  {ascension,n,ascension}
  {last,a,dernier}
}

\end{document}

Waiting for a further edit to fill in what you mean to do with the lists.

Original answer

Reading minds is not easy…

Based on your comment I defined a dummy \lex command that takes a comma separated list, just to show that it works with no problem.

The idea is to exploit \seq_use:Nnnn, where the n arguments specify, respectively, the separator between only two items, the separator between several items and the separator between the last two items (if more than two).

The input is transformed into a sequence, another one is built by wrapping the items with \textit and the result is passed to \seq_use:Nnnn.

\documentclass{article}

\ExplSyntaxOn

\NewDocumentCommand{\lex}{m}
 {
  \clist_map_inline:nn { #1 } { \fbox{##1} }
 }

\NewDocumentCommand{\coolitlist}{m}
 {
  \krebs_cool_itlist:n { #1 }
 }

\seq_new:N \l__krebs_cool_itlist_in_seq
\seq_new:N \l__krebs_cool_itlist_out_seq

\cs_new_protected:Nn \krebs_cool_itlist:n
 {
  \seq_set_from_clist:Nn \l__krebs_cool_itlist_in_seq { #1 }
  \seq_set_map:NNn \l__krebs_cool_itlist_out_seq \l__krebs_cool_itlist_in_seq { \textit { ##1 } }
  \seq_use:Nnnn \l__krebs_cool_itlist_out_seq { ~and~ } { ,~ } { ~and~ }
 }

\ExplSyntaxOff

\begin{document}

\coolitlist{a}

\coolitlist{a,b}

\coolitlist{a,b,c}

\coolitlist{a,b,\lex{c,cc,ccc},d}

\end{document}

No counter, no arithmetic.

Answer 5

You can use the pgffor package (which is loaded by tikz) to take advantage of the ... syntax.

\documentclass{article}

\usepackage{pgffor, ifthen}

\newcommand{\coolitlist}[1]{\foreach\W[count=\n]in{#1}{\xdef\nnn{\n}}%
    \foreach\W[count=\n, evaluate=\n as \m using int(\n+1)]in{#1}
        {\ifthenelse{\n=\nnn}{ and \W}{\ifthenelse{\m=\nnn}{\W}{\W,\ }}}}

\begin{document}

I like \coolitlist{a,b,...,g}.

I like \coolitlist{10,9,...,2}.

I like \coolitlist{{blue},{green},{yellow}}.

\end{document}

Answer 6

If I understand correctly, this is what you want

\documentclass{article}

\ExplSyntaxOn 

\seq_new:N \l__krebs_cool_itlist_a_seq
\seq_new:N \l__krebs_cool_itlist_b_seq

\NewDocumentCommand \coolitlist { m } {%
    \seq_set_from_clist:Nn \l__krebs_cool_itlist_a_seq { #1 }
    \krebs_cool_itlist:
}

\cs_new:Nn \krebs_cool_itlist_concat:n
{
    \seq_set_from_clist:Nn \l__krebs_cool_itlist_b_seq { #1 }
    \seq_concat:NNN \l__krebs_cool_itlist_a_seq \l__krebs_cool_itlist_a_seq \l__krebs_cool_itlist_b_seq
    \krebs_cool_itlist:
    
}

\cs_new_protected:Nn \krebs_cool_itlist:
{
    \peek_meaning:NTF \c_group_begin_token 
        { 
            \krebs_cool_itlist_concat:n
        } 
        { 
            \seq_set_map:NNn \l__krebs_cool_itlist_b_seq \l__krebs_cool_itlist_a_seq { \textit { ##1 } }
            \seq_use:Nnnn \l__krebs_cool_itlist_b_seq { ~and~ } { ,~ } { ~and~ } 
        } 
}

\ExplSyntaxOff
\begin{document}
    
    \coolitlist{a,b,c,d,e,f,g,h,i,j}
    
    \coolitlist{a,b,c,d,e,f,g,h,i,j}{k,l,m,n,o,p}
    
    \coolitlist{a,b,c,d,e,f,g,h,i,j}{k,l,m,n,o,p}{q,r,s,t,u,v}
    
    \coolitlist{a,b,c,d,e,f,g,h,i,j}{k,l,m,n,o,p}{q,r,s,t,u,v}{w,x,y,z} 
    
    Resault with \verb|\bgroup|
    
    \coolitlist{a,b,c,d,e,f,g,h,i,j}\bgroup k,l,m,n,o,p\egroup
    
\end{document}

It is based on egreg's answer. The way it works is that the function will peek after the first argument to see if it is an open group character (beware that an implicit one is also valid, but e.g \bgroup would probably give unwanted results. Also spaces are not skipped), if so, it will concatenate the content of the next argument to the first argument and peek ahead again, if not it will do the same as \krebs_cool_itlist:n from egreg's answer.

Maybe it will be wise to append \relax after a call of \coolitlist, e.g. \coolitlist{a,b}{c}\relax

Answer 7

This is in the spirit of Gaussler's answer which makes use of xparse's (deprecated) g-type-argument, but it does not require at least one brace-nested lexem-triple to be present.

\documentclass{article}

\usepackage{xspace,xparse}

\newcommand{\tslt}[1]{\unskip\xspace`#1'}

\NewDocumentCommand{\lexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}

\NewDocumentCommand{\lexTRIPLE}{>{\SplitArgument{2}{,}}m}{\lexAUX#1}

\makeatletter
\DeclareDocumentCommand\lexloop{mmg}{%
  \IfValueTF{#3}{\@firstoftwo#1\lexloop{#2\lexTRIPLE{#3}}{{, }{ and }}}%
                {\@secondoftwo#1}%
}%
\makeatother
\DeclareDocumentCommand\lex{}{\lexloop{{}{}}{{}{}}}%

\begin{document}

    \lex{tree,n,arbre}, \lex{apple,n,pomme} and \lex{stuff,n,thing}

    \lex{tree,n,arbre}{apple,n,pomme}

    \lex{tree,n,arbre}{apple,n,pomme}{stuff,n,thing}

    \lex{tree,n,arbre}

    noth\lex ing

\end{document}

Answer 8

I am very grateful to you everyone for your many interesting proposals.

I write down all the coding possibilities; I am learning a lot thanks to you.

Here is a MWE illustrating the solutions that I retain.

\documentclass{article}
\usepackage{listofitems,xspace,fontspec}
\usepackage[lmargin=2.5cm,rmargin=2.5cm,bmargin=2.5cm,tmargin=3.5cm]{geometry}
\setmainfont{Times New Roman}

%%%%%%% Common Code %%%%%%%
\NewDocumentCommand{\oldlexAUX}{mmm}{\textit{#1}\IfNoValueF{#2}{\textup{\textsubscript{\textsc{#2}}}}\IfNoValueF{#3}{\tslt{#3}}}
\NewDocumentCommand{\oldlex}{>{\SplitArgument{2}{,}}m}{\oldlexAUX#1}
\newcommand{\tslt}[1]{\unskip\xspace`#1'}
%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%% Gaussler's g-type Method %%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\DeclareDocumentCommand\lexEXTRA{mg}{%
    \IfValueTF{#2}{%
        ,\space\oldlex{#1}\lexEXTRA{#2}%
    }{%
        \space and\space\oldlex{#1}%
    }%
}

\DeclareDocumentCommand\gausslex{mg}{%
    \oldlex{#1}%
    \IfValueT{#2}{%
        \lexEXTRA{#2}%
    }%
}




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% Wipet/Steven Method %%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\newtoks\lextoks
\ignoreemptyitems

\newcommand{\lexeme}{\expandafter\oldlex\expandafter{\z}}

\newcommand\lex{\lextoks{}\lexA}
\newcommand\lexA{\futurelet\nexttok\lexB}
\newcommand\lexB{\ifx\nexttok\bgroup\expandafter\lexC
    \else\expandafter\lexD\expandafter{\the\lextoks}\fi}
\newcommand\lexC[1]{\lextoks\expandafter{\the\lextoks{#1},}%
    \lexA}

\newcommand\lexD[1]{%
    \readlist*\mylist{#1}%
    \foreachitem\z\in\mylist[]{%
        \ifnum\zcnt=1\lexeme
        \else
            \ifnum\zcnt<\listlen\mylist[]\unskip,\space\lexeme
            \else\space and \lexeme
            \fi
        \fi
    }%
}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%% Enrico's Semi-Colon Variant of \lex %%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\NewDocumentCommand{\dolex}{>{\SplitArgument{2}{,}}m}{%
    \coolexAUX#1%
}
\NewDocumentCommand{\coolexAUX}{mmm}{%
    \textit{#1}%
    \IfValueT{#2}{\textup{\textsubscript{\textsc{#2}}}}%
    \IfValueT{#3}{\tslt{#3}}%
}

\ExplSyntaxOn

\NewDocumentCommand{\coolex}{m}
{
    \krebs_lex_listoflexemes:n { #1 }
}

\seq_new:N \l__krebs_lex_in_seq
\seq_new:N \l__krebs_lex_out_seq

\cs_new_protected:Nn \krebs_lex_listoflexemes:n
{
    \seq_set_split:Nnn \l__krebs_lex_in_seq { ; } { #1 }
    \seq_set_map:NNn \l__krebs_lex_out_seq \l__krebs_lex_in_seq { \dolex{##1} }
    \seq_use:Nnnn \l__krebs_lex_out_seq { ~and~ } { ,~ } { ~and~ }
}

\ExplSyntaxOff

\begin{document}

I would like to mention several words, namely \gausslex{invasion,n,invasion}{great,a,génial}{avec,p,with}{eat,v}{word-with-no-category}! \textrightarrow{} This is \textit{Gaussler}'s very economic method for infinite brace-delimited arguments.

\vspace{2ex}
    
I would like to mention several words, namely \lex{invasion,n,invasion}{great,a,génial}{avec,p,with}{eat,v}{word-with-no-category}! \textrightarrow{} This is \textit{wipet} and \textit{Steven}'s solution, using  \TeX{} primitives and delimiting arguments with \textbf{braces}.

\vspace{2ex}

I would like to mention several words, namely \coolex{invasion,n,invasion;great,a,génial;avec,p,with;eat,v;word-with-no-category}! \textrightarrow{} This is \textit{egreg}'s solution, using \textit{Expl3} syntax and delimiting arguments with \textbf{semicolons}.
    
\end{document}