Gsyfuy

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.

Fundamentally you just need to use futurelet as you do for any other look ahead

deffoo{futureletfooauxfootoken}

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.

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 of group) and the character-code equals the character-code of the curly-opening-brace-character. The check does not out work out with character-tokens where the category code is 1 but the character-code is different.

But you can implement a full expandable check which tells you whether the first token inside a macro-argumnt is an explicit character-token of category code 1 (begin of 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