Crthuky

I have a situation where I want to define a command that takes a variable number of arguments, where the number of arguments is known programmatically via a count, and process the parameters in some way (say as if they are a list).

As an example, say I'd like to output the parameters as a comma-separated list.

newcommandmakecsv[N]#1, #2, ..., #N

The code that I've come up with to do this kind of operation (in a generic-ish way) essentially takes a command, csv and expands it recursively N times. csv needs to know how to continue the recursion, and has some state that I'd like to thread through the recursion (rather than using global).

documentclassreport
usepackageetoolbox

makeatletter
newcommandifzero[3]%
 % #1: count
 % #2: state for #3
 % #3: macro to expand to
 % - should take at least 2 parameters
 % - ##1: count threaded through
 % - ##2: macro state threaded through
 ifnumc > 0
 deftmp@f##1##2##3##1##2##3%
 advance#1 -1%
 else
 deftmp@f##1##2##3)% note closeparen here (could be param)
 fi
 tmp@f#3#1#2%

makeatother

newcommandcsv[3]
 % #1: count
 % #2: separator state
 % #3: string to concat
 % 
 #2#3ifzero#1, csv%


newcommandmakecsv[1]%
 ifzero#1csv%


makeatletter
newcommanddecl[3]%
 % #1: decl id
 % #2: decl symbol
 % #3: # params
 csgdefdecl@#1#2%
 globalexpandafternewcountcsname decl@#1@nparamsendcsname%
 csusedecl@#1@nparams #3relax%


newcommandusedecl[1]%
 newcountc
 c thecsusedecl@#1@nparams
 csusedecl@#1(makecsvc%

makeatother

% declare some interface routines
declfooFOO3
declbarBAR4

begindocument
usedeclfoop1p2p3par
usedeclbarp1p2p3p4par
enddocument

Is this a reasonable thing to do in 2e, or is there some sort of standard approach to this that is normally used?

Edit 1

It seems like my original MWE wasn't adequate to describe why someone might want this. I've updated the MWE with a use case. decl allows authors to declaratively define a C-style function, and usedecl allows the author to generate a use of the function, with its parameters bound to specific arguments.

This is similar enough to what I'm doing that it should help motivate the example.

As commented, here a solution that uses @ifnextchar. I also implemented checks against too many or too few arguments (or why are they provided by the user?).

The @ifnextchar(or its “very internal” big brother kernel@ifnextchar) skips spaces which results in removed spaces in the third and fourth example.

Code

documentclassreport
usepackageetoolbox
makeatletter
newcommand*decl[3]%
 % #1: decl id
 % #2: decl symbol
 % #3: # params
 csdefdecl@symbol@#1#2%
 expandafternewcountcsname c@decl@params@#1endcsname
 csusec@decl@params@#1=#3relax

newcountdecl@params@check
newcommand*usedecl[1]%
 defdecl@name#1%
 edefdecl@paramsthecsusec@decl@params@#1%
 defdecl@symbolcsusedecl@symbol@#1%
 decl@params@check=z@
 letdecl@list@gobble % the @gobble removes the first , (expandable)
 defdecl@nextkernel@ifnextcharbgroupuse@decluse@decl@finish%
 decl@next

newcommand*use@decl[1]%
 advancedecl@params@check@ne
 expandafterifnumthedecl@params@check>decl@paramsrelax % too many!
 PackageWarningdeclYou have used more params than the decl@namespace function expected!
 I ignore this (and any following) param, ok?% but insert the extra argument anyway?!
 defdecl@nextuse@decl@finish#1% the extra pair of braces keeps '#1' local as it is in the input stream
 else
 expandafterdefexpandafterdecl@listexpandafterdecl@listdecl@list@sep#1%
 fi
 decl@next

newififuse@decl@message
newcommand*use@decl@finish%
 ifnumdecl@params@check<decl@paramsrelax % too few!
 expandafter@firstoftwo
 else
 expandafter@secondoftwo
 fi
 %
 ifuse@decl@messageelse
 PackageWarningdeclYou have used fewer params than the decl@namespace function expected! I'm filling up with '??'!%
 use@decl@messagetrue
 fi
 use@decl??
 %
 decl@symboldecl@list@startdecl@listdecl@list@end
 use@decl@messagefalse
 %

