class WidgetFactory{
public:
  virtual Window* CreateWindow() =  0 ;
  virtual Button*  CreateButton() =  0 ;
  virtual Scroller* CreateScroller() =  0 ;
};

typedef Abstractactory<Window, Button, ScrollBar> WidgetFactory;

template<class T>
T* MakeWidget( WidgetFactory& factory )
{
  T* pW = Factory.Create<T>();
  pW->SetColor( RED );
  return pW;
}

//  а вот и он список типов
template<class T, class U>
struct TypeList{
  typedef T head;
  typedef U tail;
};

typedef typelist<float, typelist<double, long double> >
    floating_point_types;

typedef cons<float, double, long double>::type
    floating_point_types;

template <class tlist> class AdHocVisitor;

template <class H, class T>
class AdHocVisitor< typelist<H, T> > 
    : public AdHocVisitor<T> // рекурсия
{
public:
    using AdHocVisitor<T>::Visit;
    virtual void Visit(H*) =  0 ;
    template <class SomeClass>
    void StartVisit(SomeClass* p)
    {
        if (H* pFound = dynamic_cast<H*>(p))
        {
            Visit(pFound);
        }
        else
        {
            AdHocVisitor<T>::StartVisit(p);
        }
    }
};

// остановка рекурсии
template <class H>
class AdHocVisitor< typelist<H, null_typelist> > 
{
public:
    virtual void Visit(H*) =  0 ;
    template <class SomeClass>
    void StartVisit(SomeClass* p)
    {
        if (H* pFound = dynamic_cast<H*>(p))
        {
            Visit(pFound);
        }
        else
        {
            throw "Unknown type passed";
        }
    }
};

int main()
{
    typedef cons<TextArea, VectorGraphics,
        Bitmap>::type MyHierarchy;
    Graphics *p = new Bitmap;
    struct ConcreteVisitor : AdHocVisitor<MyHierarchy>
    {
        void Visit(TextArea* p) 
        {
            ... 
        }
        void Visit(VectorGraphics* p) 
        {
            ... 
        }
        void Visit(Bitmap* p) 
        {
            ... 
        }
    };
    ConcreteVisitor visitor;
    visitor.StartVisit(p);
}

// отрывок из билиотеки LOKI
    template <class TList, typename R>
    class BaseVisitorImpl
        : public Visitor<typename TList::Head, R>
        
        , public Private::BaseVisitorImplHelper
          <
            typename TL::is_Typelist<typename TList::Tail>::type_tag
          >
          ::template In<typename TList::Tail, R>::Result
    {
        ASSERT_TYPELIST(TList);

    public:
        // using BaseVisitorImpl<Tail, R>::Visit;

        virtual R Visit(typename TList::Head&)
        { return R(); }
    };

typedef cons<TextArea,VectorGraphics,Bitmap>::type MyHierarchy;

//вот обычная обощенная фабрика
template
<
  class AbstractProduct, // базовый класс иерархии
  typename IdentifierType, // GUID имеет отношение порядка для std::map
  typename ProductCreator //  функтор создающий AbstractProduct
>
class Factory
{
public:
  bool Register( const IdentifierType& id, ProductCreator creator )
  {
    return asociations_.insert(
              AssocMap::value_type( id, creator)
                                      ).second;
  }
  bool Unregistered( const IdentifierType& id )
  {
    return asociations_.erase( id ) ==  1 ;
  }
  AbstractProduct* CreateObject( const IdentifierType& id )
  {
    typename AssocMap::const_iterator i = asociations_.find(id);
    if( i != asociations_.end() )
    {
      return ( i->second )();
    }
    // обработка ошибок пропущена
  }
private:
  typedef std::map< IdentifierType, AbstractProduct > AssocMap;
  AssocMap asociations_;
}

template <typename T>
struct Type2Type
{
  typedef T OriginalType;
};

template < class T >
class AbstractFactoryUnit
{
public:
  virtual T* DoCreate( Type2Type<T> =  0  );
  virtual ~AbstractFactoryUnit() {};
};

template
<
  class TList, // список типов из которых генерируется иерархия
  template <class> class Unit = AbstractFactoryUnit
