On the fly (one step) expansion of a macro defined with \cs_gset_eq:NN - TeX

TopAnswers TeX

Top Answer

frougon

Delimited arguments require delimiter tokens to have the same *shape* in definition and usage(\*). `\tmpend` and `\q_stop` may be `\ifx`-equivalent, they don't have the same shape. Using `\tmpend` in the definition is fine IMHO if this is for user code (for expl3 macro code, just use `\q_stop`). You can define `\tmpend` as a quark to prevent incorrect usage.

Another important point is that when TeX grabs macro arguments (as part of the macro expansion process), it doesn't expand anything. There are functions defined with expl3 that perform some form of expansion on grabbed arguments (most notably `o`, `e`, `x`, `f` and `V` variants) but ultimately, they are built from TeX “building blocks”, among which the macros don't (some primitives such as `\expanded` obviously do). In particular, token sequences used as argument delimiters are never expanded.

(\*) In general, two tokens have the same *shape* if they are either both control sequences with the same name, or both character tokens with the same (character code, category code) pair. TeX being what it is, there are a few *very special* exceptions mentioned in [The LaTeX3 interfaces](https://mirrors.ctan.org/macros/latex/required/l3kernel/interface3.pdf) §24.7, *Description of all possible tokens*.

Another important point related to your question: when TeX grabs macro arguments (as part of the macro expansion process), it doesn't expand anything. Some functions defined with expl3 perform some form of expansion on grabbed arguments (most notably `o`, `e`, `x`, `f` and `V` variants), but ultimately, they are built from TeX “bricks”, and these don't. In particular, token sequences used as argument delimiters are never expanded. Which brings us back to good old TeX wisdom: Read The Fine TeXbook. :)

By the way, since I have the attention of both of you here, I would like to show a snippet from the acknowledgements of [LinguisTiX](https://ctan.org/pkg/linguistix) :D ![blob](/image?hash=b7c1d332ec4cb2f05d9583a0c7f0824a657ec055723e19eb43f95eae97f93a7b) _(edited)_

TeX processes tokens progressively from the input stream. It has no view whatsoever about what comes “far away“. So, when it processes `\begingroup`, the `\endgroup` being inside braces doesn't matter, TeX doesn't even see this. It will do the matching when it gets to the `\endgroup`. So, first it processes `\begingroup` (new grouping level; saves things to the save stack so they can be restored after the corresponding `\endgroup`). Then it performs the `\lccode` assignment which will affect the `\lowercase` operation. Then it processes (i.e. executes here) the `\lowercase` primitive. This replaces `\lowercase{\endgroup\let~}` with `\endgroup\let+` where the `+` has category code 13 (active) because this is the category code of `~` at this moment. Now the input stream contains ``` \endgroup\let++\catcode`\+=\active ``` where the first `+` is active but not the second one (it has catcode 12, aka ”other”). This closes the group, changes the meaning of active character `+`, and then the category code of `+` to make it active. So, further `+` characters found in the input stream will be tokenized as “active `+`” but the meaning of the resulting tokens will be the same as the meaning of the usual `+` character token... Skillmon always has hairy tricks in his pocket. :) (You can think of ”meaning” and “shape” as the two dimensions that define a token, in the mathematical vector space sense of the word “dimension”: people often say “orthogonal axes”, because non-null, pairwise orthogonal vectors are always [linearly independent](https://en.wikipedia.org/wiki/Linear_independence)... however one can have linearly independent vectors that aren't orthogonal.)

Hi, thanks for asking... alas things aren't so great here. Let's say I was passing by and your question, with a good actual MWE, was appealing. :) I hope you're doing fine, as all the nice people here.

Sorry, I would need an explanation for this. What's the job of `\lowercase` here? Why is `\endgroup` inside it? What are the steps of this construction? I.e., I thought that `\begingroup\lccode`\~=`\+` was a chunk given the two argument syntax of `\lccode`, but then the group is not ended. Okay, I am confused!

in the TeX world you'll sometimes hear/read the term "shape" for what @frougon described. The most evil tokens regarding this are active characters let to a token of the same character code but different category: ``` \begingroup\lccode`\~=`\+\lowercase{\endgroup\let~}+\catcode`\+=\active ``` After this you can't tell the new `+` apart from the normal category code 12 one in any other way than as an argument delimiter (as far as I'm aware; there is certainly no expandable way to tell them apart).

Hello, delimited arguments require the *same delimiter tokens* in definition and usage. `\tmpend` and `\q_stop` may be `\ifx`-equivalent, they are not the same token. Using `\tmpend` in the definition is fine IMHO if this is for user code (for expl3 macro code, just use `\q_stop`). You can define `\tmpend` as a quark to prevent incorrect usage.

1 Answer