Unexpected result from i == j == k?

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.