Re: Containers

[bitwise via Digitalmars-d]

On Friday, 4 September 2015 at 23:15:54 UTC, Andrei Alexandrescu 
wrote:
My thinking is that significant work in this(this) is poor D 
style. Eager copying for containers doesn't seem like the best 
way to go. -- Andrei

I would still prefer classes to the embedded RefCounted approach. 
It's more flexible. If a class is used, a user can wrap it in a 
RefCounted if they want, and eventually, if 
http://wiki.dlang.org/DIP74 works out, an extra template 
parameter could be provided to to enable the ref counting for the 
container without changing any of the caller's syntax.

Example:
class List(T, bool refCounted = false) {
    static if(refCounted) {
        // opAddRef(), opRelease(), etc..
    }
}

I think my solution is still the base of something more robust, 
however.
In the following example, all three storage types are allowed:

struct ListBase(T) { } // represents my List(T) as currently 
implemented

enum ListType {
        Stack,
        RefCounted,
        Heap
}

// defaults to RefCounted to avoid eager copying
template List(T, ListType mode = ListType.RefCounted)
{
        static if(mode == ListType.Stack) {
                alias List = ListBase!T;
        }
        else static if(mode == ListType.RefCounted) {
                alias List = RefCounted!(ListBase!T);
        }
        else {
                final class List {
                        ListBase!T _list;
                        alias _list this;
                        
                        this(Args...)(Args args) {
                                _list = ListBase!T(args);
                        }
                }
        }
}

void main(string[] args)
{
	List!int a = [1, 2, 3];                                          
      // ref counted by default
	List!(int, ListType.Stack) b = [1, 2, 3];                    //  
stack allocated
	auto c = new List!(int, ListType.Heap)([1, 2, 3]);    // GC heap 
allocated
}