Modulo Bug?

[bearophile]

> It's a localized but important design bug of languages like C 
> that D has carried over for backward compatibility reasons. D % 
> has caused bugs in my code. I suggest to not use the built-in % 
> on numbers that can be negative,

Better to show an example, reduced from a larger program. This
little function has to look for the next true value in a circular
array 'data', before or after a given starting index, according
to a int 'movement' variable that is allowed to be only +1 or -1:


This is Python code, it correctly performs the wrap-around in all
cases:


def find_next(data, index, movement):
      assert movement == 1 or movement == -1
      while True:
          index = (index + movement) % len(data)
          if data[index]:
              break
      return index

#         0      1      2      3      4     5
data = [False, False, False, False, True, False]
print find_next(data, 5, -1) # OK, prints 4
print find_next(data, 0, -1) # OK, prints 4


The D code doesn't work, because of the C %:


size_t findNext(in bool[] data, size_t index, in int movement)
pure nothrow in {
      assert(movement == 1 || movement == -1);
} body {
      do {
          index = (index + movement) % data.length;
      } while (!data[index]);
      return index;
}

void main() {
      import std.stdio;
      //              0      1      2      3      4     5
      const data = [false, false, false, false, true, false];

      writeln(findNext(data, 5, -1)); // OK, prints 4
      writeln(findNext(data, 0, -1)); // not OK
}


Bye,
bearophile