Bdtyktl

So I'm trying to implement a COOL-style Sum macro which is supposed to support the following syntax:

Sum{ldots}  % -> sum ldots

Sum[i]{ldots}  % -> sum_{i} ldots

Sum[i in I]{ldots}  % -> sum_{i in I} ldots

Sum[i, 0, N]{ldots}  % -> sum_{i=0}^{N} ldots

Sum[{i,j}, 0, N]{ldots}  % -> sum_{i,j=0}^{N} ldots

Sum[{i,j,k}]{ldots}  % -> sum_{i,j,k} ldots

The important bit is that I would like braces to protect commas in the first argument. The actual implementation is in expl3 with the user interface using xparse. Unfortunately, xparse appears to always strip braces inside arguments if they surround the whole argument such that this protection will not work in all cases, no matter what my internal code does. Looking at the docs, I couldn't find a way to prevent this.

I tried macros signatures of the forms

DeclareDocumentCommand Sum { s >{ SplitArgument{2}{,} } o m }

  { ... }

DeclareDocumentCommand Sum { s o m }

  { ... }

Am I missing something here, is there a (undocumented) way to make xparse not strip such braces short of circumventing xparse and implementing the interface manually (maybe using argument processors?)? If not, would this warrant a bug report/feature request at the latex github?

You can trick this by inserting another token after the opening bracket if there is one (proof of concept like answer). Replace Wisperwind_Sum_original_code:nnn with your original code to typeset the sum (including the handling of the optional star with IfBooleanTF).

documentclass{article}



usepackage{xparse}

ExplSyntaxOn

tl_new:N l_Wisperwind_tl

clist_new:N l_Wisperwind_clist

NewDocumentCommand Sum { s t[ }

  {

    IfBooleanTF { #2 }

      { Sum_two { #1 } [ ~ }

      { Sum_two { #1 } }

  }

NewDocumentCommand Sum_two { m O{~} m }

  {

    tl_set:Nn l_Wisperwind_tl { #2 }

    tl_remove_once:Nn l_Wisperwind_tl { ~ }

    Wisperwind_Sum_original_code:nVn { #1 } l_Wisperwind_tl { #3 }

  }

cs_new:Npn Wisperwind_Sum_original_code:nnn #1 #2 #3

  {

    sum

    clist_set:Nn l_Wisperwind_clist { #2 }

    int_case:nn { clist_count:N l_Wisperwind_clist }

      {

        { 1 } { sb { clist_item:Nn l_Wisperwind_clist { c_one_int } } }

        { 2 }

          {

            sb { clist_item:Nn l_Wisperwind_clist { c_one_int } }

            sp { clist_item:Nn l_Wisperwind_clist { 2 } }

          }

        { 3 }

          {

            sb

              {

                clist_item:Nn l_Wisperwind_clist { c_one_int }

                =

                clist_item:Nn l_Wisperwind_clist { 2 }

              }

            sp { clist_item:Nn l_Wisperwind_clist { 3 } }

          }

      }

    #3

  }

cs_generate_variant:Nn Wisperwind_Sum_original_code:nnn { nVn }

ExplSyntaxOff



begin{document}

$Sum{ldots}$  % -> sum ldots

$Sum[i]{ldots}$  % -> sum_{i} ldots

$Sum[i in I]{ldots}$  % -> sum_{i in I} ldots

$Sum[i, 0, N]{ldots}$  % -> sum_{i=0}^{N} ldots

$Sum[{i,j}, 0, N]{ldots}$  % -> sum_{i,j=0}^{N} ldots

$Sum[{i,j,k}]{ldots}$  % -> sum_{i,j,k} ldots

end{document}

Here using LaTeX2e:

documentclass{article}

usepackage{listofitems}

makeatletter

newcommandSum{@ifnextchar[{Sumaux[@gobble}{sum}}

makeatother

defSumaux[#1]#2{

  sum

  setsepchar{,}

  readlistsumargs{#1}

  ifnumlistlensumargs>1relax

    _{sumargs[1]=sumargs[2]}

    ifnumlistlensumargs>2relax^sumargs[3]fi

  else

    _{sumargs[1]}

  fi

  #2

}

begin{document}

[Sum{ldots}  ]% -> sum ldots

[Sum[i]{ldots}  ]% -> sum_{i} ldots

[Sum[i in I]{ldots}  ]% -> sum_{i in I} ldots

[Sum[i, 0, N]{ldots}  ]% -> sum_{i=0}^{N} ldots

[Sum[{i,j}, 0, N]{ldots}  ]% -> sum_{i,j=0}^{N} ldots

[Sum[{i,j,k}]{ldots}  ]% -> sum_{i,j,k} ldots

end{document}

The brace stripping is quite deliberate as newcommand-generated commands requires braces for the case

foo[{]}]{bar}

whereas xparse-generated ones do not. Without brace stripping,

foo[{bar}]

and

foo[bar]

could be treated differently.

In your case, you have a comma list with one entry. The obvious solution is to provide a second, empty, entry

Sum[{i,j},]{ldots}

as this is a no-op.