Расширение шаблонных вариационных шаблонов в C ++

Question

Этот вопрос является продолжением моего предыдущего вопроса. Множественные узорные шаблонные шаблоны в C ++ , на которые я получил решение:

#include <array>
#include <iostream>
#include <type_traits>

template <typename T, std::size_t N>
class Vec;

template <std::size_t, typename ...>
struct dimVec;

// ground case for no Vecs: unimplemented for SFINAE failure !
template <>
struct dimVec<0U>;

// ground case with one or more Vecs: size fixed
template <std::size_t N>
struct dimVec<N> : public std::integral_constant<std::size_t, N>
 { };

// first Vec: size detected
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<0U, Vec<T, N>, Ts...> : public dimVec<N, Ts...>
 { };

// another Vec of same size: continue
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<N, Vec<T, N>, Ts...> : public dimVec<N, Ts...>
 { };

// another Vec of different size: unimplemented for SFINAE failure !
template <std::size_t N1, std::size_t N2, typename T, typename ... Ts>
struct dimVec<N1, Vec<T, N2>, Ts...>;

// a not-Vec type: continue
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<N, T, Ts...> : public dimVec<N, Ts...>
 { };

template <typename ... Args>
static constexpr auto dimVecV { dimVec<0U, Args...>::value };

template <std::size_t I, typename T, std::size_t N>
constexpr auto extrV (Vec<T, N> const & v)
 { return v[I]; }

template <std::size_t I, typename T>
constexpr auto extrV (T const & v)
 { return v; }

template <typename T, std::size_t N>
class Vec
 {
   private:
      std::array<T, N> d;

   public:
      template <typename ... Ts>
      Vec (Ts ... ts) : d{{ ts... }}
       { }

      T & operator[] (int i)
       { return d[i]; }

      T const & operator[] (int i) const
       { return d[i]; }
 };


template <std::size_t I, typename F, typename ... Args>
auto applyH2 (F && f, Args ... as)
 { return f(extrV<I>(as)...); }

template <std::size_t ... Is, typename F, typename ... Args>
auto applyH1 (std::index_sequence<Is...> const &, F && f, Args ... as)
   -> Vec<decltype(applyH2<0U>(f, as...)), sizeof...(Is)>
 { return { applyH2<Is>(f, as...)... }; }

template <typename F, typename ... Args, std::size_t N = dimVecV<Args...>>
auto apply (F && f, Args ... as)
 { return applyH1(std::make_index_sequence<N>{}, f, as...); }

long foo (int a, int b)
 { return a + b + 42; }

int main ()
 {
   Vec<int, 3U>  v3;
   Vec<int, 2U>  v2;

   auto r1 { apply(foo, v2, v2) };
   auto r2 { apply(foo, v3, v3) };
   auto r3 { apply(foo, v3, 0)  };

   static_assert( std::is_same<decltype(r1), Vec<long, 2U>>{}, "!" );
   static_assert( std::is_same<decltype(r2), Vec<long, 3U>>{}, "!" );
   static_assert( std::is_same<decltype(r3), Vec<long, 3U>>{}, "!" );

   // apply(foo, v2, v3); // compilation error
   // apply(foo, 1, 2);   // compilation error

 }

Теперь допустим, у меня также есть шаблонный класс.template <typename T, size_t N, size_t M> class mat;, представляющий матрицу NxM, в которой предыдущие Vec эквивалентны столбцам (M) для вещания, теперь я хочу расширить применение, чтобы оно также могло работать с классом Mat без прерыванияобработка только vec.

Правил:

• , если список аргументов содержит матрицу NxM, тогда все матрицы NxM и все векторы должны быть M, и функция вернет NxM matrix
• , иначе правила как ранее для векторов, если список аргументов содержит вектор N, тогда все векторы должны быть N, а функция вернет a N vector

