What guarantees does D 'const' provide, compared to C++?

[Chris Cain]

On Friday, 17 August 2012 at 03:42:23 UTC, Mehrdad wrote:
> Yes, I 100% realize 'pure' and 'immutable' are advantages over 
> C++.
> The question was about 'const' by itself, though, because 
> otherwise that's not a fair comparison. (The goal is comparing 
> C++ const to D const, not C++ const to D const + immutable + 
> purity.)

I don't know what to tell you then. If you have a non-const pure 
function and add const to it, then you can make all kinds of 
optimizations for free basically. But, as you've found, if you 
completely ignore purity, you can find some ways around that and 
the compiler would have to potentially perform some expensive 
checks to do the same optimizations (unless they're just not 
valid).

You can probably do more optimizations on primitive types easier 
(but they obviously have their own limitations), but many of 
those same optimizations could potentially be done on C++'s const 
primitives as well. But really, the biggest differentiation 
between C++'s const and D's const comes in to play with 
non-primitives. C++'s const on classes, for instance, gives you 
_no_ guarantees (none, at all, unless you dive into the class and 
take a close look) and therefore _no_ optimizations without major 
costly calculations and certainly no easy reasoning.

OTOH, D's const does give you guarantees. Combine that with pure 
and you've got huge amounts of reasoning. And yes, I'd say this 
answers your topic's question on what D's const does for you. 
Clearly, a pure function without const doesn't provide you with 
the same reasoning as a pure function with const.

writeln(s.pureMutatingFunc());
writeln(s.pureMutatingFunc()); // guaranteed not to change 
globals ... restricted to only changing s and, transitively, 
everything s points to

const: Prevents changing s and, transitively, everything s points 
to (through the s view, of course ... doesn't say anything about 
global data or other views available to you because of global 
data, as you've found).

ergo, we can do this:

writeln(s.pureConstFunc());
writeln(s.pureConstFunc()); // definitely the same as above call


Now an impure function can modify globals, so it shouldn't 
surprise you that if s has a pointer to a global, you can modify 
the global and therefor the view s represents will also have a 
change.