Escaping the Tyranny of the GC: std.rcstring, first blood

[Rikki Cattermole via Digitalmars-d]

> The one wrinkle is that you need to wrap string literals "abc" 
> with explicit constructor calls, e.g. RCString("abc"). This 
> puts RCString on a lower footing than built-in strings and 
> makes swapping configurations a tad more difficult.

A few ideas:

import std.traits : isSomeString;
auto refCounted(T)(T value) if (isSomeString!T) {
	static if (is(T == string))
		return new RCXString!(immutable char)(value);
	//....
	static assert(0);
}

static assert("abc".refCounted == "abc");

Wrapper type scenario. May look nicer.

Other which would require a language change of:

struct MyType {
  string value;
  alias value this;

  this(string value) {
   this.value = value;
  }
}

static assert("abc".MyType == "abc");

*shudder* does remind me a little too much of the Jade 
programming language with its casts like that.

There is one other thing which I don't think people are taking 
too seriously is my idea of using with statement to swap out e.g. 
the GC during runtime.

with(myAllocator) {
  Foo foo = new Foo; // calls the allocator to assign memory for 
new instance of Foo
}
// tell allocator to free foo

with(myAllocator) {
  Foo foo = new Foo; // calls the allocator to assign memory for 
new instance of Foo
  myFunc(foo);
}
// if myFunc modifies foo or if myFunc passes foo to another 
function then:
//  tell GC it has to free it when able to
// otherwise:
//  tell allocator to free foo

class MyAllocator : Allocator {
  void opWithIn(string file = __MODULE__, int line = __LINE__, 
string function = ?) {
   GC.pushAllocator(this);
  }

  void opWithOut(string file = __MODULE__, int line = __LINE__, 
string function = ?) {
   GC.popAllocator();
  }
}

By using the with statement this is possible:
void something() {
  with(new RCAllocator) {
   string value = "Hello World!"; // allocates memory via 
RCAllocator
  } // frees here
}