Getting the const-correctness of Object sorted once and for all

[era scarecrow]

On Tuesday, 15 May 2012 at 21:18:11 UTC, Chad J wrote:
> On 05/15/2012 03:32 PM, Chris Cain wrote:
>> On Tuesday, 15 May 2012 at 18:07:12 UTC, Chad J wrote:
>>> An idea I thought of is to introduce a method local 
>>> declaration that
>>> allows a method to access instance-specific-state that isn't
>>> accessible to the rest of the class:
>>
>> This is an interesting idea (as it seems to really try to keep
>> the state changes internal to the function, which can be seen  
>> as
>> how D handles purity)... however, it breaks the point of 
>> purity due to
>> this:
>>
>> pure nothrow hash_t toHash() const {
>> @instance hash_t bad = 0;
>> ++bad;
>> return hashfn(field) + bad;
>> }
>>
>> Now it violates everyone's definition of purity and we can no
>> longer make our sweet optimizations and reasoning about the  
>> code.
>> Sure, we could "trust the programmers to not do this" ... but
>> that's another debate entirely.
>
>
> Yes.  I intend to "trust the programmers to not do this".
>
> Otherwise we need to find some way to ensure that a function 
> that alters external state will always return the same value as 
> long as the rest of the program doesn't change the state it 
> looks at.
>
>>
>> ... and setting toStringCacheValid to true in toString violates
>> const, so this is absolutely not allowed. Sorry.
>>
>
> Yep, ya got me.
>
>>
>> Maybe there's a solution, but I doubt the solution is something
>> the programmer can/should do completely transparently.

  I think I have an answer. It came to me last night when I was 
going to sleep. Anyways, it may be a little verbose but I Hope I 
got it all right. Oddly enough it stays within D's own rules :)

--

import std.stdio;
import std.conv;

struct CachedHash(T) {
   T element;
   uint hash;
   alias element this;

   this(T inVal) {
     element = inVal;
   }

   @property uint toHash(){
     if(!hash) {
       writeln("Hashing!");
       hash = element.toHash();
     } else
       writeln("From Cache!");
     return hash;
   }
}

uint toHash(string x){
   return 123456; //for example
}

class AString {
   string str;

   this(string s) {
     str = s;
   }

   const uint toHash(){
     return 123456;
   }
}

uint calledHash(T)(T as){
   return as.toHash();
}

int main() {
   immutable char[] s = "this is a test!";

   auto ch_s = CachedHash!string(s);  //since s is inherently 
immutable..

   writeln(s);
   writeln(s.toHash, "\n");

   writeln(ch_s);
   writeln(ch_s.toHash);
   writeln(ch_s.toHash, "\n");

   AString as = new AString(s);
   immutable AString ias = cast(immutable AString) new AString(s);

   auto as_s = CachedHash!AString(as);
   auto ias_s = CachedHash!(immutable AString)(ias);

   writeln(as.toHash, "\n");
   writeln(as_s.toHash);
   writeln(as_s.toHash);
   writeln(ias_s.toHash);
   writeln(ias_s.toHash, "\n");

   writeln(calledHash!AString(as_s)); //non-CachedHash aware 
simulate
   writeln(calledHash!(typeof(as_s))(as_s));

   return 0;
}