RefCounted

[JG]

Hi,

I would have thought that RefCounted!(T, 
RefCountedAutoInitialize.no) is to be used in place T* when I 
want reference counting instead of the usual garbage collection 
(or manual allocation). Perhaps this is wrong?

If I am correct what am I doing wrong here?

(Sorry for two space squashed style).

```
import std.stdio;
import std.typecons;

struct Node(T) {
   RefCounted!(Node!T, RefCountedAutoInitialize.no) next;
   T val;
}

struct List(T) {
   RefCounted!(Node!T, RefCountedAutoInitialize.no) head;
   bool empty() { return head.refCountedStore.isInitialized; }
   T front() { return head.val; }
   void popFront() { head = head.next; }
   typeof(this) save() { return typeof(this)(head); }
}

void main() {
   List!long l;
}
```
I also tried my own implementation but that is not working (since 
not everything is being freed) and probably
relies on undefined behavior with my casting away inout, which I 
did because
otherwise the compiler kept giving me errors about not being able 
to generate a copy constructor for List.

```
import std.stdio;
import core.stdc.stdlib;


private struct RefCountedPointer(T) {
   static struct Payload(T) {
     long cnt=1;
     T val;
   }
   Payload!T* ptr;
   this(T x) {
     ptr = cast(Payload!T*) calloc(0,Payload!T.sizeof);
     *ptr = Payload!T(1,x);
   }
   ~this() {
     if(ptr==null) { return; }
     (*ptr).cnt--;
     if((*ptr).cnt == 0) {
       ptr.val.destroy();
       free(ptr);
     }
   }
   @disable this(ref return scope immutable(typeof(this)) rhs);
   this(ref return scope inout(typeof(this)) rhs) {
     ptr = cast(Payload!T*) rhs.ptr;
     if(ptr==null) { return; }
     ptr.cnt++;
   }
   void opAssign(typeof(this) rhs) {
     if(this.ptr!=null) { (*this.ptr).cnt--; }
     this.ptr = rhs.ptr;
     if(this.ptr!=null) { (*this.ptr).cnt++; }
   }
   bool isNull() { return ptr==null; }
   ref auto dref() { assert(!isNull); return (*ptr).val; }
}

private struct Node(T) {
   RefCountedPointer!(Node!T) next;
   T val;
}


struct List(T) {
   private RefCountedPointer!(Node!T) head;
   bool empty() { return head.isNull; }
   T front() { return head.dref.val; }
   void popFront()  { head = head.dref.next;  }
   auto save() { return typeof(this)(head); }
   auto insert(T x) {
     head = RefCountedPointer!(Node!T)(Node!T(head,x));
   }
}

void main() {
   List!long list;
   list.insert(8);
import std.stdio;
import core.stdc.stdlib;


private struct RefCountedPointer(T) {
   static struct Payload(T) {
     long cnt=1;
     T val;
   }
   Payload!T* ptr;
   this(T x) {
     ptr = cast(Payload!T*) calloc(0,Payload!T.sizeof);
     *ptr = Payload!T(1,x);
   }
   ~this() {
     if(ptr==null) { return; }
     (*ptr).cnt--;
     if((*ptr).cnt == 0) {
       writeln("free");
       ptr.val.destroy();
       free(ptr);
     }
   }
   @disable this(ref return scope immutable(typeof(this)) rhs);
   this(ref return scope inout(typeof(this)) rhs) {
     ptr = cast(Payload!T*) rhs.ptr;
     if(ptr==null) { return; }
     ptr.cnt++;
   }
   void opAssign(typeof(this) rhs) {
     "here".writeln;
     if(this.ptr!=null) { (*this.ptr).cnt--; }
     this.ptr = rhs.ptr;
     if(this.ptr!=null) { (*this.ptr).cnt++; }
   }
   bool isNull() { return ptr==null; }
   ref auto dref() { assert(!isNull); return (*ptr).val; }
}

private struct Node(T) {
   RefCountedPointer!(Node!T) next;
   T val;
}


struct List(T) {
   private RefCountedPointer!(Node!T) head;
   bool empty() { return head.isNull; }
   T front() { return head.dref.val; }
   void popFront()  { head = head.dref.next;  }
   auto save() { return typeof(this)(head); }
   auto insert(T x) {
     head = RefCountedPointer!(Node!T)(Node!T(head,x));
   }
}

void main() {
   List!long list;
   list.insert(8);
import std.stdio;
import core.stdc.stdlib;


private struct RefCountedPointer(T) {
   static struct Payload(T) {
     long cnt=1;
     T val;
   }
   Payload!T* ptr;
   this(T x) {
     ptr = cast(Payload!T*) calloc(0,Payload!T.sizeof);
     *ptr = Payload!T(1,x);
   }
   ~this() {
     if(ptr==null) { return; }
     (*ptr).cnt--;
     if((*ptr).cnt == 0) {
       writeln("free");
       ptr.val.destroy();
       free(ptr);
     }
   }
   @disable this(ref return scope immutable(typeof(this)) rhs);
   this(ref return scope inout(typeof(this)) rhs) {
     ptr = cast(Payload!T*) rhs.ptr;
     if(ptr==null) { return; }
     ptr.cnt++;
   }
   void opAssign(typeof(this) rhs) {
     "here".writeln;
     if(this.ptr!=null) { (*this.ptr).cnt--; }
     this.ptr = rhs.ptr;
     if(this.ptr!=null) { (*this.ptr).cnt++; }
   }
   bool isNull() { return ptr==null; }
   ref auto dref() { assert(!isNull); return (*ptr).val; }
}

private struct Node(T) {
   RefCountedPointer!(Node!T) next;
   T val;
}


struct List(T) {
   private RefCountedPointer!(Node!T) head;
   bool empty() { return head.isNull; }
   T front() { return head.dref.val; }
   void popFront()  { head = head.dref.next;  }
   auto save() { return typeof(this)(head); }
   auto insert(T x) {
     head = RefCountedPointer!(Node!T)(Node!T(head,x));
   }
}

void main() {
   List!long list;
   list.insert(8);
   list.insert(7);
   list.insert(6);
   list.insert(5);
   list.insert(4);
   list.popFront;
   list.writeln;
   list.insert(4);
   list.insert(3);
   list.insert(2);
   list.insert(1);
   list.writeln;
}