What is a "comma expression"?

[Elmar]

On Sunday, 10 October 2021 at 12:01:33 UTC, rempas wrote:
> This is the first time I'm finding something like that. I'm 
> having the following code in C:
>
> ```
>   if (0 == (i >> 7)) {
>     if (len < 1) return -1;
>     v = i;
>     return *ret = v, 1;
>   }
> ```
>
> This is part of a function that returns an `int`. When I'm 
> running this in C, it works. However in D, I'm getting the 
> following error message:
>
> ```
> Error: Using the result of a comma expression is not allowed
> ```
>
> Can someone explain what comma expressions are and why they 
> don't work in D (or if the only doesn't work as returned values 
> from a function)?

Hello rempas.

The comma-operator `,` is like `;` but results in an expression 
value, not a statement like `;` would. The left side of `,` is 
executed like a statement and the value of the right side of `,` 
is returned. Comma-expressions are merely used to pack additional 
instructions into places where only expressions are allowed.

```d
if (x = y, myNiceFunction(), yay(x), x > 5)
{
    // ...
}
```

or

```d
if (hasFancyFunkyStuff)
     x = z, fancy(x), funkyUpdate(z);   // too lazy for braces
```

Many consider the `,` operator to be a design-flaw because it 
makes expressions difficult to read and can be easily abused 
because the above should actually be:

```d
x = y;
myNiceFunction();
yay(x);
if (x > 5)
{
     // ...
}
```

In `D` you can still write the second example of code but not the 
first example of code. The designers of D thought they could make 
it less painful by just forbidding comma-expressions to be used 
as expression value and only as statement. This is because then 
comma-expressions can still be used in `for`-loops:

```d
for (x = y, z = a; x < z; x++, z--)
{
     ;
}
```

In conclusion, your C snippet should actually look like:

```c
   if (0 == (i >> 7))
   {
     if (len < 1)
       return -1;
     *ret = v = i;
     return 1;
   }
```

The previous snippet even could mislead readers to think that it 
would return a tuple of two elements which it doesn't.