> To make a type "double linkable" the developer needs to mixin the following mixin template:
>
>> mixin template DoubleLinkable()
>> {
>> typeof(this) next;
>> typeof(this) prev;
>> }
>
>
> The next and prev pointer can be access with the help of mixin by using the following templates:
>
>> T* next(T, string name)(T node) pure nothrow const
>>
>> {
>>
>> mixin("return &(node." ~ name ~ ".next);");
>>
>> }

These are free functions? Why not put them in the mixin templates?

They are actually part of the DoubleLinkedList template but I put them as free functions because it is easier to read. My motivation for putting them in the DoubleLinkedList template and class is because they are part of the Container logic. For example they may need to be synchronized if you want a concurrent data structure.

> To use the above abstraction the developer just needs to do the following:
>
>> class Person
>> {
>> int age;
>> int weight;
>> mixin DoubleLinkable people;
>> }

Oh, named mixins! Yet another D feature I totally forgot. Hey, those reading this, who here knew you could do 'mixin someTemplate someName;' to refer to the template scope by the given name?

> I am not a big fan of the template signature 'class DoubleLinkedList(T, string name)' but I couldn't figure out a better way of allowing one object to be embedded in multiple containers. Thoughts? Any idea how this can be improved so that it is easier to use and read?

I didn't read the blog post, but any reason why you do not put all the list machinery in a mixin template and refer directly to next/prev?

I think I answer this above.

I'm on a pad, so typing is not so easy, but like this:

mixin template NodeImplementation()
{
    // should detect if typeof(this) is a reference type or a value type.
    // for a reference type, we should not use pointers.
    typeof(this) next() @property { return *_next;}
    typeof(this) prev() @property { return *_prev;}
/// + setters also
    private *typeof(this) _next,_prev;
}

struct Person()
{
    mixin NodeImplementation;
    string name;
    int age;
}

And DoublyLinkedList(Node) if (isNode!Node)

with

/**
A node is a type T that has .next and .prev fields
that return another T.
*/
isNode(T)
{
    enum isNode = __traits(compiles, { T p = T.init.prev; T n = T.init.next;});
}

Yep. DoubleLinkedList should have a template constraint but I didn't want to add to many D features as I plan to post this as a comment in the blog. All the C/C++ would have a harder time understanding the D code. ;)

Thanks!

-Jose