On 3/13/2015 2:20 PM, bearophile wrote:
something like a "var" keyword to denote mutable values,
Transitive const may make this problematic.
I don't understand, but perhaps you misunderstood me. I am talking about
variables. In strict mode they are constant by default. This means in this code
both x and y are immutable:
auto x = 10;
foreach (y; 0 .. 10) {}
So in strict mode if you want them mutable you need a new keyword like "var":
var x = 10;
foreach (var y; 0 .. 10) {}
Given:
mutable int* p;
int* q = p;
q cannot be made immutable. But q can be made const.
static full tracking of memory ownership,
Makes the language significantly more complex.
You are probably right. But it also gives good things back to a system language.
In the last years I've seen that taking twice the time to write my code is a
good deal if later I can avoid wasting stressful hours searching and fixing
bugs. So now I am willing to pay a high price up front when I code to avoid some
bugs later. I have friends that have taken a look at Rust and have dismissed it
for being too much fussy and hard to get code to compile (despite probably with
practice the Rust rules should become quite simpler to follow), but Rust looks
like the right language for me and I'd like the same qualities in the language
that I like more (D). So in the end I don't know what's the best solution for D.
Rust has indeed done a good job selling people on the complexity of their
annotation system. But I think starting with 'return ref' and D's ability to do
inference we're actually in good shape with a far simpler system.
less implicit casts (because now we have the safe int(x) sytnax),
I think D does very well with implicit casts.
I am not sure of that. Implicit casts cause some troubles, you can see this if
you program for a while in a language with no or with very little implicit casts
like Haskell, and F#.
In D we have some implicit casts also because the "cast(int)x" syntax is
dangerous. But now we can write safe casts with the "int(x)" syntax, so there's
less need of naked implicit casts.
Again, too many casts can cause bugs.
I have used languages that did not have implicit casting (Pascal) and didn't
have a positive experience with it. It didn't detect a single actual bug, and
managed to be quite annoying.
Value Range Propagation is a big win.