Насколько я могу судить, поскольку функция f() не реализована для матриц, тогда applyH2() должен потерпеть неудачу (если нет, то должен), в его текущем видеПрименить бытерпит неудачу, следовательно, должна быть возможность реализовать еще один apply(), который принимает несколько размеров M и N таким же образом, который будет использоваться, если список аргументов содержит матрицу, и затем будет вызывать extrV<I,J>(as), что для векторовдолжен отображаться как extrV<I,J>(as) -> extrV<J>(as), эта часть выглядит довольно прямо вперед, как доза, реализующая dimMatM и dimMatN таким же образом, как dimVec и такая, что dimMatM отображается на dimVec для векторов.

Однако я не уверен, как заставить эти две версии на apply() работать вместе без ошибок.

Необязательно: Эта часть не очень важна, скажем, что позже у меня есть class tensor<T, N...> расширяет концепцию vec и mat на N измерений, можно ли распространить действие на работу таким образом, чтобы вещание происходило по ведущим измерениям, например

double f(float x, float y);
int main() {
   tensor<float, 2, 4, 6> f246;
   tensor<int, 4, 6> i46;
   tensor<float, 2, 4> f24;

   auto r1 = apply(f, f246, i46); // returns tensor<double, 2, 4, 6>
   // apply(f, f24, f246); // Compile ERROR: dimensions don't match
}

РЕДАКТИРОВАТЬ:

Iтолько что придумал возможное решение или хотя бы его часть, см. ниже

template <size_t ...N>
struct tensor_helper {
template <size_t I, typename T, size_t ...M> static tensorGet(const tensor<T, M...>& V) { return V.v[I % product<M...>::value]; }
template <size_t I, typename T> static tensorGet(const T& V) { return V; }
template <std::size_t I, typename F, typename ...Args>
static auto applyH2 (F && f, Args ...as) -> decltype(f(std::declval<typename base_type<Args>::type>()...))
 { return f(tensorGet<I>(as)...); }
template <size_t ... Is, typename F, typename ... Args>
static auto applyH1(std::index_sequence<Is...> const &..., F && f, Args ... as) -> tensor<decltype(f(std::declval<typename base_type<Args>::type>()...)), N...>
    { return make_tensor<decltype(f(std::declval<typename base_type<Args>::type>()...)), N...>({applyH2<Is>(f, as...)... }); }
}

template <typename F, typename ...Args, size_t ...N = tensorSize<Args...> /* How do I get a list here? */>
auto apply (F && f, Args ... as)
 { return tensor_helper<N...>::applyH1(std::make_index_sequence<product<N...>>{}..., f, as...); }

единственная проблема заключается в том, как получить tensorSize() для предоставления списка димов, хотя я предполагаю, что это соНе следует использовать расширение вручную, если оно реализовано только для векторов и матриц, вместо использования пакетов параметров для dims.

РЕДАКТИРОВАТЬ 2: Полагаю, я могу использовать массив constexpr для вариационного шаблона , чтобы решитьN проблема списка, из моего кода выше.Но я слишком старался, на самом деле попытаться реализовать эту концепцию сегодня вечером попробую завтра.

Answer 1

Если вас все еще интересует решение на основе вариабельного N-мерного tensor<> ... ну ... это кошмар, но кошмар другого типа.

Прежде всего, я подготовилследующая рекурсивная оболочка для std::array

template <typename T, std::size_t ...>
struct tensor;

template <typename T, std::size_t N, std::size_t ... Ns>
struct tensor<T, N, Ns...>
 { 
   using nextT = std::conditional_t<(sizeof...(Ns) > 0U),
                    tensor<T, Ns...>, T>;

   std::array<nextT, N>  value;

   auto const & operator[] (std::size_t i) const
    { return value[i]; }

   auto & operator[] (std::size_t i)
    { return value[i]; }
 };

Функция extrV() теперь рекурсивна и принимает список индексов в std::index_sequence

// scalar case: return value
template <std::size_t ... Is, typename T>
constexpr auto extrV (std::index_sequence<Is...> const &, T const & t)
 { return t; }