newcommand*setdeclstart[1]defdecl@list@start#1
newcommand*setdeclend[1]defdecl@list@end#1
newcommand*setdeclsep[1]defdecl@list@sep#1
makeatother

setdeclstart(
setdeclend)
setdeclsep, 

% declare some interface routines
declfooFOO3
declbarBAR4

begindocument
given $P$, $Q$ and $R$ such dots that $usedeclfooPQR$ results in dotspar
given P, Q and R such dots that usedeclfooPQR results in dotspar
usedeclfoop1p2p3par
usedeclbarp1p2p3p4par
usedeclbarp1 foopar
usedeclfoop1p2p3 p4par
enddocument

Output

If you're willing to peek ahead, you can check whether there's "another argument" and keep gobbling them on the fly:

documentclassarticle
usepackageetoolbox% http://ctan.org/pkg/etoolbox

makeatletter
newcommandnewdecl[2]csgdefdecl@#1#2% Creates a declaration
newcommandcsvdel% Delimiter used in CSV representation
newcommandnewusedecl[2][,]% Use a declaration
 renewcommandcsvdelrenewcommandcsvdel#1,% Delay csvdel one cycle.
 csname decl@#2endcsname(checknextarg
newcommandchecknextarg@ifnextcharbgroupgobblenext% Check if another "argument" exists
newcommandgobblenext[1]csvdel#1@ifnextcharbgroupgobblenext)% Gobble next "argument"
makeatother

% declare some interface routines
newdeclfooFOO
newdeclbarBAR

begindocument

newusedeclfoop1p2p3par
newusedeclbarp1p2p3p4p1p2p3p4p1p2p3p4p1p2p3p4
 p1p2p3p4par
newusedecl[;]foop1p2p3p4p1p2p3p4p1p2p3p4p1p2p3p4
 p1p2p3p4

enddocument

The peeking is done using @ifnextchar. For some explanation around this, see Understanding @ifnextchar. The delayed use of csvdel (the CSV delimiter) stems from Cunning (La)TeX tricks).

The optional argument to newusedecl adapts csvdel.

You've not given us much to go off of, but here's something that seems to implement what you want while being fed a comma separated list (in lieu of passing a variable number of arguments).

documentclassarticle
usepackagexparse
newcountermyargcounter
ExplSyntaxOn
clist_new:N l_myvararg_parameters_clist
tl_new:N l_myvararg_current_item_tl
NewDocumentCommandmakecsv m 
 
 clist_set:Nn l_myvararg_parameters_clist #1 
 int_while_do:nNnn clist_count:N l_myvararg_parameters_clist > 1 
 
 clist_pop:NN l_myvararg_parameters_clist l_myvararg_current_item_tl
 tl_use:N l_myvararg_current_item_tl,
 
 clist_pop:NN l_myvararg_parameters_clist
 l_myvararg_current_item_tl
 ~ and ~ tl_use:N l_myvararg_current_item_tl
 
ExplSyntaxOff
pagestyleempty
begindocument
makecsva,b,c,d

makecsva,b,c,d,e,f,g

makecsva,b

enddocument

Here is an expansion-based implementation where the loop for gathering the parameters is based on romannumeral both for triggering expansion and for keeping track of the amount of parameters that still is to be collected.

The usedecl-mechanism does without using any count-registers and without whatsoever temporary assignments for carrying out the loop. e-TeX-extensions and whatsoever fancy packages are not needed. ;-)

Due to romannumeral-expansion usedecl delivers the result after two expansion-steps/after being hit by expandafter twice.

documentclassreport

makeatletter
%%----------------------------------------------------------------------
%% Form control sequence token from sequence of characters denoting its
%% name:
%% UD@name foobar -> foobar
%% , e.g.,
%% UD@namenewcommand*foo -> newcommand*foo
%% UD@namestringfoo -> stringfoo
%% UD@nameUD@nameletfoo=bar -> UD@nameletfoo=bar -> letfoo=bar
%% UD@namefoo -> foo
%%......................................................................
@ifdefinableUD@name%
 longdefUD@name#1#romannumeral0UD@innername#1%
