How to write a macro that is braces sensitive?
In the xparse
package, there is the g
type of argument which captures things inside a pair of TeX group tokens. This makes it possible to define commands foo
that behaves differently for foo{a}
and foo a
. I am interested in whether such type of macro is possible in plain TeX (I guess yes) and if it is possible, how can it be implemented. I am new to plain TeX and I appreciate detailed explanation of the workflow of such a macro. I would also be happy to learn about other possibilities such as in e-TeX instead of plain TeX.
Edit
Only after reading the answers did I realize that it was impossible at first look because all I was thinking was deffoo#1...
(and indeed it is impossible if this form is used).
macros plain-tex braces
New contributor
add a comment |
In the xparse
package, there is the g
type of argument which captures things inside a pair of TeX group tokens. This makes it possible to define commands foo
that behaves differently for foo{a}
and foo a
. I am interested in whether such type of macro is possible in plain TeX (I guess yes) and if it is possible, how can it be implemented. I am new to plain TeX and I appreciate detailed explanation of the workflow of such a macro. I would also be happy to learn about other possibilities such as in e-TeX instead of plain TeX.
Edit
Only after reading the answers did I realize that it was impossible at first look because all I was thinking was deffoo#1...
(and indeed it is impossible if this form is used).
macros plain-tex braces
New contributor
It's possible, but it's bad syntax. Under normal TeX conventions,foo a
andfoo{a}
should be considered equivalent (when the argument consists of a single token as in this case).
– egreg
Apr 6 at 21:18
Thank you for your quick reply. I know it's bad syntax otherwisexparse
would not declare it as obsolete, but it is (extensively) used in e.g.physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.
– Weijun Zhou
Apr 6 at 21:22
1
It's indeed used inphysics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.
– egreg
Apr 6 at 21:23
1
Due to the weird syntax I end up addingrelax
here and there ... but I guess I will still use it.
– Weijun Zhou
Apr 6 at 21:31
add a comment |
In the xparse
package, there is the g
type of argument which captures things inside a pair of TeX group tokens. This makes it possible to define commands foo
that behaves differently for foo{a}
and foo a
. I am interested in whether such type of macro is possible in plain TeX (I guess yes) and if it is possible, how can it be implemented. I am new to plain TeX and I appreciate detailed explanation of the workflow of such a macro. I would also be happy to learn about other possibilities such as in e-TeX instead of plain TeX.
Edit
Only after reading the answers did I realize that it was impossible at first look because all I was thinking was deffoo#1...
(and indeed it is impossible if this form is used).
macros plain-tex braces
New contributor
In the xparse
package, there is the g
type of argument which captures things inside a pair of TeX group tokens. This makes it possible to define commands foo
that behaves differently for foo{a}
and foo a
. I am interested in whether such type of macro is possible in plain TeX (I guess yes) and if it is possible, how can it be implemented. I am new to plain TeX and I appreciate detailed explanation of the workflow of such a macro. I would also be happy to learn about other possibilities such as in e-TeX instead of plain TeX.
Edit
Only after reading the answers did I realize that it was impossible at first look because all I was thinking was deffoo#1...
(and indeed it is impossible if this form is used).
macros plain-tex braces
macros plain-tex braces
New contributor
New contributor
edited 2 days ago
Weijun Zhou
New contributor
asked Apr 6 at 21:14
Weijun ZhouWeijun Zhou
1405
1405
New contributor
New contributor
It's possible, but it's bad syntax. Under normal TeX conventions,foo a
andfoo{a}
should be considered equivalent (when the argument consists of a single token as in this case).
– egreg
Apr 6 at 21:18
Thank you for your quick reply. I know it's bad syntax otherwisexparse
would not declare it as obsolete, but it is (extensively) used in e.g.physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.
– Weijun Zhou
Apr 6 at 21:22
1
It's indeed used inphysics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.
– egreg
Apr 6 at 21:23
1
Due to the weird syntax I end up addingrelax
here and there ... but I guess I will still use it.
– Weijun Zhou
Apr 6 at 21:31
add a comment |
It's possible, but it's bad syntax. Under normal TeX conventions,foo a
andfoo{a}
should be considered equivalent (when the argument consists of a single token as in this case).
– egreg
Apr 6 at 21:18
Thank you for your quick reply. I know it's bad syntax otherwisexparse
would not declare it as obsolete, but it is (extensively) used in e.g.physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.
– Weijun Zhou
Apr 6 at 21:22
1
It's indeed used inphysics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.
– egreg
Apr 6 at 21:23
1
Due to the weird syntax I end up addingrelax
here and there ... but I guess I will still use it.
– Weijun Zhou
Apr 6 at 21:31
It's possible, but it's bad syntax. Under normal TeX conventions,
foo a
and foo{a}
should be considered equivalent (when the argument consists of a single token as in this case).– egreg
Apr 6 at 21:18
It's possible, but it's bad syntax. Under normal TeX conventions,
foo a
and foo{a}
should be considered equivalent (when the argument consists of a single token as in this case).– egreg
Apr 6 at 21:18
Thank you for your quick reply. I know it's bad syntax otherwise
xparse
would not declare it as obsolete, but it is (extensively) used in e.g. physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.– Weijun Zhou
Apr 6 at 21:22
Thank you for your quick reply. I know it's bad syntax otherwise
xparse
would not declare it as obsolete, but it is (extensively) used in e.g. physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.– Weijun Zhou
Apr 6 at 21:22
1
1
It's indeed used in
physics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.– egreg
Apr 6 at 21:23
It's indeed used in
physics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.– egreg
Apr 6 at 21:23
1
1
Due to the weird syntax I end up adding
relax
here and there ... but I guess I will still use it.– Weijun Zhou
Apr 6 at 21:31
Due to the weird syntax I end up adding
relax
here and there ... but I guess I will still use it.– Weijun Zhou
Apr 6 at 21:31
add a comment |
2 Answers
2
active
oldest
votes
You can use futurelet
letleftbracechar={
deffoo{%
begingroup
futureletfootempinnerfoo
}%
definnerfoo{%
expandafterendgroup
ifxfootempleftbracechar
expandafterfooatleftbrace
else
expandafterfooatnoleftbrace
fi
}%
deffooatleftbrace#1{Argument in braces is: {bf #1}}
deffooatnoleftbrace#1{Argument without braces is: {bf #1}}
foo a
foo{a}
bye
, but be aware that this can be confused by implicit characters, i.e., by things like foobgroup huh?...
Besides this, the check is only about tokens (be they explicit or implicit character tokens) where the category code is 1 (begin group) and the character code equals the character code of the curly-opening-brace-character. The check does not work out with character tokens where the category code is 1 (begin group) but the character code is different.
But you can implement a full expandable check which tells you whether the first token inside a macro argument is an explicit character token of category code 1 (begin group) no matter what its character code might be:
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is an explicit catcode-1-character
%%.............................................................................
%% UDCheckWhetherBrace{<Argument which is to be checked>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>}%
longdeffirstoftwo#1#2{#1}%
longdefsecondoftwo#1#2{#2}%
longdefUDCheckWhetherBrace#1{%
romannumeral0expandaftersecondoftwoexpandafter{expandafter{%
string#1.}expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's have some fun: Give [ the same functionality as {:
catcode`[=thecatcode`{
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's see that the test on explicit characters is not fooled by implicit characters:
letbgroup={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroupegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroup Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% The test is also not fooled by implicit active characters:
catcode`X=13
let X={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{Xegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{X Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
bye
In order to see how UDCheckWhetherBrace
works, let's write it with different line-breaking and different indentation:
The gist is: Have the argument's first token hit by string
and use TeX's catching of brace-balanced arguments for finding out whether an opening brace or something else was neutralized/was turned into a catcode-12-sequence:
longdefUDCheckWhetherBrace#1{%
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string#1.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
For example
UDCheckWhetherBrace{test}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying "t" from the phrase "test":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character t, due to string now of category code 12 (other)⟩est.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩no brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
no brace
For example
UDCheckWhetherBrace{{test}}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying the left curly brace/the openening curly brace from the phrase "{test}":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character {, due to string now of category code 12 (other)⟩test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
firstoftwo{%
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩firstoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
brace
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
add a comment |
Fundamentally you just need to use futurelet
as you do for any other look ahead
deffoo{futureletfootokenfooaux}
deffooaux{%
ifxfootokenbgroup
% Brace group
else
% Something else
fi
}
The only reason this 'looks different' to other peek ahead situations is that you can't use an explicit {
, but rather the implicit token bgroup
.
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
add a comment |
Your Answer
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "85"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Weijun Zhou is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2ftex.stackexchange.com%2fquestions%2f483588%2fhow-to-write-a-macro-that-is-braces-sensitive%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
2 Answers
2
active
oldest
votes
2 Answers
2
active
oldest
votes
active
oldest
votes
active
oldest
votes
You can use futurelet
letleftbracechar={
deffoo{%
begingroup
futureletfootempinnerfoo
}%
definnerfoo{%
expandafterendgroup
ifxfootempleftbracechar
expandafterfooatleftbrace
else
expandafterfooatnoleftbrace
fi
}%
deffooatleftbrace#1{Argument in braces is: {bf #1}}
deffooatnoleftbrace#1{Argument without braces is: {bf #1}}
foo a
foo{a}
bye
, but be aware that this can be confused by implicit characters, i.e., by things like foobgroup huh?...
Besides this, the check is only about tokens (be they explicit or implicit character tokens) where the category code is 1 (begin group) and the character code equals the character code of the curly-opening-brace-character. The check does not work out with character tokens where the category code is 1 (begin group) but the character code is different.
But you can implement a full expandable check which tells you whether the first token inside a macro argument is an explicit character token of category code 1 (begin group) no matter what its character code might be:
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is an explicit catcode-1-character
%%.............................................................................
%% UDCheckWhetherBrace{<Argument which is to be checked>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>}%
longdeffirstoftwo#1#2{#1}%
longdefsecondoftwo#1#2{#2}%
longdefUDCheckWhetherBrace#1{%
romannumeral0expandaftersecondoftwoexpandafter{expandafter{%
string#1.}expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's have some fun: Give [ the same functionality as {:
catcode`[=thecatcode`{
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's see that the test on explicit characters is not fooled by implicit characters:
letbgroup={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroupegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroup Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% The test is also not fooled by implicit active characters:
catcode`X=13
let X={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{Xegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{X Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
bye
In order to see how UDCheckWhetherBrace
works, let's write it with different line-breaking and different indentation:
The gist is: Have the argument's first token hit by string
and use TeX's catching of brace-balanced arguments for finding out whether an opening brace or something else was neutralized/was turned into a catcode-12-sequence:
longdefUDCheckWhetherBrace#1{%
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string#1.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
For example
UDCheckWhetherBrace{test}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying "t" from the phrase "test":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character t, due to string now of category code 12 (other)⟩est.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩no brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
no brace
For example
UDCheckWhetherBrace{{test}}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying the left curly brace/the openening curly brace from the phrase "{test}":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character {, due to string now of category code 12 (other)⟩test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
firstoftwo{%
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩firstoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
brace
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
add a comment |
You can use futurelet
letleftbracechar={
deffoo{%
begingroup
futureletfootempinnerfoo
}%
definnerfoo{%
expandafterendgroup
ifxfootempleftbracechar
expandafterfooatleftbrace
else
expandafterfooatnoleftbrace
fi
}%
deffooatleftbrace#1{Argument in braces is: {bf #1}}
deffooatnoleftbrace#1{Argument without braces is: {bf #1}}
foo a
foo{a}
bye
, but be aware that this can be confused by implicit characters, i.e., by things like foobgroup huh?...
Besides this, the check is only about tokens (be they explicit or implicit character tokens) where the category code is 1 (begin group) and the character code equals the character code of the curly-opening-brace-character. The check does not work out with character tokens where the category code is 1 (begin group) but the character code is different.
But you can implement a full expandable check which tells you whether the first token inside a macro argument is an explicit character token of category code 1 (begin group) no matter what its character code might be:
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is an explicit catcode-1-character
%%.............................................................................
%% UDCheckWhetherBrace{<Argument which is to be checked>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>}%
longdeffirstoftwo#1#2{#1}%
longdefsecondoftwo#1#2{#2}%
longdefUDCheckWhetherBrace#1{%
romannumeral0expandaftersecondoftwoexpandafter{expandafter{%
string#1.}expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's have some fun: Give [ the same functionality as {:
catcode`[=thecatcode`{
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's see that the test on explicit characters is not fooled by implicit characters:
letbgroup={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroupegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroup Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% The test is also not fooled by implicit active characters:
catcode`X=13
let X={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{Xegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{X Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
bye
In order to see how UDCheckWhetherBrace
works, let's write it with different line-breaking and different indentation:
The gist is: Have the argument's first token hit by string
and use TeX's catching of brace-balanced arguments for finding out whether an opening brace or something else was neutralized/was turned into a catcode-12-sequence:
longdefUDCheckWhetherBrace#1{%
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string#1.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
For example
UDCheckWhetherBrace{test}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying "t" from the phrase "test":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character t, due to string now of category code 12 (other)⟩est.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩no brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
no brace
For example
UDCheckWhetherBrace{{test}}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying the left curly brace/the openening curly brace from the phrase "{test}":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character {, due to string now of category code 12 (other)⟩test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
firstoftwo{%
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩firstoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
brace
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
add a comment |
You can use futurelet
letleftbracechar={
deffoo{%
begingroup
futureletfootempinnerfoo
}%
definnerfoo{%
expandafterendgroup
ifxfootempleftbracechar
expandafterfooatleftbrace
else
expandafterfooatnoleftbrace
fi
}%
deffooatleftbrace#1{Argument in braces is: {bf #1}}
deffooatnoleftbrace#1{Argument without braces is: {bf #1}}
foo a
foo{a}
bye
, but be aware that this can be confused by implicit characters, i.e., by things like foobgroup huh?...
Besides this, the check is only about tokens (be they explicit or implicit character tokens) where the category code is 1 (begin group) and the character code equals the character code of the curly-opening-brace-character. The check does not work out with character tokens where the category code is 1 (begin group) but the character code is different.
But you can implement a full expandable check which tells you whether the first token inside a macro argument is an explicit character token of category code 1 (begin group) no matter what its character code might be:
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is an explicit catcode-1-character
%%.............................................................................
%% UDCheckWhetherBrace{<Argument which is to be checked>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>}%
longdeffirstoftwo#1#2{#1}%
longdefsecondoftwo#1#2{#2}%
longdefUDCheckWhetherBrace#1{%
romannumeral0expandaftersecondoftwoexpandafter{expandafter{%
string#1.}expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's have some fun: Give [ the same functionality as {:
catcode`[=thecatcode`{
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's see that the test on explicit characters is not fooled by implicit characters:
letbgroup={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroupegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroup Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% The test is also not fooled by implicit active characters:
catcode`X=13
let X={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{Xegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{X Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
bye
In order to see how UDCheckWhetherBrace
works, let's write it with different line-breaking and different indentation:
The gist is: Have the argument's first token hit by string
and use TeX's catching of brace-balanced arguments for finding out whether an opening brace or something else was neutralized/was turned into a catcode-12-sequence:
longdefUDCheckWhetherBrace#1{%
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string#1.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
For example
UDCheckWhetherBrace{test}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying "t" from the phrase "test":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character t, due to string now of category code 12 (other)⟩est.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩no brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
no brace
For example
UDCheckWhetherBrace{{test}}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying the left curly brace/the openening curly brace from the phrase "{test}":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character {, due to string now of category code 12 (other)⟩test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
firstoftwo{%
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩firstoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
brace
You can use futurelet
letleftbracechar={
deffoo{%
begingroup
futureletfootempinnerfoo
}%
definnerfoo{%
expandafterendgroup
ifxfootempleftbracechar
expandafterfooatleftbrace
else
expandafterfooatnoleftbrace
fi
}%
deffooatleftbrace#1{Argument in braces is: {bf #1}}
deffooatnoleftbrace#1{Argument without braces is: {bf #1}}
foo a
foo{a}
bye
, but be aware that this can be confused by implicit characters, i.e., by things like foobgroup huh?...
Besides this, the check is only about tokens (be they explicit or implicit character tokens) where the category code is 1 (begin group) and the character code equals the character code of the curly-opening-brace-character. The check does not work out with character tokens where the category code is 1 (begin group) but the character code is different.
But you can implement a full expandable check which tells you whether the first token inside a macro argument is an explicit character token of category code 1 (begin group) no matter what its character code might be:
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is an explicit catcode-1-character
%%.............................................................................
%% UDCheckWhetherBrace{<Argument which is to be checked>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>}%
%% {<Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>}%
longdeffirstoftwo#1#2{#1}%
longdefsecondoftwo#1#2{#2}%
longdefUDCheckWhetherBrace#1{%
romannumeral0expandaftersecondoftwoexpandafter{expandafter{%
string#1.}expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{{Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's have some fun: Give [ the same functionality as {:
catcode`[=thecatcode`{
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[}Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{[Test}}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% Now let's see that the test on explicit characters is not fooled by implicit characters:
letbgroup={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroupegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{bgroup Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
leavevmodehrulefillnull
% The test is also not fooled by implicit active characters:
catcode`X=13
let X={
UDCheckWhetherBrace{Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{Xegroup Test}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
UDCheckWhetherBrace{X Testegroup}%
{The first token of the arg is an explicit catcode 1 char.}%
{The first token of the arg is not an explicit catcode 1 char.}%
bye
In order to see how UDCheckWhetherBrace
works, let's write it with different line-breaking and different indentation:
The gist is: Have the argument's first token hit by string
and use TeX's catching of brace-balanced arguments for finding out whether an opening brace or something else was neutralized/was turned into a catcode-12-sequence:
longdefUDCheckWhetherBrace#1{%
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string#1.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
}%
For example
UDCheckWhetherBrace{test}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string test.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying "t" from the phrase "test":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character t, due to string now of category code 12 (other)⟩est.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩secondoftwo%
{brace}{no brace}%
yields carrying out expandafter
and secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩no brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
no brace
For example
UDCheckWhetherBrace{{test}}{brace}{no brace}%
yields:
romannumeral0%
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter
secondoftwo%← This is the interesting secondoftwo.
expandafter{%← This is the interesting secondoftwo's first argument's opening brace.
expandafter{%
string{test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
and thus stringifying the left curly brace/the openening curly brace from the phrase "{test}":
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo%← This is the interesting secondoftwo.
{%← This is the interesting secondoftwo's first argument's opening brace.
{%
⟨character {, due to string now of category code 12 (other)⟩test}.}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% , which itself must be brace-balanced, had an opening-brace as first token.
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the interesting secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterfirstoftwoexpandafter{expandafter
secondoftwostring}expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out the expandafter
-chain and string
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
firstoftwo{%
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo}%← This is the interesting secondoftwo's first argument's closing brace in case the argument
% did not have an opening-brace as first token
{expandafterexpandafterfirstoftwo{ }{}secondoftwo}%
{brace}{no brace}%
yields carrying out firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
secondoftwo⟨character }, due to string now of category code 12 (other)⟩expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out secondoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafterexpandafterfirstoftwo{ }{}%
firstoftwo
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
and thus delivering the space that was inside braces:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
expandafter⟨space token⟩firstoftwo%
{brace}{no brace}%
yields carrying out expandafter
and firstoftwo
:
%romannumeral expansion in progress as by now romannumeral only found the digit 0 and searches for more digits:
⟨space token⟩brace
Now romannumeral
finds the space token and discards it and aborts gathering digits. As by now it has only found the digit "0" which does not form a positive number, it does silently not deliver any token:
%romannumeral expansion done:
brace
edited yesterday
answered Apr 6 at 22:02
Ulrich DiezUlrich Diez
5,625620
5,625620
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
add a comment |
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
This is much more extensive. I will spend some time understanding and learning from it. I think the idea of checking catcode instead of char code is very interesting and useful. It would be great if some more explanation can be added for the latter case.
– Weijun Zhou
Apr 6 at 22:08
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
Thank you very much for your effort explaining how it works.
– Weijun Zhou
2 days ago
add a comment |
Fundamentally you just need to use futurelet
as you do for any other look ahead
deffoo{futureletfootokenfooaux}
deffooaux{%
ifxfootokenbgroup
% Brace group
else
% Something else
fi
}
The only reason this 'looks different' to other peek ahead situations is that you can't use an explicit {
, but rather the implicit token bgroup
.
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
add a comment |
Fundamentally you just need to use futurelet
as you do for any other look ahead
deffoo{futureletfootokenfooaux}
deffooaux{%
ifxfootokenbgroup
% Brace group
else
% Something else
fi
}
The only reason this 'looks different' to other peek ahead situations is that you can't use an explicit {
, but rather the implicit token bgroup
.
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
add a comment |
Fundamentally you just need to use futurelet
as you do for any other look ahead
deffoo{futureletfootokenfooaux}
deffooaux{%
ifxfootokenbgroup
% Brace group
else
% Something else
fi
}
The only reason this 'looks different' to other peek ahead situations is that you can't use an explicit {
, but rather the implicit token bgroup
.
Fundamentally you just need to use futurelet
as you do for any other look ahead
deffoo{futureletfootokenfooaux}
deffooaux{%
ifxfootokenbgroup
% Brace group
else
% Something else
fi
}
The only reason this 'looks different' to other peek ahead situations is that you can't use an explicit {
, but rather the implicit token bgroup
.
edited Apr 6 at 22:18
frougon
850711
850711
answered Apr 6 at 21:22
Joseph Wright♦Joseph Wright
205k23564892
205k23564892
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
add a comment |
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
That's clear enough and much simpler than I originally imagined.
– Weijun Zhou
Apr 6 at 21:27
add a comment |
Weijun Zhou is a new contributor. Be nice, and check out our Code of Conduct.
Weijun Zhou is a new contributor. Be nice, and check out our Code of Conduct.
Weijun Zhou is a new contributor. Be nice, and check out our Code of Conduct.
Weijun Zhou is a new contributor. Be nice, and check out our Code of Conduct.
Thanks for contributing an answer to TeX - LaTeX Stack Exchange!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2ftex.stackexchange.com%2fquestions%2f483588%2fhow-to-write-a-macro-that-is-braces-sensitive%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
It's possible, but it's bad syntax. Under normal TeX conventions,
foo a
andfoo{a}
should be considered equivalent (when the argument consists of a single token as in this case).– egreg
Apr 6 at 21:18
Thank you for your quick reply. I know it's bad syntax otherwise
xparse
would not declare it as obsolete, but it is (extensively) used in e.g.physics
package. I am just not sure about whether it can be done in plain, or it requires some features of the engine.– Weijun Zhou
Apr 6 at 21:22
1
It's indeed used in
physics
. My opinion about the package is that it has good ideas, but I can't recommend its usage. The weird syntax is just one among the several reasons for not recommending it.– egreg
Apr 6 at 21:23
1
Due to the weird syntax I end up adding
relax
here and there ... but I guess I will still use it.– Weijun Zhou
Apr 6 at 21:31