tuple cast for use defined classes

[asadchev]

The following patch allows to typecast user-defined tuple classes as tuple using tuple_caster
eg,

  template<typename First, typename Second>
  struct Pair;

  struct Struct { int first, float second };

  template <typename First, typename Second>
  struct type_caster< Pair<First,Second> >
    : tuple_caster<Pair<First,Second>, First, Second> {};


  template<>
  struct type_caster<Struct>
  : tuple_caster<Struct, int, float> {};

Patch to enable this hack

--- a/python/pybind11/include/pybind11/cast.h
+++ b/python/pybind11/include/pybind11/cast.h
@@ -623,9 +623,9 @@ public:
 };
 
 // Base implementation for std::tuple and std::pair
-template <template <typename...> class Tuple, typename... Ts>
+template <class Tuple, typename... Ts>
 class tuple_caster {
-    using type = Tuple<Ts...>;
+    using type = Tuple;
     static constexpr auto size = sizeof...(Ts);
     using indices = make_index_sequence<size>;
 
@@ -672,11 +672,11 @@ public:
 protected:
     template <size_t... Is>
     type implicit_cast(index_sequence<Is...>) & {
-        return type(cast_op<Ts>(std::get<Is>(subcasters))...);
+        return type{ cast_op<Ts>(std::get<Is>(subcasters))... };
     }
     template <size_t... Is>
     type implicit_cast(index_sequence<Is...>) && {
-        return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...);
+        return type{ cast_op<Ts>(std::move(std::get<Is>(subcasters)))... };
     }
 
     static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
@@ -718,14 +718,14 @@ protected:
         return result.release();
     }
 
-    Tuple<make_caster<Ts>...> subcasters;
+    std::tuple<make_caster<Ts>...> subcasters;
 };
 
 template <typename T1, typename T2>
-class type_caster<std::pair<T1, T2>> : public tuple_caster<std::pair, T1, T2> {};
+class type_caster<std::pair<T1, T2>> : public tuple_caster<std::pair<T1,T2>, T1, T2> {};
 
 template <typename... Ts>
-class type_caster<std::tuple<Ts...>> : public tuple_caster<std::tuple, Ts...> {};
+class type_caster<std::tuple<Ts...>> : public tuple_caster<std::tuple<Ts...>, Ts...> {};
 
 /// Helper class which abstracts away certain actions. Users can provide specializations for
 /// custom holders, but it's only necessary if the type has a non-standard interface.