%
newcommandUD@innername[2]%
 expandafterUD@exchangeexpandaftercsname#2endcsname #1%
%
newcommandUD@exchange[2]#2#1%
%%----------------------------------------------------------------------
%% Check whether argument is empty:
%%......................................................................
%% UD@CheckWhetherNull<Argument which is to be checked>%
%% <Tokens to be delivered in case that argument
%% which is to be checked is empty>%
%% <Tokens to be delivered in case that argument
%% which is to be checked is not empty>%
%% The gist of this macro comes from Robert R. Schneck's ifempty-macro:
%% <https://groups.google.com/forum/#!original/comp.text.tex/kuOEIQIrElc/lUg37FmhA74J>
newcommandUD@CheckWhetherNull[1]%
 romannumeral0expandafter@secondoftwostringexpandafter
 @secondoftwoexpandafterexpandafterstring#1expandafter
 @secondoftwostringexpandafter@firstoftwoexpandafterexpandafter
 @secondoftwostringexpandafterexpandafter@firstoftwo %
 @secondoftwoexpandafterexpandafter@firstoftwo @firstoftwo%
%
%%----------------------------------------------------------------------
%% Associate IDs with amounts of parameters and symbols:
%% No count-registers get allocated/get wasted. Just macros get defined.
%%......................................................................
newcommanddecl[3]%
 % #1: decl id; #2: decl symbol; #3: # params
 UD@namenewcommand*decl@#1#2%
 UD@namenewcommand*decl@#1@nparams#3%
%
%%----------------------------------------------------------------------
%% usedecl<decl id><list of parameters of length decl@<decl id>@nparams>
%%
%% creates comma list from parameters, nested in parentheses and
%% lead by the tokens that come from expanding decl@<decl id>
%%
%% Due to romannumeral-expansion the result is delivered after two
%% expansion-steps/after "hitting" usedecl by expandafter twice.
%%......................................................................
newcommandusedecl[1]%
 romannumeral0%
 expandafterUD@exchange
 expandafter%
 expandafter%
 romannumeral0%
 UD@exchange UD@nameexpandafterdecl@#1%
 %
 %
 expandafterusedeclloop
 expandafter%
 romannumeralUD@namenumbernumberdecl@#1@nparams 000 %
 %
 %
%
newcommandusedeclloop[4]%
 %#1 amount of m = amount of parameters to collect
 %#2 decl symbol
 %#3 prepend-tokens
 %#4 parameters collected so far
 UD@CheckWhetherNull#1 #2(#4)%
 expandafterusedeclloopatfetchexpandafter@gobble#1#2, #4#3%
 %
%
newcommandusedeclloopatfetch[5]%
 %#1 amount of m = amount of parameters to collect
 %#2 decl symbol
 %#3 prepend tokens
 %#4 parameters collected so far
 %#5 next parameter fetched.
 usedeclloop#1#2#3#4#5%
%
newcommandwithoutdecl[2]%
 romannumeral0%
 expandafterusedeclloopexpandafterromannumeralnumbernumber#2 000 #1%
 %
%

makeatother

% declare the symbols and the amounts of parameters:
declfooFOO3
declbarBAR4

begindocument

usedeclfoop1p2p3par
usedeclbarp1p2p3p4par
withoutdeclBAZ5p1p2p3p4p5par

expandafterexpandafterexpandafterdef
expandafterexpandafterexpandafterfoolist
expandafterexpandafterexpandafter%
 usedeclfoop1p2p3%
%

expandafterexpandafterexpandafterdef
expandafterexpandafterexpandafterbarlist
expandafterexpandafterexpandafter%
 usedeclbarp1p2p3p4%
%

expandafterexpandafterexpandafterdef
expandafterexpandafterexpandafterbazlist
expandafterexpandafterexpandafter%
 withoutdeclBAZ5p1p2p3p4p5%
%

texttt

texttt

texttt

enddocument