Mfcttrf

I'm trying to write a macro, tup that will effectively expand this:

tup b 

to this:

leftlangle a ~middle|~ b ~middle|~ ... ~middle|~ z rightrangle

I tried the following, but it only puts down the first separator and then stops.

documentclass[preview]standalone

newcommandbrak[1]ensuremathleftlangle#1rightrangle

makeatletter
newcommandtup[1]%
 begingroup%
 @tempswafalse%
 def@sep~middle%
 edef@tempa#1%
 expandafterbrakexpandafterexpandafter@tuploop@temparelax%
 endgroup%

def@tuploop#1|#2relax%
 if@tempswa@sepelse@tempswatruefi#1
 begingroup
 ifxrelax#2relax
 renewcommandnextendgroup%
 else
 renewcommandnextendgroup@tuploop#2relax%
 fi
 next

makeatother

begindocument
$tupb$
enddocument

However, if I change the definition of @sep to def@sep~ then it "works" and puts the pipe characters in between

I believe middle might be expanding too early, but I'm not sure what to do. How can I get this to work?

I don't think you need a loop:

documentclassarticle

begingroup
lccode`~=`|
lowercaseendgroup
deftup#1="8000leftlangle#1rightrangle

begindocument

[
tup b + tupa 
]

enddocument

As a general rule, I recommend to avoid left and right whenever possible.

Here's an implementation with a syntax similar to commands defined with DeclarePairedDelimiter from mathtools.

The unadorned command uses normal size; in the optional argument big, Big, bigg or Bigg can appear. The * means using automatic sizing.

Spaces in the mandatory argument are ignored, so tupb is the same as tup c.

documentclassarticle
usepackageamsmath
usepackagexparse

ExplSyntaxOn

NewDocumentCommandtupsom
 
 IfBooleanTF#1
 
 tl_set:Nn l__reinking_tup_open_tl leftlangle 
 tl_set:Nn l__reinking_tup_middle_tl ; 
 tl_set:Nn l__reinking_tup_close_tl rightrangle 
 
 
 IfNoValueTF#2
 
 tl_set:Nn l__reinking_tup_open_tl langle 
 tl_set:Nn l__reinking_tup_middle_tl mathrel 
 tl_set:Nn l__reinking_tup_close_tl rangle 
 
 
 tl_set:Nn l__reinking_tup_open_tl mathopen#2langle 
 tl_set:Nn l__reinking_tup_middle_tl mathrel#2 
 tl_set:Nn l__reinking_tup_close_tl mathclose#2rangle 
 
 
 __reinking_tup:n #3 
 

tl_new:N l__reinking_tup_open_tl
tl_new:N l__reinking_tup_middle_tl
tl_new:N l__reinking_tup_close_tl
seq_new:N l__reinking_tup_items_seq

cs_new_protected:Nn __reinking_tup:n
 
 seq_set_split:Nnn l__reinking_tup_items_seq #1 
 l__reinking_tup_open_tl
 seq_use:NV l__reinking_tup_items_seq l__reinking_tup_middle_tl
 l__reinking_tup_close_tl
 
cs_generate_variant:Nn seq_use:Nn NV 

ExplSyntaxOff

begindocument

$tupa$
quad
$tup[big]a$
quad
$tup[Big]a$
quad
$tup*dots$

enddocument

A package-free version, which indiscriminately uses left, middle and right. The items are absorbed one at a time and appended to a list, then the list is executed.

documentclassarticle
usepackageamsmath

makeatletter
newcommandtup[1]%
 def@tup@list%
 @tup#1
def@tup#1|%
 ifx@tup#1relax
 expandafter@firstoftwo
 else
 expandafter@secondoftwo
 fi
 leftlangle@tup@listrightrangle%
 ifx@tup@list@empty@tup@append#1else@tup@append;#1fi@tup%

def@tup@append#1%
 expandafterdefexpandafter@tup@listexpandafter@tup@list#1%

makeatother

begindocument

$tupa$

$tupa$

enddocument

This way there's no problem with groups implicitly formed by left, middle and right.

Your command was almost working. If you put more items in tup, like $tupc$ you'd see this:

it's not the first item which is left out, rather they are grouped in pairs. Your command starts with a leftlangle, which starts a "math left group" and with the @tempswa switch set to false. In the first iteration of @tuploop you do if@tempswa@sepelse@tempswatruefi which expands to @tempswatrue, meaning that no @sep is inserted now, and @tempswa is now true. The command then inserts the first item (a) and proceeds to the next iteration.

On the second iteration, @tempswa is true and if@tempswa@sepelse@tempswatruefi expands to @sep, which inserts a middle| (the separator after a). The middle primitive will end the "math left group" started by leftlangle and will start another "math left group". However, when the first group ended, your @tempswa switch was restored to its value outside the current group, which is false! And now the command inserts b and goes to the third iteration, but now with @tempswa set to false once again.

So your command was actually inserting <token>|<token> and then <token>|<token>, and so on, due to the end of group triggered by middle. You could circumvent this with some aftergroup magic, or simply making a gloabl assignment to the switch:

if@tempswa@sepelseglobal@tempswatruefi

However, as egreg said in the comment, @tempswa is supposed to be set locally only, so it would be better if you created a newififg@insertsep and then always used globalg@insertseptrue and globalg@insertsepfalse.

And since meanwhile egreg posted a much more elaborate expl3 answer than the one-liner I would post, I'll stop here ;-)

There seems to be space for one more answer, in which one could mention that all this seems to have been done some long time ago.

documentclassarticle
usepackagebraket
begindocument
[
Braket b + Braketa 
]
enddocument

Back then they also needed no loop. ;-)