raii

[Ellery Newcomer]

Hello

The impetus:

> I agree, except I more and more think that scope classes were a mistake. Structs with destructors are a much better solution, and wrapping a class inside a struct would give it RAII semantics.

The problem:

In designing a library (or rather touching up someone else's library), I 
have a class (interface?) Foo, and it has a method close (actually 
several methods). Almost invariably (although conceivably not always), 
usage involves manipulating Foo, and then remembering to call close. 
That last part is obnoxious.

One obtains a Foo from function foo.

What I'd like is for the result of foo to have RAII semantics by 
default, with the possibility of nixing it if the user actually cares.

I want to take the burden of remembering that stupid close off the user.

For example:

void bar(){
   auto a = foo();
   a.doStuff();
}

has an implicit call to close after doStuff.

The impetus suggests I can do this by wrapping Foo inside a struct, but 
I'm not so sure how well this would work out. Also note that close can 
fail in a number of ways relating to file io.

So I wrote up a simple prototype.

Thoughts?




import std.stdio;
class Foo{
     int k;
     this(int i){
	writefln("bin %d",k);
	k = i;
     }
     void doStuff(){
	writefln("do stuff %d",k);
     }
     void close(){
	writefln("close %d",k);
     }
}
struct RAII(T){
     T b;
     bool extracted = false;
     alias b this;
     this (T i){
	assert(i !is null);
	writeln("in");
	b = i;
     }
     ~this(){
	writeln("~this");
	if(!extracted) b.close();
     }
     T extract(){
	assert(!extracted);
	T t = b;
	b = null;
	extracted = true;
	return t;
     }
}
RAII!(Foo) foo(int i){
     return RAII!(Foo)(new Foo(i));
}
void main(){
     auto a = foo(1);
     auto b = foo(2).extract();
     a.doStuff();
     b.doStuff();
}