How to make a transparent wrapper type?

Random D user via Digitalmars-d-learn digitalmars-d-learn at
Mon Dec 7 11:13:20 PST 2015

I kind of miss reference values on stack, so I attempted to make 
one in a struct.
Pointers are pretty good (since d doesn't have ->), but it would 
be nice to avoid dereferencing them explicitly on assignment.

Since reference is a pointer that you can't change afterwards.
I tried something like this:

struct RefVal( T )
     this( T* val )                      {   ptr = val;  }

     ref auto opAssign( T value )        {   *ptr = value; return 
*ptr;  }
     ref auto opAssign( ref T value )    {   *ptr = value; return 
*ptr;  }

     alias ptr this;
     T* ptr;

This works for most basic cases but breaks in:

struct Foo
     this( int k )
         a = k;

     void opAssign( int k )
         a = k;

     int a;

Foo foo = Foo(2);
Foo baz = Foo(3);
RefVal!Foo bar = RefVal!Foo( &foo );

bar = baz;

bar = 5; // Ooops! doesn't work

Is there a way to transparently pass everything to *RefVal.ptr?

Also is there a way to make "alias ptr this" to work with 
"private T*"?
Ideally I wouldn't want to give access to the ptr, but for now 
it's handy as a workaround.

More information about the Digitalmars-d-learn mailing list