BigInt bool assign

[bearophile]

Here I ask for opinions about a small enhancement request about BigInt that Don has refused:

http://d.puremagic.com/issues/show_bug.cgi?id=7079

It's not a very important thing, so I will probably avoid further arguing after this post :-)


In some languages like the ones derived from Pascal, like Ada, and in some other languages Java the boolean type is very distinct from the integer values. So to test if a integer value is zero you write something like:


int x = 10;
if (x == 0) {
    // do A ...
} else {
    // do B ...
}


In languages derived from C, like C++ and D and many others, like Python too, the integer values are valid in a boolean context too. This is valid C/C++/D code:

int x = 10;
if (x) {
    // do B ...
} else {
    // do A ...
}



This is handy in some situations, like when you want to count how many true cases there are:


void main() {
    auto s1 = "hello";
    auto s2 = "hallo";
    int hamming_distance = 0;
    assert(s1.length == s2.length);
    foreach (i, c1; s1)
        hamming_distance += c1 != s2[i];
    assert(hamming_distance == 1);
}


While in a Delphi/Java language you need something like:

if (c1 != s2[i])
    hamming_distance++;


The implicit conversion from boolean to integer is equally handy in Python:

s1 = "hello"
s2 = "hallo"
hamming_distance = sum(c1 != c2 for c1,c2 in zip(s1, s2))
assert hamming_distance == 1


D language regards boolean values as a subset of integers so it allows implicit conversion from bool to integer, but not from int to bool. I don't think this will ever change in D2/D3:


void main() {
    int x = 1;
    bool b = true;
    x = b;         // bool -> int is OK
    int y = x > 3; // bool -> int is OK
    b = x;         // int -> bool is an Error
}


While multi-precision numbers are not the fixed size integers, it is wise to give multi-precision numbers the same rules and usages of the normal fixed size integers _everywhere this is possible and handy_. This has some advantages like:
- Reduces the cognitive burden to remember where they differ;
- Allows for less work to adapt routines that work with integers to work with BigInts. This is handy for generic code and for manual translation of code.

I have said everywhere this is possible and handy, because this is not always possible. You can't use a BigInt to index an array, and there are some situations where BigInts require a different algorithm (example: http://d.puremagic.com/issues/show_bug.cgi?id=7102 ). So I am not asking BigInt to be a drop-in replacement for int in all cases.
But I have seen a hundred cases where in Python it's handy to use the built-in multi-precision integers with normal algorithms useful for normal integers too.


So I have asked to allow implicit bool -> BigInt too:


import std.bigint;
void main() {
    BigInt b = true;
}


This allows BigInt to be used as an int in a situation where it causes no harm. Introducing an usage difference here between int and BigInt in my opinion is gratuitous, doesn't help reduce bugs, it asks the programmer to remember one difference between them that gives nothing useful back. So that code should be accepted.

Bye,
bearophile