TL;DR: The comma operator has little use in D, but perhaps it could be used like in Python, to define tuple expressions.

Context:

In D, one can write a comma expression, similar to C and C++: https://dlang.org/spec/expression.html#comma_expression

Comma itself is a low precedence operator, lower than assignment. Thus, consider the following two C examples:

#include <stdio.h>

int main() {
  int a;
  a = 1, 2, 3;
  printf("%d\n", a);  // Outputs: 1
  return 0;
}

#include <stdio.h>

int main() {
  int a;
  a = (1, 2, 3);
  printf("%d\n", a);  // Outputs: 3
  return 0;
}

The usage of the comma operator like this is counter-intuitive, and almost always leads to errors. In fact, in D, using the result of a comma expression is entirely forbidden.

void main()
{
  int b = (1, 2, 3);
  assert(b == 3);
}

// onlineapp.d(3): Error: using the result of a comma expression is not allowed

The comma expression is mostly viewed as a shortcut to write multiple expressions on a single line, offering only a few benefits over just using semi-colons. For example:

int a = 1; int b = 2;
int a = 1, b = 2;  // The type doesn't have to be repeated.

Comparison with Python:

In Python, tuples are a built-in type, defined using parenthesis. E.g. (1, 2, 3) is a tuple with three numbers, while (3, "Bob", 1.2) is a tuple with a number, string, and float. https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences

The parenthesis are actually optional in Python, meaning one can create a tuple like 1, 2, 3. Moreover, tuples can be used in assignment expressions as well, as illustrated in the following example:

# Assigns a=1, b=2, c=3
a, b, c = 1, 2, 3

Additionally, tuples can also be used as the return type of functions, e.g.:

# Computes the evaluation of an expression given variable values, and returns
# the result as well as the derivative.
def evalAndDiv(expression, variables):
  ...
  return result, derivative

r,d = evalAndDiv(myExpression, myVariables)

A built-in recognition of tuples also dove-tails nicely with things like foreach loops, which currently have a special implementation for iterating over associative-arrays: https://dlang.org/spec/hash-map.html#aa_example_iteration

Question: Would D benefit from using commas to define tuples rather than triggering an error when the result of a comma-expression is used? Right now, because the errors, the result of a comma expression is a bit of "unused real estate" in the language.

The easy syntax for dealing with tuples of values is especially useful in writing logic for machine-learning algorithms, and has helped Python gain and hold a strong foothold in this area, but where performance is needed, Python libraries like PyTorch turn to C++. Perhaps this could be D instead.

On Tuesday, 8 August 2023 at 16:47:25 UTC, Vijay Nayar wrote:

# Assigns a=1, b=2, c=3
a, b, c = 1, 2, 3

Don't like it because if a and b predefined with -1 and 0 I would assume to get a tuple:
(-1,0,1,2,3)

This notion also fits to default arguments we already have in D.

On Tuesday, 8 August 2023 at 19:18:42 UTC, sighoya wrote:

# Assigns a=1, b=2, c=3
a, b, c = 1, 2, 3

In Python, there is also a syntax for default arguments that is identical to D: https://www.geeksforgeeks.org/default-arguments-in-python/

Using the comma operator to define tuples would require changing the operator precedence. Rather than being at the lowest priority, with assignment being above it, it would be a higher priority than assignment.

Thus you would end up with:

(a, b, c) = (1, 2, 3)

Rather than:

(a), (b), (c = 1), 2, 3

This change in priority would be specific to top-level statements, it would not subvert the parsing of a function's argument list.

On Tuesday, 8 August 2023 at 21:00:06 UTC, Vijay Nayar wrote:

Then we have some kind of non uniformity between function declarations and top level statements.
And what about this statement?:

int a,b=1,c;

On Tuesday, 8 August 2023 at 16:47:25 UTC, Vijay Nayar wrote:

You can use something like tuple assignment, you can get pretty far simulating that with current D’s tools:

struct t
{
    import std.typecons : tuple;
    static opIndex(Ts...)(Ts args) => tuple(args);

    alias opIndexAssign = opIndexOpAssign!"";
    template opIndexOpAssign(string op)
    {
        static void opIndexOpAssign(R, Ts...)(R rhs, ref Ts lhs)
        {
            static foreach (i; 0 .. Ts.length)
            	mixin("lhs[i] ", op,"= rhs[i];");
        }
    }
}

void main()
{
    int x;
    double y;
    t[x, y] = t[2, 3.14];
    assert(x == 2);
    assert(y == 3.14);
    t[x, y] += t[3, 2.71];
    assert(x == 5);
    assert(y == 3.14 + 2.71);
}

It doesn’t work with non-copyable values, but it can be made to work with some effort (I’ve done that). Other than that, this little thing gets you quite far. A rough outline of how to support non-copyable types: Make your own tuple-like type to store the values that went into and “store” a compile-time bool array of whether the values were rvalues or lvalues. When the values are read, return originally-lvalue values by reference and move the originally-rvalue values (return by value).

Obviously it can’t do declarations and a few other things that language-level tuple support would (in all likelihood) bring.