// tensor case with lower dimension: skip the first requested index 
template <std::size_t I0, std::size_t ... Is,
          typename T, std::size_t ... Js>
constexpr auto extrV
   (std::index_sequence<I0, Is...> const &, tensor<T, Js...> const & t,
    std::enable_if_t<(sizeof...(Is) >= sizeof...(Js))> * = nullptr)
 { return extrV(std::index_sequence<Is...>{}, t); }

// tensor case with exact dimension: use the first requested index 
template <std::size_t I0, std::size_t ... Is,
          typename T, std::size_t ... Js>
constexpr auto extrV
   (std::index_sequence<I0, Is...> const &, tensor<T, Js...> const & t,
    std::enable_if_t<(sizeof...(Is)+1U == sizeof...(Js))> * = nullptr)
 { return extrV(std::index_sequence<Is...>{}, t[I0]); }

Теперь черты пользовательского типачто, учитывая переменный список типов Args..., извлекает самую длинную общую последовательность индексов (если есть) и возвращает ее внутри std::index_sequence (в случае)

template <typename ...>
struct commonDims;

// ground case: define type as surviving parameter
template <std::size_t I0, std::size_t ... Is>
struct commonDims<std::index_sequence<I0, Is...>>
 { using type = std::index_sequence<I0, Is...>; };

// no tensor type: continue
template <typename IS, typename T0, typename ... Ts>
struct commonDims<IS, T0, Ts...> : public commonDims<IS, Ts...>
 { };

// tensor type: continue with bigger common index list (if any)
template <std::size_t ... Is, typename T, std::size_t ... Js,
          typename ... Ts>
struct commonDims<std::index_sequence<Is...>, tensor<T, Js...>, Ts...>
   : public commonDims<greaterSeqT<std::index_sequence<Is...>,
                                   std::index_sequence<Js...>,
                                   (sizeof...(Is) > sizeof...(Js))>, Ts...>
 { };

template <typename ... Ts>
using commonDimsT = typename commonDims<std::index_sequence<>, Ts...>::type;

Как вы можете видеть, этоиспользует greaterSeq черты типа помощника

template <typename, typename, bool>
struct greaterSeq;

template <typename T1, typename T2>
struct greaterSeq<T1, T2, true> : public gsHelper<T1, T1, T2>
 { };

template <typename T1, typename T2>
struct greaterSeq<T1, T2, false> : public gsHelper<T2, T2, T1>
 { };

template <typename T1, typename T2, bool B>
using greaterSeqT = typename greaterSeq<T1, T2, B>::type;

, которые используют другие gsHelper черты типа помощника

template <typename, typename, typename, typename = std::true_type>
struct gsHelper;

// sequences of different lengths: skipp the first index in longest
template <typename T, std::size_t I0, std::size_t ... Is, std::size_t ... Js>
struct gsHelper<T, std::index_sequence<I0, Is...>,
          std::index_sequence<Js...>,
          std::integral_constant<bool, (sizeof...(Is) >= sizeof...(Js))>>
   : public gsHelper<T, std::index_sequence<Is...>,
                     std::index_sequence<Js...>>
 { };

template <typename T, typename IS>
struct gsHelper<T, IS, IS>
 { using type = T; };

Теперь функция apply()

template <typename F, typename ... Args, typename IS = commonDimsT<Args...>>
auto apply (F && f, Args const & ... as)
 { return applyH1(std::index_sequence<>{}, IS{}, f, as...); }

которые запускают рекурсию вызова между applyH1() и applyH2() функциями

template <std::size_t ... Is, std::size_t ... Js, std::size_t ... Ks,
          typename F, typename ... Args>
auto applyH2 (std::index_sequence<Is...> const &,
              std::index_sequence<Js...> const &,
              std::index_sequence<Ks...> const & ks,
              F && f, Args const & ... as)
   -> tensor<
         decltype(call(std::index_sequence<(Is, 0U)..., 0U, (Ks, 0U)...>{},
                       f, as...)), sizeof...(Js), Ks...>
 { return {{{ applyH1(std::index_sequence<Is..., Js>{},
                      ks, f, as...) ... }}}; }

