Unexpected result from i == j == k? - chapel

Question

In this code I am looping over all indices in a 3D domain, and printing the "diagonal" part as
for (i, j, k) in {0..9, 0..9, 0..9}
{
if i == j == k // (1)
//if (i == j) && (j == k) // (2) -> gives expected result
{
writeln((i, j, k));
}
}
My expected result is something like
(0, 0, 0)
(1, 1, 1)
(2, 2, 2)
(3, 3, 3)
(4, 4, 4)
(5, 5, 5)
(6, 6, 6)
(7, 7, 7)
(8, 8, 8)
(9, 9, 9)
which is obtained with Line (2) above. But if I use Line (1), it gives an unexpected result like
(0, 0, 1)
(0, 1, 0)
(0, 2, 0)
...
(9, 7, 0)
(9, 8, 0)
(9, 9, 1)
So I am wondering if I am erroneously using i == j == k?
(FYI, the above code is motivated by some Python code like
for i in range(10):
for j in range(10):
for k in range(10):
if i == j == k:
print( i, j, k )
which gives (0, 0, 0), (1, 1, 1), ...)

Answer 1

Right on, #Someprogrammerdude.
== is a binary operator, it is left-associative. The documentation is here:
https://chapel-lang.org/docs/language/spec/expressions.html#precedence-and-associativity
When comparing the boolean (i==j) with the integer k (in the context of i==j==k), the boolean is implicitly converted to an integer and an integer equality check is performed.

Answer 2

FWIW, these are results that I got from other languages (but my usage of each language may be wrong, so please take it as such...).
C++
#include <iostream>
using namespace std;
int main() {
int i = 2, j = 2, k = 2;
cout << (i == j == k) << endl;
}
// => 0 (false), probably by interpreting it as (i == j) == k
Chapel
var i, j, k = 2;
writeln( i == j == k );
// => false (same as C++)
D
import std.stdio;
void main() {
int i = 2, j = 2, k = 2;
writeln( i == j == k );
}
// => Error: found == when expecting ) (and some related messages)
Rust
fn main() {
let i = 2;
let j = 2;
let k = 2;
println!( "{:?}", i == j == k );
}
// => Error
error: chained comparison operators require parentheses
--> test.rs:6:25
|
6 | println!( "{:?}", i == j == k );
| ^^^^^^^^^
error[E0308]: mismatched types
--> test.rs:6:33
|
6 | println!( "{:?}", i == j == k );
| ^ expected bool, found integer
|
Scala (here ">" is REPL)
> var i = 2
> var j = 2
> var k = 2
> i == j == k
^
warning: comparing values of types Boolean and Int
using `==` will always yield false
res0: Boolean = false
Kotlin
> var i = 2
> var j = 2
> var k = 2
> i == j == k
error: operator '==' cannot be applied to 'Boolean' and 'Int'
i == j == k
Nim
var i = 2
var j = 2
var k = 2
echo( i == j == k )
=> Error: type mismatch: got <bool, int>
but expected one of:
proc `==`(x, y: bool): bool
first type mismatch at position: 2
required type for y: bool
but expression 'k' is of type: int
expression: i == j == k
Python
> i = 2
> j = 2
> k = 2
> i == j == k
True
Julia
> i = 2
> j = 2
> k = 2
> i == j == k
true
So, apart from Python and Julia (which are dynamically typed so might be a bit different thing), it seems that more lately developed statically typed languages tend to give a warning (or even an error) against the use of i == j == k. So, if Python users may be likely to use Chapel, I guess it might be helpful (for the user) to give some warning (or even an error?) message.