Bug 11148 – Can't implicitly convert const(BigInt) or immutable(BigInt) to BigInt

Created attachment 1253 Can't pass const(BigInt) to a function taking a BigInt argument. const(BigInt) or immutable(BigInt) objects can't be assigned/implicitly converted to mutable BigInt values. The attached code gives examples where a const or immutable BigInt is passed to a function taking a (mutable) BigInt argument.

Created attachment 1254 Can't pass immutable(BigInt) to function taking a BigInt argument.

Created attachment 1260 Third example, which tests implicit, explicit and cast-based conversion In fact, there is no reliable way to convert from a qualified BigInt type to an unqualified one. The 3rd code example attached shows attempted conversion through both implicit conversion (simple assignment) and explicit (trying both std.conv.to and cast).

Is this really a bug? BigInt is implemented as a reference type, so allowing a cast from const(BigInt) to BigInt would be a bug.

I think it's an issue that you can't pass an immutable(BigInt) to a function that accepts a BigInt as input. This makes it difficult to e.g. write generic functions that work with any integer type. I'm not sure what the appropriate way to deal with that is, though.

You can't pass an immutable(BigInt) to a function that takes unqual BigInt, because that breaks the type system (and risks breaking immutability). The function needs to take const(BigInt) if it doesn't need to propagate qualifiers to its return type, or inout(BigInt) if it does. If the function needs to modify the BigInt, then it should rightly reject any attempt to pass in an immutable BigInt.

(In reply to comment #5) > If the function needs to modify the BigInt, then it should rightly reject any > attempt to pass in an immutable BigInt. Well, suppose you have some function of the form, T foo(T)(T n) { Unqual!T a = n; // ... do mutable stuff with a return a; } That still won't work if T is an immutable(BigInt), because the first line will fail: you can't copy from the immutable to mutable.

BigInt must behave essentially exactly like every other integral type (except for having a larger range of possible values), which includes being a value type. Any internal COW implementation must be invisible to users.

Seems fixed: https://github.com/D-Programming-Language/phobos/compare/cc52695e4a15...9a93d82e9924

Fixed: https://github.com/D-Programming-Language/phobos/commit/9a93d82e9924a39b9f1f9cade1ec03b84bbfe376