template <typename IS, typename F, typename ... Args>
auto applyH1 (IS const & is, std::index_sequence<> const &,
              F && f, Args const & ... as)
 { return call(is, f, as...); }

template <typename IS, std::size_t J0, std::size_t ... Js,
          typename F, typename ... Args>
auto applyH1 (IS const & is, std::index_sequence<J0, Js...> const &,
              F && f, Args const & ... as)
 { return applyH2(is, std::make_index_sequence<J0>{},
                  std::index_sequence<Js...>{}, f, as...); }

, которые завершаются вызовом call()

template <typename IS, typename F, typename ... Args>
auto call (IS const & is, F && f, Args const & ... as)
 { return f(extrV(is, as)...); }

Ниже приведен полный пример компиляции

#include <array>
#include <string>
#include <iostream>

template <typename T, std::size_t ...>
struct tensor;

template <typename T, std::size_t N, std::size_t ... Ns>
struct tensor<T, N, Ns...>
 { 
   using nextT = std::conditional_t<(sizeof...(Ns) > 0U),
                    tensor<T, Ns...>, T>;

   std::array<nextT, N>  value;

   auto const & operator[] (std::size_t i) const
    { return value[i]; }

   auto & operator[] (std::size_t i)
    { return value[i]; }
 };

// scalar case: return value
template <std::size_t ... Is, typename T>
constexpr auto extrV (std::index_sequence<Is...> const &, T const & t)
 { return t; }

// tensor case with lower dimension: skip the first requested index 
template <std::size_t I0, std::size_t ... Is,
          typename T, std::size_t ... Js>
constexpr auto extrV
   (std::index_sequence<I0, Is...> const &, tensor<T, Js...> const & t,
    std::enable_if_t<(sizeof...(Is) >= sizeof...(Js))> * = nullptr)
 { return extrV(std::index_sequence<Is...>{}, t); }

// tensor case with exact dimension: use the first requested index 
template <std::size_t I0, std::size_t ... Is,
          typename T, std::size_t ... Js>
constexpr auto extrV
   (std::index_sequence<I0, Is...> const &, tensor<T, Js...> const & t,
    std::enable_if_t<(sizeof...(Is)+1U == sizeof...(Js))> * = nullptr)
 { return extrV(std::index_sequence<Is...>{}, t[I0]); }

template <typename, typename, typename, typename = std::true_type>
struct gsHelper;

// sequences of different lengths: skipp the first index in longest
template <typename T, std::size_t I0, std::size_t ... Is, std::size_t ... Js>
struct gsHelper<T, std::index_sequence<I0, Is...>,
          std::index_sequence<Js...>,
          std::integral_constant<bool, (sizeof...(Is) >= sizeof...(Js))>>
   : public gsHelper<T, std::index_sequence<Is...>,
                     std::index_sequence<Js...>>
 { };

template <typename T, typename IS>
struct gsHelper<T, IS, IS>
 { using type = T; };

template <typename, typename, bool>
struct greaterSeq;

template <typename T1, typename T2>
struct greaterSeq<T1, T2, true> : public gsHelper<T1, T1, T2>
 { };

template <typename T1, typename T2>
struct greaterSeq<T1, T2, false> : public gsHelper<T2, T2, T1>
 { };

template <typename T1, typename T2, bool B>
using greaterSeqT = typename greaterSeq<T1, T2, B>::type;

template <typename ...>
struct commonDims;

// ground case: define type as surviving parameter
template <std::size_t I0, std::size_t ... Is>
struct commonDims<std::index_sequence<I0, Is...>>
 { using type = std::index_sequence<I0, Is...>; };

// no tensor type: continue
template <typename IS, typename T0, typename ... Ts>
struct commonDims<IS, T0, Ts...> : public commonDims<IS, Ts...>
 { };

