Is that the expected behavior of the programmer?
Opinions can differ. Feel free to elaborate.

On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.
E.g. length of a string unsigned long.

On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

Elaborate please. Are you really asking if one can do subtraction in D.

On Tuesday, 6 October 2020 at 12:24:56 UTC, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

It's expected behavior:

"If both operands are of integral types and an overflow or underflow occurs in the computation, wrapping will happen. For example, uint.max + 1 == uint.min, uint.min - 1 == uint.max, int.max + 1 == int.min, and int.min - 1 == int.max."

https://dlang.org/spec/expression.html#add_expressions

On 10/6/20 5:24 AM, Alaindevos wrote:
> Is that the expected behavior of the programmer?
> Opinions can differ. Feel free to elaborate.

The following is even more "expected". ;) Subtract zero from -1 and you get size_t.max.

void main() {
  int[] arr;
  int i = -1;

  auto u = (i - arr.length);    // -1 - 0

  assert(u == size_t.max);                   // the surprise
  static assert (is (typeof(u) == size_t));  // the reason
}

Ali

There are two subtractions possible.
A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
A logical one. For the last one higher classes might be needed.

On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

Hello,

You may try https://dlang.org/phobos/std_experimental_checkedint.html in this case.

Regards,

On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

The (signed and unsigned) integer wrap around is well-defined in D, and is architecture independent. That means for example that if a specific architecture does not have a subtract instruction that wraps around according to what D specifies, then the compiler will generate the necessary instructions such that still int.min - 1 == int.max. That's similar to how integer multiplication 'just works' on architectures that do not have a multiply instruction.

-Johan

On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> There are two subtractions possible.
> A machine-one which can be architecture dependent, does not have the same results on all computers, and behaves like a modulus in mathematics.
> A logical one. For the last one higher classes might be needed.

Or use BigInt

On Tuesday, 6 October 2020 at 18:24:14 UTC, Alaindevos wrote:
> A logical one. For the last one higher classes might be needed.

Also assert(5/3==1);