Inheriting one variadic class from another

[Lindley]

Let's say I have a variadic base class with a pure-virtual function per type:

template <typename ... Types>
class Base;

template <typename T, typename ... Types>
class Base<T,Types...>: public Base<Types...>
{
public:
    using Base<Types...>::doSomething;
    // Stuff relating to T specifically
    virtual void doSomething(const T& arg) = 0;
};

template <typename T>
class Base<T>
{
public:
    void doSomething(const T &arg);
};

Now, I'd like to inherit from it using another variadic class, which provides implementations of doSomething(), but I run into trouble --- where do I indicate it derives from Base?

template <typename ... Types>
class Derived;

template <typename T, typename ... Types>
class Derived<T,Types...>: public Derived<Types...>
// I can't indicate it derives from Base<T,Types...> here, I don't want the diamond problem and I otherwise
// don't need virtual inheritance.
{
public:
    using Derived<Types...>::doSomething;
    // Stuff relating to T specifically
    void doSomething(const T& arg)
    {
        std::cout << arg << std::endl;
    }
};

template <typename T>
class Base<T> // I can't indicate it derives from Base here, I don't have all the types available anymore!
{
public:
    void doSomething(const T& arg)
    {
        std::cout << arg << std::endl;
    }
};

I see two possible approaches. First, virtual inheritance *might* get me what I want, but I don't know how bad a performance hit that might be.

Second, I could do some magic where the full set of types is captured in a tuple at the lowest level and continually passed up, then re-expanded in the base case to indicate Base inheritance. However, I'm not sure if that can be done in an unambigious manner; I can't have two variadic packs at once (Types... and the tuple contents), and I'm not sure if there's a way to use enable_if to check if an arbitrary template type is any kind of tuple.

Any suggestions?