Mrthfx

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.

newcommand{makecsv}[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).

documentclass{report}

usepackage{etoolbox}



makeatletter

newcommand{ifzero}[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



newcommand{csv}[3]{

  % #1: count

  % #2: separator state

  % #3: string to concat

  % 

  #2#3ifzero{#1}{, }{csv}%

}



newcommand{makecsv}[1]{%

  ifzero{#1}{}{csv}%

}



makeatletter

newcommand{decl}[3]{%

  % #1: decl id

  % #2: decl symbol

  % #3: # params

  csgdef{decl@#1}{#2}%

  globalexpandafternewcountcsname decl@#1@nparamsendcsname%

  csuse{decl@#1@nparams} #3relax%

}



newcommand{usedecl}[1]{%

  newcountc

  c thecsuse{decl@#1@nparams}

  csuse{decl@#1}(makecsv{c}%

}

makeatother



% declare some interface routines

decl{foo}{FOO}{3}

decl{bar}{BAR}{4}



begin{document}

usedecl{foo}{p1}{p2}{p3}par

usedecl{bar}{p1}{p2}{p3}{p4}par

end{document}

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

documentclass{report}

usepackage{etoolbox}

makeatletter

newcommand*{decl}[3]{%

  % #1: decl id

  % #2: decl symbol

  % #3: # params

  csdef{decl@symbol@#1}{#2}%

  expandafternewcountcsname c@decl@params@#1endcsname

  csuse{c@decl@params@#1}=#3relax

}

newcountdecl@params@check

newcommand*{usedecl}[1]{%

  defdecl@name{#1}%

  edefdecl@params{thecsuse{c@decl@params@#1}}%

  defdecl@symbol{csuse{decl@symbol@#1}}%

  decl@params@check=z@

  letdecl@list@gobble % the @gobble removes the first , (expandable)

  defdecl@next{kernel@ifnextcharbgroupuse@decluse@decl@finish}%

  decl@next

}

newcommand*{use@decl}[1]{%

  advancedecl@params@check@ne

  expandafterifnumthedecl@params@check>decl@paramsrelax % too many!

    PackageWarning{decl}{You 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@next{use@decl@finish{#1}}% the extra pair of braces {} keeps '#1' local as it is in the input stream

  else

    expandafterdefexpandafterdecl@listexpandafter{decl@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

      PackageWarning{decl}{You 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

decl{foo}{FOO}{3}

decl{bar}{BAR}{4}



begin{document}

given $P$, $Q$ and $R$ such dots that $usedecl{foo}{P}{Q}{R}$ results in dotspar

given P, Q and R such dots that usedecl{foo}{P}{Q}{R} results in dotspar

usedecl{foo}{p1}{p2}{p3}par

usedecl{bar}{p1}{p2}{p3}{p4}par

usedecl{bar}{p1} foopar

usedecl{foo}{p1}{p2}{p3} {p4}par

end{document}

Output

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

documentclass{article}

usepackage{etoolbox}% http://ctan.org/pkg/etoolbox



makeatletter

newcommand{newdecl}[2]{csgdef{decl@#1}{#2}}% Creates a declaration

newcommand{csvdel}{}% Delimiter used in CSV representation

newcommand{newusedecl}[2][,]{% Use a declaration

  renewcommand{csvdel}{renewcommand{csvdel}{#1,}}% Delay csvdel one cycle.

  csname decl@#2endcsname(checknextarg}

newcommand{checknextarg}{@ifnextcharbgroup{gobblenext}{}}% Check if another "argument" exists

newcommand{gobblenext}[1]{csvdel#1@ifnextcharbgroup{gobblenext}{)}}% Gobble next "argument"

makeatother



% declare some interface routines

newdecl{foo}{FOO}

newdecl{bar}{BAR}



begin{document}



newusedecl{foo}{p1}{p2}{p3}par

newusedecl{bar}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}

  {p1}{p2}{p3}{p4}par

newusedecl[;]{foo}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}{p1}{p2}{p3}{p4}

  {p1}{p2}{p3}{p4}



end{document}

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).

documentclass{article}

usepackage{xparse}

newcounter{myargcounter}

ExplSyntaxOn

clist_new:N l_myvararg_parameters_clist

tl_new:N    l_myvararg_current_item_tl

NewDocumentCommand{makecsv}{ 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

pagestyle{empty}

begin{document}

makecsv{a,b,c,d}



makecsv{a,b,c,d,e,f,g}



makecsv{a,b}



end{document}

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.

documentclass{report}



makeatletter

%%----------------------------------------------------------------------

%% Form control sequence token from sequence of characters denoting its

%% name:

%% UD@name foo{bar} -> foobar

%%   , e.g.,

%% UD@namenewcommand*{foo} -> newcommand*foo

%% UD@namestring{foo} -> stringfoo

%% UD@nameUD@namelet{foo}={bar} -> UD@nameletfoo={bar} -> letfoo=bar

%% UD@name{foo} -> foo

%%......................................................................

@ifdefinableUD@name{%

  longdefUD@name#1#{romannumeral0UD@innername{#1}}%

}%

newcommandUD@innername[2]{%

  expandafterUD@exchangeexpandafter{csname#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@secondoftwostring{expandafter

  @secondoftwoexpandafter{expandafter{string#1}expandafter

  @secondoftwostring}expandafter@firstoftwoexpandafter{expandafter

  @secondoftwostring}expandafterexpandafter@firstoftwo{ }{}%

  @secondoftwo}{expandafterexpandafter@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@nameexpandafter}{decl@#1}%

    }{}{}%

  }{%

    expandafterusedeclloop

    expandafter{%

      romannumeralUD@namenumbernumber{decl@#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%

  expandafterusedeclloopexpandafter{romannumeralnumbernumber#2 000 }{#1}%

  {}{}%

}%



makeatother



% declare the symbols and the amounts of parameters:

decl{foo}{FOO}{3}

decl{bar}{BAR}{4}



begin{document}



usedecl{foo}{p1}{p2}{p3}par

usedecl{bar}{p1}{p2}{p3}{p4}par

withoutdecl{BAZ}{5}{p1}{p2}{p3}{p4}{p5}par



expandafterexpandafterexpandafterdef

expandafterexpandafterexpandafterfoolist

expandafterexpandafterexpandafter{%

  usedecl{foo}{p1}{p2}{p3}%

}%



expandafterexpandafterexpandafterdef

expandafterexpandafterexpandafterbarlist

expandafterexpandafterexpandafter{%

  usedecl{bar}{p1}{p2}{p3}{p4}%

}%



expandafterexpandafterexpandafterdef

expandafterexpandafterexpandafterbazlist

expandafterexpandafterexpandafter{%

  withoutdecl{BAZ}{5}{p1}{p2}{p3}{p4}{p5}%

}%



texttt{|frenchspacingstringfoolist=meaningfoolist|}



texttt{|frenchspacingstringbarlist=meaningbarlist|}



texttt{|frenchspacingstringbazlist=meaningbazlist|}



end{document}