The most awesome "forward to member" solution?

[Andrei Alexandrescu via Digitalmars-d]

Hey folks,

So in working with the allocator, a common matter has come again to the 
fore: I need to forward certain functions to a member. Consider code in 
https://github.com/andralex/phobos/blob/allocator/std/experimental/allocator/free_tree.d:

struct FreeTree(ParentAllocator)
{
    ...

    static if (hasMember!(ParentAllocator, "expand"))
    bool expand(ref void[] b, size_t delta)
    {
        return parent.expand(b, delta);
    }

    static if (hasMember!(ParentAllocator, "reallocate"))
    bool reallocate(ref void[] b, size_t n)
    {
        return parent.reallocate(b, n);
    }

    static if (hasMember!(ParentAllocator, "allocateAll"))
    void[] allocateAll()
    {
        return parent.allocateAll;
    }
}

A simple solution have FreeTree support these functions would be to use 
simple subtyping with alias this. However, I'd like more control than 
that - yes, I want forwarding to work but not accessing the parent 
object directly.

So I'm thinking of defining a mixin that would be used like this:

struct FreeTree(ParentAllocator)
{
    ...
    mixin(forwardIfDefined("parent",
        "expand", "reallocate", "allocateAll"));
}

and, boom, all appropriate forwarding is generated, either with sheer 
definitions or by using opDispatch.

Furthermore, we should probably define this for Phobos because it's a 
common thing people like to do.

Before embarking on this, does anyone have some code around that does 
that kind of stuff?


Andrei