// tensor type: continue with bigger common index list (if any)
template <std::size_t ... Is, typename T, std::size_t ... Js,
          typename ... Ts>
struct commonDims<std::index_sequence<Is...>, tensor<T, Js...>, Ts...>
   : public commonDims<greaterSeqT<std::index_sequence<Is...>,
                                   std::index_sequence<Js...>,
                                   (sizeof...(Is) > sizeof...(Js))>, Ts...>
 { };

template <typename ... Ts>
using commonDimsT = typename commonDims<std::index_sequence<>, Ts...>::type;

template <typename IS, typename F, typename ... Args>
auto call (IS const & is, F && f, Args const & ... as)
 { return f(extrV(is, as)...); }

template <std::size_t ... Is, std::size_t ... Js, std::size_t ... Ks,
          typename F, typename ... Args>
auto applyH2 (std::index_sequence<Is...> const &,
              std::index_sequence<Js...> const &,
              std::index_sequence<Ks...> const & ks,
              F && f, Args const & ... as)
   -> tensor<
         decltype(call(std::index_sequence<(Is, 0U)..., 0U, (Ks, 0U)...>{},
                       f, as...)), sizeof...(Js), Ks...>
 { return {{{ applyH1(std::index_sequence<Is..., Js>{},
                      ks, f, as...) ... }}}; }

template <typename IS, typename F, typename ... Args>
auto applyH1 (IS const & is, std::index_sequence<> const &,
              F && f, Args const & ... as)
 { return call(is, f, as...); }

template <typename IS, std::size_t J0, std::size_t ... Js,
          typename F, typename ... Args>
auto applyH1 (IS const & is, std::index_sequence<J0, Js...> const &,
              F && f, Args const & ... as)
 { return applyH2(is, std::make_index_sequence<J0>{},
                  std::index_sequence<Js...>{}, f, as...); }

template <typename F, typename ... Args, typename IS = commonDimsT<Args...>>
auto apply (F && f, Args const & ... as)
 { return applyH1(std::index_sequence<>{}, IS{}, f, as...); }

long foo (int a, int b)
 { return a + b + 42; }

int main ()
 { 
   tensor<int, 2, 3, 4, 5>  t0;

   t0[0][0][0][0] = 1;

   using t1 = commonDimsT<tensor<int, 1>, long, tensor<long, 3, 2, 1>, int>;

   static_assert(std::is_same<t1, std::index_sequence<3, 2, 1>>{}, "!");

   auto r1 { apply(foo, tensor<int, 3, 2, 1>{}, 0) };
   auto r2 { apply(foo, tensor<int, 3, 2, 1>{}, tensor<int, 3, 2, 1>{}) };
   auto r3 { apply(foo, tensor<int, 3, 2, 1>{}, tensor<int, 2, 1>{}) };
   auto r4 { apply(foo, tensor<int, 3, 2, 1>{}, tensor<int, 1>{}) };
   auto r5 { apply(foo, 0, tensor<int, 1>{}) };

   static_assert(std::is_same<decltype(r1), tensor<long, 3, 2, 1>>{}, "!");
   static_assert(std::is_same<decltype(r2), tensor<long, 3, 2, 1>>{}, "!");
   static_assert(std::is_same<decltype(r3), tensor<long, 3, 2, 1>>{}, "!");
   static_assert(std::is_same<decltype(r4), tensor<long, 3, 2, 1>>{}, "!");
   static_assert(std::is_same<decltype(r5), tensor<long, 1>>{}, "!");

   // compilation errors (no common tensor)
   //apply(foo, 0, 0);
   //apply(foo, tensor<int, 3, 2, 1>{}, tensor<int, 2>{});
 }

Answer 2

Концептуально очень похоже, но с двумя измерениями становится кошмаром.

Вместо dimVec я предлагаю dimMat с двумя измерениями (N и M) и отказ SFINAE.для неприемлемых случаев (vecs или маты разных размеров, vect с размерами, несовместимыми с матом);не уверен, что все дела управляются, но должно быть что-то вроде

