S>>+ к этому у нас есть проект на boost::mpl. Там все на шаблонах .

   template< class Bases, class Derived >
   struct CheckDependencies
   {
   private:
      typedef  typename instantiate_sequence< Bases, Derived > :: type sequence;

      typedef mpl::placeholders::_1 __1;
      typedef mpl::placeholders::_2 __2;
      
      template< class B >
         struct CheckBase
      {
      private:
         template< class R >
            struct CheckRule
               : R::apply< B, sequence, Derived >::type
         {};

         typedef typename Rules< B > rules;

      public:
         typedef typename mpl::fold<rules, mpl::true_, mpl::and_< __1, CheckRule<__2> > > :: type type;
      };

   public:
      typedef typename mpl::fold<sequence, mpl::true_, mpl::and_< __1, CheckBase<__2> > > :: type type;
   };

   namespace details
   {
      template< class APred, class BPred, class Sequence >
         struct Precedes
      {
            static const int size = mpl::size< Sequence >::type::value;

            typedef typename mpl::find_if < Sequence, APred >  :: type Ait;
            typedef typename mpl::find_if < Sequence, BPred >  :: type Bit;

            static const int Aidx = mpl::distance< typename mpl::begin<Sequence>::type, Ait >::type::value;
            static const int Bidx = mpl::distance< typename mpl::begin<Sequence>::type, Bit >::type::value;

            static const bool value = (Aidx == size) || (Aidx < Bidx);

         public:
            typedef mpl::bool_< value > type;
      };
   }

_CheckDependencies _Bases _Derived =
    let
        sequence = instantiate_sequence _Bases _Derived
        -- это что, sequence = zip _Bases _Derived ?
        _CheckBase b =
            let
                _CheckRule r = r b sequence _Derived -- если zip, то зачем сюда снова передавать _Derived ?
                rules = _Rules b
            in
                fold (\_1 _2 -> _1 && _CheckRule _2) True rules
                -- можно было fold (&&) True $ map _CheckRule rules
    in
        fold (\_1 _2 -> _1 && _CheckBase _2) True sequence
        -- то же самое
        -- fold (&&) True $ map _CheckBase sequence

conjunct_map = fold (&&) True . map

template<template<class>class Pred, class Sequence>
struct conjunct_map : mpl::fold<Sequence, mpl::true_, mpl::and_<__1, Pred<__2> > > {};

_Precedes _APred _BPred _Sequence =
    let
        size = length _Sequence
        _Aidx = length $ takeWhile (not _APred) _Sequence
        _Bidx = length $ takeWhile (not _BPred) _Sequence
        value = _Aidx == size || _Aidx < _Bidx
    in
        value

К>_CheckDependencies _Bases _Derived =
К>    let
К>        sequence = instantiate_sequence _Bases _Derived
К>        -- это что, sequence = zip _Bases _Derived ?

К>        _CheckBase b =
К>            let
К>                _CheckRule r = r b sequence _Derived -- если zip, то зачем сюда снова передавать _Derived ?
К>                rules = _Rules b
К>            in
К>                fold (\_1 _2 -> _1 && _CheckRule _2) True rules
К>                -- можно было fold (&&) True $ map _CheckRule rules
К>    in
К>        fold (\_1 _2 -> _1 && _CheckBase _2) True sequence
К>        -- то же самое
К>        -- fold (&&) True $ map _CheckBase sequence
К>

_Derived :: Class

_Bases :: [Class -> Class]

instantiate_sequence :: [Class -> Class] -> Class -> [Class]
instantiate_sequence b d = map (\x -> x d) b

К>conjunct_map = fold (&&) True . map
К>

К>template<template<class>class Pred, class Sequence>
К>struct conjunct_map : mpl::fold<Sequence, mpl::true_, mpl::and_<__1, Pred<__2> > > {};
К>

К>_Precedes _APred _BPred _Sequence =
К>    let
К>        size = length _Sequence
К>        _Aidx = length $ takeWhile (not _APred) _Sequence
К>        _Bidx = length $ takeWhile (not _BPred) _Sequence
К>        value = _Aidx == size || _Aidx < _Bidx
К>    in
К>        value
К>

S>_Derived :: Class

S>_Bases :: [Class -> Class]

S>instantiate_sequence :: [Class -> Class] -> Class -> [Class]
S>instantiate_sequence b d = map (\x -> x d) b
S>

#define TN(...) typename __VA_ARGS__::type
#define TV(...) __VA_ARGS__::type::value

template<class S, class Pred>
struct cspan : mpl::distance<TN(mpl::begin<S>), TN(mpl::find_if<S,Pred>) {};
// по аналогии с strspan (including), strcspan (excluding)

template<class S, class PA, class PB>
struct precede_or_pass
{
private:
    typedef mpl::size<S> size;
    typedef cspan<S,PA> cspanA;
    typedef cspan<S,PB> cspanB;
public:
    typedef mpl::bool_< TV(cspanA)==TV(size) || TV(cspanA)<TV(spanB) > type;
};

E>ИМХО на RT C++ это написать на-а-а-амного просще

class Foo : public Bar1<Foo>, public Bar2<Foo>, ...., public BarN<Foo> // дофига баз и миксинов
{};
// заменяем на
class Foo : derive_from< mpl::vector<Bar1, Bar2, ...., BarN> >
{};