Performance improvements for D / DMD compiler.

[Chris Nicholson-Sauls]

Bill Baxter wrote:
> Walter Bright wrote:
>> Bill Baxter wrote:
>>> The question is how can we write functions in D that take big structs 
>>> as parameters in such a way that it is:
>>> A) efficient and
>>> B) guaranteed not to change the caller's value
>>>
>>> In C++ the answer is const LargeStruct&.
>>
>> C++ doesn't *guarantee* it won't change. There are at least two legal 
>> ways to do it.
> 
> Very true.  What I'm after is really a concise way to both
> a) document to readers of the code that it won't change and
> b) get the compiler to zap me if I accidentally try to modify it.
> 
>>> In D the answer is...
>>
>> There aren't const references in D. But the 3 ways to pass it by 
>> pointer are:
>>
>> 1) inout
>> 2) take the address and use a pointer
>> 3) make it a class instead
> 
> And none of those accomplishes a or b.
> 
> --bb

Just a thought: B) can be accomplished with an Interface that only exposes gettors. 
Granted, though, that 1) it means defining everything you want to be read-only as a 
property, but these would be optimized away by inlining anyhow, 2) you have to write an 
Interface (which isn't a big deal, IMHO, but I know some people can be annoyed with them). 
  Also, you would want to make the implementor class and all methods 'final' to avoid 
potential virtuality overhead.

Something akin to:
<code>
interface IFoo {
   int alpha () ;
   int beta  () ;
}

final class Foo : IFoo {
   private {
     int m_alpha ;
     int m_beta  ;
   }

   int alpha () { return m_alpha ; }
   int beta  () { return m_beta  ; }

   int alpha (int x) { return m_alpha = x ; }
   int beta  (int x) { return m_beta  = x ; }
}

void somefunc (IFoo obj) {
   // do stuff with obj.alpha and obj.beta
}

auto myfoo = new Foo;
somefunc(myfoo);
</code>

-- Chris Nicholson-Sauls