>
class AbstractFactory : public GenScatterHierarchy<TList, Unit>
{
public:
  typedef TList ProductList;
  template <class T> T* Create()
  {
    Unit<T>& unit = *this;
    return unit.DoCreate( Type2Type<T>() );
  }
};

// Example 1(a): Calling a nonmember function
//
string AppendA( string s ) { return s + 'a'; }
 
string test = "test";

// Making an immediate call is easy:
//
cout << AppendA( test ) << endl;             // immediate call

// Making a delayed call involves storing a pointer
// (or reference) to the function:
//
typedef string (*F)( string ); 
F f = &AppendA;                               // select function...
// ... later...
cout << f( test ) << endl;                    // ... make delayed call

// Example 1(b): Calling a member function
//
class B {
public:
  virtual string AppendB( string s ) { return s + 'b'; }
};

class Derived : public B {
  string AppendB( string s ) { return s + "bDerived"; }
};
 
string test = "test";
B b;
Derived der;

// Making an immediate call is easy:
//
cout << b.AppendB( test ) << endl;            // immediate call

// Making a delayed call involves storing a pointer
// (or reference) to the member function, and requires
// some appropriate object to call it on:
//
typedef string (B::*F)( string );
F f = &B::AppendB;                            // select function...
// ... later...
cout << (b.*f)( test ) << endl;               // ... make delayed call
cout << (der.*f)( test ) << endl;             // ... another delayed call,
                                              //   virtual dispatch works

/ Example  1 (b), continued: Alternative, using binders
//
typedef binder1st<mem_fun1_t<string,B,string> > F2;
F2 f2 = bind1st( mem_fun( &B::AppendB ), &b ); 
// ... later...
cout << f2( test ) << endl;                   // ... make delayed call

f2 = bind1st( mem_fun( &B::AppendB ), &der );
// ... later...
cout << f2( test ) << endl;                   // ... another delayed call,
                                              //  virtual dispatch works

// определим функтор, который будет "конфликтовать" с нашим решением
class C {
public:
  string operator()( string s ) { return s + 'c'; }
};
 
string test = "test";
C c;

// Making an immediate call is easy:
//
cout << c( test ) << endl;                    // immediate call

// Making a delayed call is trickier. There's no easy way without
// fixing the type of the object as a C, such as by taking a C&...:
//
typedef C& F;
F f = c;                                      // select functor...
// ... later...
cout << f( test ) << endl;                    // ... make delayed call

...

// пример конфликта
class Name {
public:
  Name( string s ) : s_( s ) { }
  string Get() const { return s_; }

private:
  string s_;
};

// Stubbed-in function to demonstrate varying
// parameter and return types:
const char* AppendD( const Name& s ) {
  static string x;
  x = s.Get() + 'd';
  return x.c_str();
}
 
string test = "test";

// Making an immediate call is still easy:
//
cout << AppendD( test ) << endl;              // immediate call

// But the typedef from Example 1(a) no longer works,
// even though the rest of the call is unchanged:
//
typedef string (*F)( string ); 
F f = &AppendD;                               // error: type mismatch
// ... later (in our dreams)...
cout << f( test ) << endl;                    // ... never get here

// Example 1(e): One function<> to bring them all,
// and flexibly to bind them
//
// This code uses the same class and function definitions
// from Examples 1(a) through (d)
//
string test = "test";
B b;
Derived der;
C c;

function<string (string)> f;                  // can bind to anything that
                                              // takes and returns a string
f = &AppendA;                                 // bind to a free function
cout << f( test ) << endl;

f = bind1st( mem_fun( &B::AppendB ), &b );
cout << f( test ) << endl;// bind to a member function
f = bind1st( mem_fun( &B::AppendB ), &der );
cout << f( test ) << endl;                    // with virtual dispatch

f = c;                                        // bind to a functor
cout << f( test ) << endl;

f = &AppendD;                                 // bind to a function with a
cout << f( test ) << endl;                    // different but compatible signature

function<int (int x, int y)> arithmetic_operation(char k)
{
  switch (k) {
    case '+': return plus<int>();
    case '-': return minus<int>();
    case '*': return multiplies<int>();
    case '/': return divides<int>();
    case '%': return modulus<int>();
    default: assert( 0 );
  }
}

typedef cons<Graphics, Bitmap, TextArea> MyIerarhy;