• Salih Dincer (70/70) Dec 20 2022 I want to have a wrapper structure for the variables I want to
• rikki cattermole (1/1) Dec 21 2022 This may be what you want: https://dlang.org/phobos/std_typecons.html#Pr...
• Salih Dincer (53/55) Dec 22 2022 Thank you, now no need proxy! It's works:

Salih Dincer <salihdb hotmail.com> writes:

I want to have a wrapper structure for the variables I want to 
protect, but in D I can't do it the way I want. It doesn't work 
in W1 Test's constructor, but it works in main():

```d
struct W1(T) {
   private T value;

   alias getset this;

    property T getset(T v)
   {
     return value = v;
   }

    property T getset() inout
   {
     return value;
   }
}

struct W1test {
   W1!int i;

   this(int i) {
     this.i = i;/* doesn't work
     this.i.getset = i; //*/
   }
}

void main()
  {
   import std.stdio;

   W1!int w1;
   w1 = 1;
   w1.writeln;

   auto w1Test = W1test(2);
   w1Test.writeln;
}
```

What do I do when this doesn't work the way I want! I need to 
upgrade to a new version (W2) which I did with opCall():

```d
struct W2(T) {
   private T value;

   alias opCall this;

    property T opCall(T v)
   {
     return value = v;
   }

    property T opCall() inout
   {
     return value;
   }
}

struct W2test {
   W2!int i;

   this(int i) {
     //this.i = i;/* doesn't work
     this.i(i); //*/
   }
}

void main()
  {
   import std.stdio;

   W2!int w2;
   w2 = 2;
   w2.writeln;

   auto w2Test = W2test(3);
   w2Test.writeln;
}
```

Yes except one thing, I don't need to know getset() now and 
everything is as I want:

Why do I need to use parentheses when inside the constructor? 
Because when I'm in main() I can use it like a regular variable!

SDB 79

rikki cattermole <rikki cattermole.co.nz> writes:

This may be what you want: https://dlang.org/phobos/std_typecons.html#Proxy

Salih Dincer <salihdb hotmail.com> writes:

On Wednesday, 21 December 2022 at 15:02:42 UTC, rikki cattermole 
wrote:
 This may be what you want: 
 https://dlang.org/phobos/std_typecons.html#Proxy

Thank you, now no need proxy! It's works:

```d
void main()
{
   import std.stdio;

   auto p1 = Point(1, 2);
   auto p2 = Point(10, 20);
   writeln(p1 + p2);

   class Foo
   {
     NP!Point point;
     this(double x = 0.0, double y = 0.0)
     {
       point = Point(x, y);
     }
   }

   auto foo = new Foo(0.1234, 567.89);
   writeln(foo.point + p2);
}

struct NP(T) { // NP: No Proxy
   private T value;
   this(T x)
   {
     value = x;
   }

   alias opCall this;
    property opCall() inout
   {
     return value;
   }

    property opCall(T x)
   {
     return value = x;
   }
}

struct Point
{
   double x, y;
   pure const nothrow  safe:

   auto opBinary(string op)(in Point rhs)  nogc
   {
     return Point(mixin("x" ~ op ~ "rhs.x"),
                  mixin("y" ~ op ~ "rhs.y"));
   }

   auto opBinary(string op)(int rhs)  nogc
   {
     return Point(mixin("x" ~ op ~ "rhs"),
                  mixin("y" ~ op ~ "rhs"));
   }
}
```