Why does a brace command group need spaces after the opening brace in POSIX Shell Grammar?

Question

TL;DR: Why does POSIX brace group need spaces after { reserved word but subshell doesn't after reserved word (?

POSIX shell grammar defines brace group and subshell as follows

brace_group      : Lbrace compound_list Rbrace

subshell         : '(' compound_list ')'

Now, if we're reading that literally, spaces are significant. This would mean that there has to be space delineating opening and closing brace and parenthesis as in

{ echo hello world; }

( echo hello world )

This would also align with Compound Command definitions:

Each of these compound commands has a reserved word or control operator at the beginning, and a corresponding terminator reserved word or operator at the end.

However what doesn't make sense is why (list) and ( list ) work just fine (that space after ( is not required), however brace expansion has to have a leading space, i.e. {echo hello;} wouldn't work.

Of course reserved word being treated as shell word would make sense needing a space afterwards to align with concept of field splitting, however definition itself makes no mention of spaces. Further, if { and ( are both considered reserved words by POSIX definition of compound command, why they're treated differently in regards to space character after these reserved words? Now, ksh(1) manual does state:

Words, which are sequences of characters, are delimited by unquoted white-space characters (space, tab and newline) or meta-characters (<, >, |, ;, &, ( and ))

In other words, it makes sense that ksh would recognize ( as word delimiter, where first word would be a command or variable assignment. POSIX, however doesn't appear to mention ( as meta-character. The only possible explanation I found as far as POSIX grammar goes is that { is considered a "token", where as ( is not listed as one.

/* These are reserved words, not operator tokens, and are
   recognized when reserved words are recognized. */


%token  Lbrace    Rbrace    Bang
/*      '{'       '}'       '!'   */

So what would be precise reasoning for this discrepancy ?

Accepted Answer Notes:

• Moved accepted checkmark to Isaac's answer since it provides quote form the standard itself which directly addresses my question:

  For instance, '(' and ')' are control operators, so that no <space> is needed in (list). However, '{' and '}' are reserved words in { list;}, so that in this case the leading <space> and <semicolon> are required.

• Accepting Kusalananda's answer. Kusalananda's answer addresses what I needed, though mostly from informal and intuitive point of view; it points out { is a reserved word and ( is operator. Michael Homer also noted the same in the comments - that Compound Command definition states(emphasis added):

  Each of these compound commands has a reserved word or control operator at the beginning

• { are defined as reserved word, similar to for or while, listed in Shell Grammar (see the last code block in the question)

• Section 2.9 states(emphasis added):

  In particular, the representations include spacing between tokens in some places where <blank>s would not be necessary (when one of the tokens is an operator).

• While the standard doesn't explicitly define ( as an operator, ( is referred to as operator; specifically, section 2.9.2 says

  If the pipeline begins with the reserved word ! and command1 is a subshell command, the application shall ensure that the ( operator at the beginning of command1 is separated from the ! by one or more characters. The behavior of the reserved word ! immediately followed by the ( operator is unspecified.

• Question on Stack Overflow by Digital Trauma points out Section 2.4 on Reserved Words:

  This recognition shall only occur when none of the characters is quoted and when the word is used as:

  -The first word of a command

• As mentioned in Kusalananda's answer "The spaces shown in the POSIX grammar are not spaces that needs to be there in the shell input data, but just a way of displaying the grammar itself. It is the fact that the braces are reserved words that implies that they have to be surrounded by whitespace" As mentioned by Michael Homer in the comments:"If the spaces were significant in their own right, they'd need to be listed in the production"

Case closed.

Answer 1

The difference between the curly braces and the parentheses are that the braces (and !) are reserved words, just like for, if, then etc. while parentheses are control operators. Words need to be separated by whitespace.

This means that just like you can't have

foriin*; do

you can't have

{somecommand;} >file

or

if !somecommand; then

The spaces shown in the POSIX grammar are not spaces that needs to be there in the shell input data, but just a way of displaying the grammar itself. It is the fact that the braces are reserved words that implies that they have to be surrounded by whitespace, while the parentheses of a subshell don't.

Answer 2

That's a limitation of the way in which the shell breaks lines into tokens.

The shell reads lines from the input file and According to section 2 "Shell Introduction" converts them to either a word or an operator:

2. The shell breaks the input into tokens: words and operators

{ is a reserved word

Some words are reserved words

Reserved words are words that have special meaning to the shell. The following words shall be recognized as reserved words:

! { } case do done elif else esac fi for if in then until while

Words, to be recognized as words, must be delimited.

Reserved words are recognized only when they are delimited ...

Mostly by blanks (point 7) and by operators.

7. If the current character is an unquoted <blank>, any token containing the previous character is delimited and the current character shall be discarded.

( is an operator

Operators stand by themselves:

whereas operators are themselves delimiters.

Where "operators" are either:

3.260 Operator

In the shell command language, either a control operator or a redirection operator.

Redirection operators are:

Redirection Operator

In the shell command language, a token that performs a redirection function. It is one of the following symbols:

<     >     >|     <<     >>     <&     >&     <<-     <>

Control operators are:

3.113 Control Operator

In the shell command language, a token that performs a control function. It is one of the following symbols:

&   &&   (   )   ;   ;;   newline   |   ||

Conclusion

So, '(' and ')' are control operators while '{' '}' are reserved words.

And the exact same description of your question is inside the spec:

For instance, '(' and ')' are control operators, so that no <space> is needed in (list). However, '{' and '}' are reserved words in { list;}, so that in this case the leading <space> and <semicolon> are required.

Which exactly explains why an space (or some other delimiter) is required after a {.

This is valid:

{ echo yes;}

As is this:

{(echo yes);}

This:

{(echo yes)}

Or even this:

{>/dev/tty echo yes;}