template <std::size_t, std::size_t, typename ...>
struct dimMat;

// ground case for no Vecs and no Mats: unimplemented for SFINAE failure
template <>
struct dimMat<0U, 0U>;

// ground case with one or more Vecs and/or Mats: sizes fixed
template <std::size_t N, std::size_t M>
struct dimMat<N, M>
 { 
   static constexpr std::size_t valN { N };
   static constexpr std::size_t valM { M };
 };

// first Vec: M detected
template <std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, 0U, Vec<T, M>, Ts...> : public dimMat<0U, M, Ts...>
 { };

// first Mat: N and M detected
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, 0U, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// first Mat after a correct Vect: N detected
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, M, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Vec of correct size: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, Vec<T, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Mat of correct sizes: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Vec of different size: unimplemented for SFINAE failure
template <std::size_t N, std::size_t M1, std::size_t M2, typename T,
          typename ... Ts>
struct dimMat<N, M1, Vec<T, M2>, Ts...>;

// another Mat of different sizes: unimplemented for SFINAE failure
template <std::size_t N1, std::size_t N2, std::size_t M1, std::size_t M2,
          typename T, typename ... Ts>
struct dimMat<N1, M1, Mat<T, N2, M2>, Ts...>;

// a not-Vec, not-Mat type: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, T, Ts...> : public dimMat<N, M, Ts...>
 { };

Переменные вспомогательного шаблона просты

template <typename ... Args>
static constexpr auto dimMatN { dimMat<0U, 0U, Args...>::valN };

template <typename ... Args>
static constexpr auto dimMatM { dimMat<0U, 0U, Args...>::valM };

Для apply(), переименован applyM(), я предполагаю что-то как

template <typename F, typename ... Args, std::size_t N = dimMatN<Args...>,
          std::size_t M = dimMatM<Args...>>
auto applyM (F && f, Args ... as)
 { return applyMH1(std::make_index_sequence<N>{},
                   std::make_index_sequence<M>{}, 
                   f, as...); }

Для applyMH1() двух случаев: если N равен нулю, поэтому первый аргумент является пустым индексным списком, мы имеем случай vec

// Vec case: the first index list is empty: call applyH2()
template <std::size_t ... Js, typename F, typename ... Args>
auto applyMH1 (std::index_sequence<> const &,
               std::index_sequence<Js...> const &, F && f, Args ... as)
   -> Vec<decltype(applyH2<0U>(f, as...)), sizeof...(Js)>
 { return { applyH2<Js>(f, as...)... }; }

в противном случае матcase

template <std::size_t ... Is, std::size_t ... Js, typename F,
          typename ... Args>
auto applyMH1 (std::index_sequence<Is...> const &,
               std::index_sequence<Js...> const & js, F && f, Args ... as)
   -> Mat<decltype(applyMH3<0U, 0U>(f, as...)), sizeof...(Is), sizeof...(Js)>
 { return {{{ applyMH2<Is>(js, f, as...) ... }}}; }

Now applyMH2()

template <std::size_t I, std::size_t ... Js, typename F, typename ... Args>
auto applyMH2 (std::index_sequence<Js...> const &, F && f, Args ... as)
   -> std::array<decltype(applyMH3<0U, 0U>(f, as...)), sizeof...(Js)>
 { return {{ applyMH3<I, Js>(f, as...)... }}; }

и applyMH3()

template <std::size_t I, std::size_t J, typename F, typename ... Args>
auto applyMH3 (F && f, Args ... as)
 { return f(extrM<I, J>(as)...); }

с учетом extrM() на основе extrV()

template <std::size_t I, std::size_t J, typename T,
          std::size_t N, std::size_t M>
constexpr auto extrM (Mat<T, N, M> const & v)
 { return v[I][J]; }

template <std::size_t I, std::size_t J, typename T>
constexpr auto extrM (T const & v)
 { return extrV<J>(v); }

