proposal: chainable comparison operators

[thejoshwolfe]

We certainly don't need this feature, but as I'm working on #114, I realized that it makes sense to be able to chain some comparison operators. C doesn't allow this, but we could do it and it would make perfect sense, so I'm writing this proposal to formally discuss the idea.

• Chainable ==. a == b == c is equivalent to a == b and b == c (and b is evaluated only once).
• Chainable < and <=. a OP b OP c is equivalent to a OP b and b OP c, where OP is one of < or <=.
• Chainable > and >=. similar to above.

Python has this feature, but I'm proposing a more restrictive version than python's operator chaining. In python, you can do a != b != c, and I don't remember exactly what that does. That's a problem, so I'm proposing you can't do that in Zig. The proposal is that you can chain operators that work transitively, which is when a OP b and b OP c then it's obvious that a OP c. This is true for the above three cases, and isn't true of all any other mixture of comparison operators.

There's one subtle issue here, which is the hidden use of the short-circuit and operator. It may seem at first glance that a() == b() == c() would call all three functions when really it only needs to call the first two sometimes. That might be obvious to some readers, but might not be to all readers.

Fwiw, python has the hidden short circuit operator like I'm proposing.

[andrewrk]

I think this is one of those features that looks and sounds nice, but ultimately makes the language bigger, requires the programmer to remember more things, and isn't worth that cost.

a == b == c is barely more convenient than a == b and b == c, and plus I read that as (a == b) == c, which doesn't even make sense according to types, if a,b,c are integers. I don't find this feature worth it. I make a motion to reject this proposal.

[thejoshwolfe]

sounds good.

[momumi]

At the moment its undecided whether zig switch statements should work with floating point values (#359, #3136). If we had this feature you could write expressions like this:

if (x < 0) {
} else if (0 <= x < 100) {
} else if (x >= 100) {
} else {
}

which I think is elegant and more intuitive then using a switch statement. You can do this now with compound and, but it makes the code harder to read. This change would be much simpler than the others suggested in (#359) so I think we should reconsider adding this feature.

I think this is one of those features that looks and sounds nice, but ultimately makes the language bigger, requires the programmer to remember more things, and isn't worth that cost.

This feature only needs a tiny change to the grammar of the language, and I think its worth it:

CompareOp := '<' | '<=' | '>' | '>=' | '==' | '!='

// New version
CompareExp := Exp (CompareOp Exp)+

// Old version
CompareExp_OLD := Exp CompareOp Exp

Of course there is the argument that it can be used to write confusing expressions, but in practice people won't unless they are deliberately trying to obfuscate their code.