Getting consistent behavour for class properties

[mikey via Digitalmars-d-learn]

Hi,

I'm experimenting with the behaviour of properties in D, as I am 
writing some classes that are being used in a mixture of const 
and non-const functions.

I've found a couple of things that I'd just like to check. First 
perhaps I should say what I would expect from working with 
properties in a mixed const / non-const environment.

* I expect getting a property to work for both const and 
non-const.
* I expect setting a property to only work for non-const.

I found that to get this behaviour I needed to declare any getter 
return type as well as the property function as "inout". This 
seemed to work for getter / setter function pairs as well as the 
"@property auto ref" idiom.

I also noticed something that was unexpected to me as a beginner, 
that the getter / setter pairs are not valid with the "+=" 
operator but the "auto ref" is. I guess this is down to the way D 
interprets the syntax during compilation and the differences 
between how the 2 different implementations access the data. But 
it is none the less surprising that the flowing are not 
syntactically equivalent.

     t.val = t.val + 1;
     t.val += t.val;

Anyway here is my test code:

     module test;

     class Test {
     private:
         int _val;

     public:

         @property inout(int) val() inout {
             return _val;
         }

         @property void val(int val) {
             _val = val;
         }

         @property auto ref inout(int) val2() inout {
             return _val;
         }
     }

     void test(Test t) {
         import std.stdio : writeln;
         writeln("--- test ----");
         writeln("val: ", t.val);
         writeln("val2: ", t.val2);
     }

     void test2(in Test t) {
         import std.stdio : writeln;
         writeln("--- test 2 ----");
         writeln("val: ", t.val);
         writeln("val2: ", t.val2);
     }

     void main() {

         auto t = new Test;
         //t.val += 100; // BAD - not an lvalue
         t.val = t.val + 100;
         test(t);
         t.val2 += 100; // OK
         test2(t);
     }