Ниже приведен полный пример компиляции

#include <array>
#include <iostream>
#include <type_traits>

template <typename T, std::size_t N>
class Vec;

template <typename T, std::size_t N, std::size_t M>
struct Mat;

template <std::size_t, std::size_t, typename ...>
struct dimMat;

// ground case for no Vecs and no Mats: unimplemented for SFINAE failure
template <>
struct dimMat<0U, 0U>;

// ground case with one or more Vecs and/or Mats: sizes fixed
template <std::size_t N, std::size_t M>
struct dimMat<N, M>
 { 
   static constexpr std::size_t valN { N };
   static constexpr std::size_t valM { M };
 };

// first Vec: M detected
template <std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, 0U, Vec<T, M>, Ts...> : public dimMat<0U, M, Ts...>
 { };

// first Mat: N and M detected
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, 0U, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// first Mat after a correct Vect: N detected
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<0U, M, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Vec of correct size: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, Vec<T, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Mat of correct sizes: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, Mat<T, N, M>, Ts...> : public dimMat<N, M, Ts...>
 { };

// another Vec of different size: unimplemented for SFINAE failure
template <std::size_t N, std::size_t M1, std::size_t M2, typename T,
          typename ... Ts>
struct dimMat<N, M1, Vec<T, M2>, Ts...>;

// another Mat of different sizes: unimplemented for SFINAE failure
template <std::size_t N1, std::size_t N2, std::size_t M1, std::size_t M2,
          typename T, typename ... Ts>
struct dimMat<N1, M1, Mat<T, N2, M2>, Ts...>;

// a not-Vec, not-Mat type: continue
template <std::size_t N, std::size_t M, typename T, typename ... Ts>
struct dimMat<N, M, T, Ts...> : public dimMat<N, M, Ts...>
 { };

template <typename ... Args>
static constexpr auto dimMatN { dimMat<0U, 0U, Args...>::valN };

template <typename ... Args>
static constexpr auto dimMatM { dimMat<0U, 0U, Args...>::valM };

template <std::size_t, typename ...>
struct dimVec;

// ground case for no Vecs: unimplemented !
template <>
struct dimVec<0U>;

// ground case with one or more Vecs: size fixed
template <std::size_t N>
struct dimVec<N> : public std::integral_constant<std::size_t, N>
 { };

// first Vec: size detected
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<0U, Vec<T, N>, Ts...> : public dimVec<N, Ts...>
 { };

// another Vec of same size: continue
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<N, Vec<T, N>, Ts...> : public dimVec<N, Ts...>
 { };

// another Vec of different size: unimplemented !
template <std::size_t N1, std::size_t N2, typename T, typename ... Ts>
struct dimVec<N1, Vec<T, N2>, Ts...>;

// a not-Vec type: continue
template <std::size_t N, typename T, typename ... Ts>
struct dimVec<N, T, Ts...> : public dimVec<N, Ts...>
 { };

template <typename ... Args>
static constexpr auto dimVecV { dimVec<0U, Args...>::value };

template <std::size_t I, typename T, std::size_t N>
constexpr auto extrV (Vec<T, N> const & v)
 { return v[I]; }

template <std::size_t I, typename T>
constexpr auto extrV (T const & v)
 { return v; }

template <std::size_t I, typename T, std::size_t N, std::size_t M>
constexpr auto extrV (Mat<T, N, M> const & v)
 { return 0; }

template <std::size_t I, std::size_t J, typename T,
          std::size_t N, std::size_t M>
constexpr auto extrM (Mat<T, N, M> const & v)
 { return v[I][J]; }

template <std::size_t I, std::size_t J, typename T>
constexpr auto extrM (T const & v)
 { return extrV<J>(v); }


template <typename T, std::size_t N>
class Vec
 {
   private:
      std::array<T, N> d;

   public:
      template <typename ... Ts>
      Vec (Ts ... ts) : d{{ ts... }}
       { }

      T & operator[] (int i)
       { return d[i]; }

      T const & operator[] (int i) const
       { return d[i]; }
 };

