Hello all, The idea behind is not new and consists in dispatching a call of an interface function to the correct template instance, depending on the runtime or compile time parameters. The field of application is (to me) the release of static/dynamic libraries including functions with a predefined set of types combination. This way, the library (compiled once) can easily be plugged to another framework or a script program (I personally use it with boost.python). An example of use could be (general idea, not a real code of course): // -------------- template <class real_type> int template_function(real_type const& r_class1, double param_d, int& param_out) { // ... return 0; } int interface_function(MyInterface const* i_class1, variant const& param, variant& out) { // return value int return_value; // constructs the dispatcher object with a reference to the values passed to interface_function dispatcher<int, MyInterface const*, variant const&, variant&> dispatch_object(return_value, i_class1, param, out); bool res = dispatch_object.calls_first( fusion::vector_tie( template_function < class_t1 >, template_function < class_t2 > //... ) ); if(res) return return_value; return -1; } // -------------- The dispatch_object tests for the convertibility of each instance ui of the arguments Ui of the interface function, with the corresponding argument Ti of the template function. The type of matching is defined by external objects, with a simple interface providing two methods: a convertibility test and a conversion. The types are "cleaned" in order to have a limited number of conversion structures. Currently this mechanism is used in a generic image processing library. The images have all the same virtual interface and the dispatch calls the correct template function based on the concrete type of the image. It also includes a "back conversion" for Ui's that are non-const reference or pointers. The dispatch mainly makes use of boost.fusion, boost.mpl and boost.function_types. I have checked a little bit the Boost.Vault but, correct me if I am wrong, the current dispatching mechanisms do not address exactly this issue. The code is already open-source released under the boost license. I can put some samples in the Vault if there is any interest. Your comments are very welcome ! Kind regards, Raffi Enficiaud