More Concise Syntax for Multiple Conditions about language

[mateusfccp]

You can do the same with

void main() {
  Bar a = Foo();

  if (a case Foo(name: 'Bar')) {
    // Inside this block, 'a' is promoted to 'Foo'
    // and can be used as such.
    print(a.name); // This is now safe and type-checked.
  } 
}

class Bar {}

class Foo extends Bar {
  String? name;
}

[lrhn]

So this is making , mean &&, so you have two ways to write the same thing.

And it only works in if and while conditions, maybe for?
Probably not a good fit for conditional expression or when conditions which are not parenthesized.

Also uses syntax that could potentially be used for something else, for something that already has a working syntax.

Going to be a hard sell. Benefits so small the opportunity costs alone outweigh them.

[Mike278]

You could also write your example as:

if (a case > 5 && < 10) {
 // some code...
}

[tilucasoli]

I concur with your perspective on the use of the comma , as an alternative to the && operator. But in the case that the comma operator can be used to casting or unwrap optional values. Let's consider the following example:

void main() {
  Bar a = Foo();

if (
  a is Foo,
  a?.name == 'Bar' // Conditional check
) {
  // Inside this block, 'a' is promoted to 'Foo'
  // and can be used as such.
  print(a.name); // This is now safe and type-checked.
  } 
}

class Bar {}

class Foo extends Bar {
 String? name;
}

In this scenario, the comma operator allows a easier control flow. Unlike the && operator, which evaluates both conditions together, the comma operator evaluates each condition separately. This means that after the type check (a is Foo), the variable a is promoted to the type Foo and not necesseraly need to be created a new if statement to do check the condition.

@mraleph

[Wdestroier]

Would an extension method help?

main() {
  var a = 7;
  
  final isNumberGreaterThanFive = a > 5;
  final isNumberLesserThanTen = a < 10;
  
  if (isNumberGreaterThanFive.and(isNumberLesserThanTen)) {}
}

extension NamedAndOperator on bool {
  bool and(bool other) => this && other;
}

Or is it more of a formatter feature request? Possibly related to #2885.
I wrote in the comments to (possibly) allow an optional comma before closing the if statement.

[mraleph]

This suggests replacing an obvious and well understood thing (logical and &&) with a unobvious thing (comma ,). What does comma even mean? Is it logical and? Is it logical or? Is it execute-all-expressions-and-take-just-the-last-result like in JavaScript or C++?

I think this is not just a hard sell - it is pretty much a no-go. && is clearly more readable then ,.

If condition is so complicated that it becomes hard to read - then the best strategy is to split it into variables instead.

[mateusfccp]

If you just want to have each condition in one line, you can always force the split by using //:

if (condition1 && //
    condition2 &&
    condition3) {
  // Do something
}

[MohiuddinM]

@tilucasoli wouldn't the pythonic way be better?

if (5 < a < 10) {
 // some code...
}

[MohiuddinM]

I think what @tilucasoli wants is the formatting because in Dart the commas are also used to nicely format across multiple lines. But I think formatting does not require any language changes and can be made to work with && and || too just like commas.

[lrhn]

In this scenario, the comma operator allows a easier control flow. Unlike the && operator, which evaluates both conditions together, the comma operator evaluates each condition separately.

The && operator evaluates the conditions sequentially, one before the other.
Dart is single-threaded, so no matter what the comma operator does, it will also evaluate one expression before the other (unless they're async, then they can technically be interleaved, but you'll have to put the awaits somewhere).

If the comma operator would evaluate both conditions, even if the first was false, then it's less useful and efficient than &&.
And it won't get the promotion that allows you to write:

if (
  a is Foo &&
  a.name == 'Bar' // No null-aware access needed, first condition promotes.
) {
  // Inside this block, 'a' is promoted to 'Foo'
  // and can be used as such. (Yep, works!)
  print(a.name); // This is now safe and type-checked. 
} 

The && does at least the same promotion as you're suggesting for the comma operator here.

I see no win for the comma, sorry.