template <typename T, std::size_t N, std::size_t M>
struct Mat
 {
   std::array<std::array<T, M>, N> m;

   auto & operator[] (int i)
    { return m[i]; }

   auto const & operator[] (int i) const
    { return m[i]; }
 };


template <std::size_t I, typename F, typename ... Args>
auto applyH2 (F && f, Args ... as)
 { return f(extrV<I>(as)...); }

template <std::size_t ... Is, typename F, typename ... Args>
auto applyH1 (std::index_sequence<Is...> const &, F && f, Args ... as)
   -> Vec<decltype(applyH2<0U>(f, as...)), sizeof...(Is)>
 { return { applyH2<Is>(f, as...)... }; }

template <typename F, typename ... Args, std::size_t N = dimVecV<Args...>>
auto apply (F && f, Args ... as)
 { return applyH1(std::make_index_sequence<N>{}, f, as...); }

template <std::size_t I, std::size_t J, typename F, typename ... Args>
auto applyMH3 (F && f, Args ... as)
 { return f(extrM<I, J>(as)...); }

template <std::size_t I, std::size_t ... Js, typename F, typename ... Args>
auto applyMH2 (std::index_sequence<Js...> const &, F && f, Args ... as)
   -> std::array<decltype(applyMH3<0U, 0U>(f, as...)), sizeof...(Js)>
 { return {{ applyMH3<I, Js>(f, as...)... }}; }

// Vec case: the first index list is empty: call applyH2()
template <std::size_t ... Js, typename F, typename ... Args>
auto applyMH1 (std::index_sequence<> const &,
               std::index_sequence<Js...> const &, F && f, Args ... as)
   -> Vec<decltype(applyH2<0U>(f, as...)), sizeof...(Js)>
 { return { applyH2<Js>(f, as...)... }; }

template <std::size_t ... Is, std::size_t ... Js, typename F,
          typename ... Args>
auto applyMH1 (std::index_sequence<Is...> const &,
               std::index_sequence<Js...> const & js, F && f, Args ... as)
   -> Mat<decltype(applyMH3<0U, 0U>(f, as...)), sizeof...(Is), sizeof...(Js)>
 { return {{{ applyMH2<Is>(js, f, as...) ... }}}; }

template <typename F, typename ... Args, std::size_t N = dimMatN<Args...>,
          std::size_t M = dimMatM<Args...>>
auto applyM (F && f, Args ... as)
 { return applyMH1(std::make_index_sequence<N>{},
                   std::make_index_sequence<M>{}, 
                   f, as...); }

long foo (int a, int b)
 { return a + b + 42; }

int main ()
 {
   Vec<int, 3U>      v3;
   Vec<int, 2U>      v2;
   Mat<int, 2U, 3U>  m23;
   Mat<int, 2U, 4U>  m24;

   auto r1 { applyM(foo, v2, v2) };
   auto r2 { applyM(foo, v3, v3) };
   auto r3 { applyM(foo, v3, 0)  };
   auto r4 { applyM(foo, v3, m23) };
   auto r5 { applyM(foo, m24, 0) };

   static_assert( std::is_same<decltype(r1), Vec<long, 2U>>{}, "!" );
   static_assert( std::is_same<decltype(r2), Vec<long, 3U>>{}, "!" );
   static_assert( std::is_same<decltype(r3), Vec<long, 3U>>{}, "!" );
   static_assert( std::is_same<decltype(r4), Mat<long, 2U, 3U>>{}, "!" );
   static_assert( std::is_same<decltype(r5), Mat<long, 2U, 4U>>{}, "!" );

   //applyM(foo, v2, v3);   // compilation error
   //applyM(foo, 1, 2);     // compilation error
   //applyM(foo, v2, m23);  // compilation error
   //applyM(foo, m24, m23); // compilation error
 }