0
\$\begingroup\$

This is a follow-up question for Nested std::deque and std::vector Type Test Cases for recursive_transform Template Function in C++, A recursive_transform Template Function Implementation with std::invocable concept in C++, A recursive_transform Template Function with Execution Policy and A recursive_transform Template Function Implementation with std::invocable Concept and Execution Policy in C++. Thanks to indi's detailed and clear answer and G. Sliepen's answer. Considering the process of the return type determination in recursive_transform() function is complicated and indi mentioned You don’t need to use just ints and doubles. In fact you could replace any of those with basically any other type. It might even be smart to mix it up, and throw in some char, some custom types, or whatever. I am trying to perform the part of various type test cases for recursive_transform() as below.

The experimental implementation

  • The part of non-range return type test

    The tested types here include char, int, float, double and long double, std::string, std::complex<char>, std::complex<int>, std::complex<float>, std::complex<double> and std::complex<long double>.

    template <typename Container, typename Function, typename Expected>
    using return_type_test_type = std::tuple<
        Container,
        Function,
        Expected,
        decltype(recursive_transform(std::execution::par, std::declval<Container>(), std::declval<Function>()))
    >;
    
    using return_type_test_types = std::tuple<
        //                    Container   Function                Result
    
        // Non-range.
        return_type_test_type<char,        char (*)(char),        char>,
        return_type_test_type<char,        char (*)(char const&), char>,
        return_type_test_type<char const,  char (*)(char const&), char>,
        return_type_test_type<char&,       char (*)(char const&), char>,
        return_type_test_type<char const&, char (*)(char const&), char>,
        return_type_test_type<char&&,      char (*)(char const&), char>,
    
        return_type_test_type<int,        char (*)(int),        char>,
        return_type_test_type<int,        char (*)(int const&), char>,
        return_type_test_type<int const,  char (*)(int const&), char>,
        return_type_test_type<int&,       char (*)(int const&), char>,
        return_type_test_type<int const&, char (*)(int const&), char>,
        return_type_test_type<int&&,      char (*)(int const&), char>,
    
        return_type_test_type<float,        char (*)(float),        char>,
        return_type_test_type<float,        char (*)(float const&), char>,
        return_type_test_type<float const,  char (*)(float const&), char>,
        return_type_test_type<float&,       char (*)(float const&), char>,
        return_type_test_type<float const&, char (*)(float const&), char>,
        return_type_test_type<float&&,      char (*)(float const&), char>,
    
        return_type_test_type<double,        char (*)(double),        char>,
        return_type_test_type<double,        char (*)(double const&), char>,
        return_type_test_type<double const,  char (*)(double const&), char>,
        return_type_test_type<double&,       char (*)(double const&), char>,
        return_type_test_type<double const&, char (*)(double const&), char>,
        return_type_test_type<double&&,      char (*)(double const&), char>,
    
        return_type_test_type<long double,        char (*)(long double),        char>,
        return_type_test_type<long double,        char (*)(long double const&), char>,
        return_type_test_type<long double const,  char (*)(long double const&), char>,
        return_type_test_type<long double&,       char (*)(long double const&), char>,
        return_type_test_type<long double const&, char (*)(long double const&), char>,
        return_type_test_type<long double&&,      char (*)(long double const&), char>,
    
        return_type_test_type<std::string,        char (*)(std::string),        char>,
        return_type_test_type<std::string,        char (*)(std::string const&), char>,
        return_type_test_type<std::string const,  char (*)(std::string const&), char>,
        return_type_test_type<std::string&,       char (*)(std::string const&), char>,
        return_type_test_type<std::string const&, char (*)(std::string const&), char>,
        return_type_test_type<std::string&&,      char (*)(std::string const&), char>,
    
        return_type_test_type<std::complex<char>,        char (*)(std::complex<char>),        char>,
        return_type_test_type<std::complex<char>,        char (*)(std::complex<char> const&), char>,
        return_type_test_type<std::complex<char> const,  char (*)(std::complex<char> const&), char>,
        return_type_test_type<std::complex<char>&,       char (*)(std::complex<char> const&), char>,
        return_type_test_type<std::complex<char> const&, char (*)(std::complex<char> const&), char>,
        return_type_test_type<std::complex<char>&&,      char (*)(std::complex<char> const&), char>,
    
        return_type_test_type<std::complex<int>,        char (*)(std::complex<int>),        char>,
        return_type_test_type<std::complex<int>,        char (*)(std::complex<int> const&), char>,
        return_type_test_type<std::complex<int> const,  char (*)(std::complex<int> const&), char>,
        return_type_test_type<std::complex<int>&,       char (*)(std::complex<int> const&), char>,
        return_type_test_type<std::complex<int> const&, char (*)(std::complex<int> const&), char>,
        return_type_test_type<std::complex<int>&&,      char (*)(std::complex<int> const&), char>,
    
        return_type_test_type<std::complex<float>,        char (*)(std::complex<float>),        char>,
        return_type_test_type<std::complex<float>,        char (*)(std::complex<float> const&), char>,
        return_type_test_type<std::complex<float> const,  char (*)(std::complex<float> const&), char>,
        return_type_test_type<std::complex<float>&,       char (*)(std::complex<float> const&), char>,
        return_type_test_type<std::complex<float> const&, char (*)(std::complex<float> const&), char>,
        return_type_test_type<std::complex<float>&&,      char (*)(std::complex<float> const&), char>,
    
        return_type_test_type<std::complex<double>,        char (*)(std::complex<double>),        char>,
        return_type_test_type<std::complex<double>,        char (*)(std::complex<double> const&), char>,
        return_type_test_type<std::complex<double> const,  char (*)(std::complex<double> const&), char>,
        return_type_test_type<std::complex<double>&,       char (*)(std::complex<double> const&), char>,
        return_type_test_type<std::complex<double> const&, char (*)(std::complex<double> const&), char>,
        return_type_test_type<std::complex<double>&&,      char (*)(std::complex<double> const&), char>,
    
        return_type_test_type<std::complex<long double>,        char (*)(std::complex<long double>),        char>,
        return_type_test_type<std::complex<long double>,        char (*)(std::complex<long double> const&), char>,
        return_type_test_type<std::complex<long double> const,  char (*)(std::complex<long double> const&), char>,
        return_type_test_type<std::complex<long double>&,       char (*)(std::complex<long double> const&), char>,
        return_type_test_type<std::complex<long double> const&, char (*)(std::complex<long double> const&), char>,
        return_type_test_type<std::complex<long double>&&,      char (*)(std::complex<long double> const&), char>,
    
        return_type_test_type<char,        int (*)(char),        int>,
        return_type_test_type<char,        int (*)(char const&), int>,
        return_type_test_type<char const,  int (*)(char const&), int>,
        return_type_test_type<char&,       int (*)(char const&), int>,
        return_type_test_type<char const&, int (*)(char const&), int>,
        return_type_test_type<char&&,      int (*)(char const&), int>,
    
        return_type_test_type<int,        int (*)(int),        int>,
        return_type_test_type<int,        int (*)(int const&), int>,
        return_type_test_type<int const,  int (*)(int const&), int>,
        return_type_test_type<int&,       int (*)(int const&), int>,
        return_type_test_type<int const&, int (*)(int const&), int>,
        return_type_test_type<int&&,      int (*)(int const&), int>,
    
        return_type_test_type<float,        int (*)(float),        int>,
        return_type_test_type<float,        int (*)(float const&), int>,
        return_type_test_type<float const,  int (*)(float const&), int>,
        return_type_test_type<float&,       int (*)(float const&), int>,
        return_type_test_type<float const&, int (*)(float const&), int>,
        return_type_test_type<float&&,      int (*)(float const&), int>,
    
        return_type_test_type<double,        int (*)(double),        int>,
        return_type_test_type<double,        int (*)(double const&), int>,
        return_type_test_type<double const,  int (*)(double const&), int>,
        return_type_test_type<double&,       int (*)(double const&), int>,
        return_type_test_type<double const&, int (*)(double const&), int>,
        return_type_test_type<double&&,      int (*)(double const&), int>,
    
        return_type_test_type<long double,        int (*)(long double),        int>,
        return_type_test_type<long double,        int (*)(long double const&), int>,
        return_type_test_type<long double const,  int (*)(long double const&), int>,
        return_type_test_type<long double&,       int (*)(long double const&), int>,
        return_type_test_type<long double const&, int (*)(long double const&), int>,
        return_type_test_type<long double&&,      int (*)(long double const&), int>,
    
        return_type_test_type<std::string,        int (*)(std::string),        int>,
        return_type_test_type<std::string,        int (*)(std::string const&), int>,
        return_type_test_type<std::string const,  int (*)(std::string const&), int>,
        return_type_test_type<std::string&,       int (*)(std::string const&), int>,
        return_type_test_type<std::string const&, int (*)(std::string const&), int>,
        return_type_test_type<std::string&&,      int (*)(std::string const&), int>,
    
        return_type_test_type<std::complex<char>,        int (*)(std::complex<char>),        int>,
        return_type_test_type<std::complex<char>,        int (*)(std::complex<char> const&), int>,
        return_type_test_type<std::complex<char> const,  int (*)(std::complex<char> const&), int>,
        return_type_test_type<std::complex<char>&,       int (*)(std::complex<char> const&), int>,
        return_type_test_type<std::complex<char> const&, int (*)(std::complex<char> const&), int>,
        return_type_test_type<std::complex<char>&&,      int (*)(std::complex<char> const&), int>,
    
        return_type_test_type<std::complex<int>,        int (*)(std::complex<int>),        int>,
        return_type_test_type<std::complex<int>,        int (*)(std::complex<int> const&), int>,
        return_type_test_type<std::complex<int> const,  int (*)(std::complex<int> const&), int>,
        return_type_test_type<std::complex<int>&,       int (*)(std::complex<int> const&), int>,
        return_type_test_type<std::complex<int> const&, int (*)(std::complex<int> const&), int>,
        return_type_test_type<std::complex<int>&&,      int (*)(std::complex<int> const&), int>,
    
        return_type_test_type<std::complex<float>,        int (*)(std::complex<float>),        int>,
        return_type_test_type<std::complex<float>,        int (*)(std::complex<float> const&), int>,
        return_type_test_type<std::complex<float> const,  int (*)(std::complex<float> const&), int>,
        return_type_test_type<std::complex<float>&,       int (*)(std::complex<float> const&), int>,
        return_type_test_type<std::complex<float> const&, int (*)(std::complex<float> const&), int>,
        return_type_test_type<std::complex<float>&&,      int (*)(std::complex<float> const&), int>,
    
        return_type_test_type<std::complex<double>,        int (*)(std::complex<double>),        int>,
        return_type_test_type<std::complex<double>,        int (*)(std::complex<double> const&), int>,
        return_type_test_type<std::complex<double> const,  int (*)(std::complex<double> const&), int>,
        return_type_test_type<std::complex<double>&,       int (*)(std::complex<double> const&), int>,
        return_type_test_type<std::complex<double> const&, int (*)(std::complex<double> const&), int>,
        return_type_test_type<std::complex<double>&&,      int (*)(std::complex<double> const&), int>,
    
        return_type_test_type<std::complex<long double>,        int (*)(std::complex<long double>),        int>,
        return_type_test_type<std::complex<long double>,        int (*)(std::complex<long double> const&), int>,
        return_type_test_type<std::complex<long double> const,  int (*)(std::complex<long double> const&), int>,
        return_type_test_type<std::complex<long double>&,       int (*)(std::complex<long double> const&), int>,
        return_type_test_type<std::complex<long double> const&, int (*)(std::complex<long double> const&), int>,
        return_type_test_type<std::complex<long double>&&,      int (*)(std::complex<long double> const&), int>,
    
        return_type_test_type<char,        float (*)(char),        float>,
        return_type_test_type<char,        float (*)(char const&), float>,
        return_type_test_type<char const,  float (*)(char const&), float>,
        return_type_test_type<char&,       float (*)(char const&), float>,
        return_type_test_type<char const&, float (*)(char const&), float>,
        return_type_test_type<char&&,      float (*)(char const&), float>,
    
        return_type_test_type<int,        float (*)(int),        float>,
        return_type_test_type<int,        float (*)(int const&), float>,
        return_type_test_type<int const,  float (*)(int const&), float>,
        return_type_test_type<int&,       float (*)(int const&), float>,
        return_type_test_type<int const&, float (*)(int const&), float>,
        return_type_test_type<int&&,      float (*)(int const&), float>,
    
        return_type_test_type<float,        float (*)(float),        float>,
        return_type_test_type<float,        float (*)(float const&), float>,
        return_type_test_type<float const,  float (*)(float const&), float>,
        return_type_test_type<float&,       float (*)(float const&), float>,
        return_type_test_type<float const&, float (*)(float const&), float>,
        return_type_test_type<float&&,      float (*)(float const&), float>,
    
        return_type_test_type<double,        float (*)(double),        float>,
        return_type_test_type<double,        float (*)(double const&), float>,
        return_type_test_type<double const,  float (*)(double const&), float>,
        return_type_test_type<double&,       float (*)(double const&), float>,
        return_type_test_type<double const&, float (*)(double const&), float>,
        return_type_test_type<double&&,      float (*)(double const&), float>,
    
        return_type_test_type<long double,        float (*)(long double),        float>,
        return_type_test_type<long double,        float (*)(long double const&), float>,
        return_type_test_type<long double const,  float (*)(long double const&), float>,
        return_type_test_type<long double&,       float (*)(long double const&), float>,
        return_type_test_type<long double const&, float (*)(long double const&), float>,
        return_type_test_type<long double&&,      float (*)(long double const&), float>,
    
        return_type_test_type<std::string,        float (*)(std::string),        float>,
        return_type_test_type<std::string,        float (*)(std::string const&), float>,
        return_type_test_type<std::string const,  float (*)(std::string const&), float>,
        return_type_test_type<std::string&,       float (*)(std::string const&), float>,
        return_type_test_type<std::string const&, float (*)(std::string const&), float>,
        return_type_test_type<std::string&&,      float (*)(std::string const&), float>,
    
        return_type_test_type<std::complex<char>,        float (*)(std::complex<char>),        float>,
        return_type_test_type<std::complex<char>,        float (*)(std::complex<char> const&), float>,
        return_type_test_type<std::complex<char> const,  float (*)(std::complex<char> const&), float>,
        return_type_test_type<std::complex<char>&,       float (*)(std::complex<char> const&), float>,
        return_type_test_type<std::complex<char> const&, float (*)(std::complex<char> const&), float>,
        return_type_test_type<std::complex<char>&&,      float (*)(std::complex<char> const&), float>,
    
        return_type_test_type<std::complex<int>,        float (*)(std::complex<int>),        float>,
        return_type_test_type<std::complex<int>,        float (*)(std::complex<int> const&), float>,
        return_type_test_type<std::complex<int> const,  float (*)(std::complex<int> const&), float>,
        return_type_test_type<std::complex<int>&,       float (*)(std::complex<int> const&), float>,
        return_type_test_type<std::complex<int> const&, float (*)(std::complex<int> const&), float>,
        return_type_test_type<std::complex<int>&&,      float (*)(std::complex<int> const&), float>,
    
        return_type_test_type<std::complex<float>,        float (*)(std::complex<float>),        float>,
        return_type_test_type<std::complex<float>,        float (*)(std::complex<float> const&), float>,
        return_type_test_type<std::complex<float> const,  float (*)(std::complex<float> const&), float>,
        return_type_test_type<std::complex<float>&,       float (*)(std::complex<float> const&), float>,
        return_type_test_type<std::complex<float> const&, float (*)(std::complex<float> const&), float>,
        return_type_test_type<std::complex<float>&&,      float (*)(std::complex<float> const&), float>,
    
        return_type_test_type<std::complex<double>,        float (*)(std::complex<double>),        float>,
        return_type_test_type<std::complex<double>,        float (*)(std::complex<double> const&), float>,
        return_type_test_type<std::complex<double> const,  float (*)(std::complex<double> const&), float>,
        return_type_test_type<std::complex<double>&,       float (*)(std::complex<double> const&), float>,
        return_type_test_type<std::complex<double> const&, float (*)(std::complex<double> const&), float>,
        return_type_test_type<std::complex<double>&&,      float (*)(std::complex<double> const&), float>,
    
        return_type_test_type<std::complex<long double>,        float (*)(std::complex<long double>),        float>,
        return_type_test_type<std::complex<long double>,        float (*)(std::complex<long double> const&), float>,
        return_type_test_type<std::complex<long double> const,  float (*)(std::complex<long double> const&), float>,
        return_type_test_type<std::complex<long double>&,       float (*)(std::complex<long double> const&), float>,
        return_type_test_type<std::complex<long double> const&, float (*)(std::complex<long double> const&), float>,
        return_type_test_type<std::complex<long double>&&,      float (*)(std::complex<long double> const&), float>,
    
        return_type_test_type<char,        double (*)(char),        double>,
        return_type_test_type<char,        double (*)(char const&), double>,
        return_type_test_type<char const,  double (*)(char const&), double>,
        return_type_test_type<char&,       double (*)(char const&), double>,
        return_type_test_type<char const&, double (*)(char const&), double>,
        return_type_test_type<char&&,      double (*)(char const&), double>,
    
        return_type_test_type<int,        double (*)(int),        double>,
        return_type_test_type<int,        double (*)(int const&), double>,
        return_type_test_type<int const,  double (*)(int const&), double>,
        return_type_test_type<int&,       double (*)(int const&), double>,
        return_type_test_type<int const&, double (*)(int const&), double>,
        return_type_test_type<int&&,      double (*)(int const&), double>,
    
        return_type_test_type<float,        double (*)(float),        double>,
        return_type_test_type<float,        double (*)(float const&), double>,
        return_type_test_type<float const,  double (*)(float const&), double>,
        return_type_test_type<float&,       double (*)(float const&), double>,
        return_type_test_type<float const&, double (*)(float const&), double>,
        return_type_test_type<float&&,      double (*)(float const&), double>,
    
        return_type_test_type<double,        double (*)(double),        double>,
        return_type_test_type<double,        double (*)(double const&), double>,
        return_type_test_type<double const,  double (*)(double const&), double>,
        return_type_test_type<double&,       double (*)(double const&), double>,
        return_type_test_type<double const&, double (*)(double const&), double>,
        return_type_test_type<double&&,      double (*)(double const&), double>,
    
        return_type_test_type<long double,        double (*)(long double),        double>,
        return_type_test_type<long double,        double (*)(long double const&), double>,
        return_type_test_type<long double const,  double (*)(long double const&), double>,
        return_type_test_type<long double&,       double (*)(long double const&), double>,
        return_type_test_type<long double const&, double (*)(long double const&), double>,
        return_type_test_type<long double&&,      double (*)(long double const&), double>,
    
        return_type_test_type<std::string,        double (*)(std::string),        double>,
        return_type_test_type<std::string,        double (*)(std::string const&), double>,
        return_type_test_type<std::string const,  double (*)(std::string const&), double>,
        return_type_test_type<std::string&,       double (*)(std::string const&), double>,
        return_type_test_type<std::string const&, double (*)(std::string const&), double>,
        return_type_test_type<std::string&&,      double (*)(std::string const&), double>,
    
        return_type_test_type<std::complex<char>,        double (*)(std::complex<char>),        double>,
        return_type_test_type<std::complex<char>,        double (*)(std::complex<char> const&), double>,
        return_type_test_type<std::complex<char> const,  double (*)(std::complex<char> const&), double>,
        return_type_test_type<std::complex<char>&,       double (*)(std::complex<char> const&), double>,
        return_type_test_type<std::complex<char> const&, double (*)(std::complex<char> const&), double>,
        return_type_test_type<std::complex<char>&&,      double (*)(std::complex<char> const&), double>,
    
        return_type_test_type<std::complex<int>,        double (*)(std::complex<int>),        double>,
        return_type_test_type<std::complex<int>,        double (*)(std::complex<int> const&), double>,
        return_type_test_type<std::complex<int> const,  double (*)(std::complex<int> const&), double>,
        return_type_test_type<std::complex<int>&,       double (*)(std::complex<int> const&), double>,
        return_type_test_type<std::complex<int> const&, double (*)(std::complex<int> const&), double>,
        return_type_test_type<std::complex<int>&&,      double (*)(std::complex<int> const&), double>,
    
        return_type_test_type<std::complex<float>,        double (*)(std::complex<float>),        double>,
        return_type_test_type<std::complex<float>,        double (*)(std::complex<float> const&), double>,
        return_type_test_type<std::complex<float> const,  double (*)(std::complex<float> const&), double>,
        return_type_test_type<std::complex<float>&,       double (*)(std::complex<float> const&), double>,
        return_type_test_type<std::complex<float> const&, double (*)(std::complex<float> const&), double>,
        return_type_test_type<std::complex<float>&&,      double (*)(std::complex<float> const&), double>,
    
        return_type_test_type<std::complex<double>,        double (*)(std::complex<double>),        double>,
        return_type_test_type<std::complex<double>,        double (*)(std::complex<double> const&), double>,
        return_type_test_type<std::complex<double> const,  double (*)(std::complex<double> const&), double>,
        return_type_test_type<std::complex<double>&,       double (*)(std::complex<double> const&), double>,
        return_type_test_type<std::complex<double> const&, double (*)(std::complex<double> const&), double>,
        return_type_test_type<std::complex<double>&&,      double (*)(std::complex<double> const&), double>,
    
        return_type_test_type<std::complex<long double>,        double (*)(std::complex<long double>),        double>,
        return_type_test_type<std::complex<long double>,        double (*)(std::complex<long double> const&), double>,
        return_type_test_type<std::complex<long double> const,  double (*)(std::complex<long double> const&), double>,
        return_type_test_type<std::complex<long double>&,       double (*)(std::complex<long double> const&), double>,
        return_type_test_type<std::complex<long double> const&, double (*)(std::complex<long double> const&), double>,
        return_type_test_type<std::complex<long double>&&,      double (*)(std::complex<long double> const&), double>,
    
        return_type_test_type<char,        long double (*)(char),        long double>,
        return_type_test_type<char,        long double (*)(char const&), long double>,
        return_type_test_type<char const,  long double (*)(char const&), long double>,
        return_type_test_type<char&,       long double (*)(char const&), long double>,
        return_type_test_type<char const&, long double (*)(char const&), long double>,
        return_type_test_type<char&&,      long double (*)(char const&), long double>,
    
        return_type_test_type<int,        long double (*)(int),        long double>,
        return_type_test_type<int,        long double (*)(int const&), long double>,
        return_type_test_type<int const,  long double (*)(int const&), long double>,
        return_type_test_type<int&,       long double (*)(int const&), long double>,
        return_type_test_type<int const&, long double (*)(int const&), long double>,
        return_type_test_type<int&&,      long double (*)(int const&), long double>,
    
        return_type_test_type<float,        long double (*)(float),        long double>,
        return_type_test_type<float,        long double (*)(float const&), long double>,
        return_type_test_type<float const,  long double (*)(float const&), long double>,
        return_type_test_type<float&,       long double (*)(float const&), long double>,
        return_type_test_type<float const&, long double (*)(float const&), long double>,
        return_type_test_type<float&&,      long double (*)(float const&), long double>,
    
        return_type_test_type<double,        long double (*)(double),        long double>,
        return_type_test_type<double,        long double (*)(double const&), long double>,
        return_type_test_type<double const,  long double (*)(double const&), long double>,
        return_type_test_type<double&,       long double (*)(double const&), long double>,
        return_type_test_type<double const&, long double (*)(double const&), long double>,
        return_type_test_type<double&&,      long double (*)(double const&), long double>,
    
        return_type_test_type<long double,        long double (*)(long double),        long double>,
        return_type_test_type<long double,        long double (*)(long double const&), long double>,
        return_type_test_type<long double const,  long double (*)(long double const&), long double>,
        return_type_test_type<long double&,       long double (*)(long double const&), long double>,
        return_type_test_type<long double const&, long double (*)(long double const&), long double>,
        return_type_test_type<long double&&,      long double (*)(long double const&), long double>,
    
        return_type_test_type<std::string,        long double (*)(std::string),        long double>,
        return_type_test_type<std::string,        long double (*)(std::string const&), long double>,
        return_type_test_type<std::string const,  long double (*)(std::string const&), long double>,
        return_type_test_type<std::string&,       long double (*)(std::string const&), long double>,
        return_type_test_type<std::string const&, long double (*)(std::string const&), long double>,
        return_type_test_type<std::string&&,      long double (*)(std::string const&), long double>,
    
        return_type_test_type<std::complex<char>,        long double (*)(std::complex<char>),        long double>,
        return_type_test_type<std::complex<char>,        long double (*)(std::complex<char> const&), long double>,
        return_type_test_type<std::complex<char> const,  long double (*)(std::complex<char> const&), long double>,
        return_type_test_type<std::complex<char>&,       long double (*)(std::complex<char> const&), long double>,
        return_type_test_type<std::complex<char> const&, long double (*)(std::complex<char> const&), long double>,
        return_type_test_type<std::complex<char>&&,      long double (*)(std::complex<char> const&), long double>,
    
        return_type_test_type<std::complex<int>,        long double (*)(std::complex<int>),        long double>,
        return_type_test_type<std::complex<int>,        long double (*)(std::complex<int> const&), long double>,
        return_type_test_type<std::complex<int> const,  long double (*)(std::complex<int> const&), long double>,
        return_type_test_type<std::complex<int>&,       long double (*)(std::complex<int> const&), long double>,
        return_type_test_type<std::complex<int> const&, long double (*)(std::complex<int> const&), long double>,
        return_type_test_type<std::complex<int>&&,      long double (*)(std::complex<int> const&), long double>,
    
        return_type_test_type<std::complex<float>,        long double (*)(std::complex<float>),        long double>,
        return_type_test_type<std::complex<float>,        long double (*)(std::complex<float> const&), long double>,
        return_type_test_type<std::complex<float> const,  long double (*)(std::complex<float> const&), long double>,
        return_type_test_type<std::complex<float>&,       long double (*)(std::complex<float> const&), long double>,
        return_type_test_type<std::complex<float> const&, long double (*)(std::complex<float> const&), long double>,
        return_type_test_type<std::complex<float>&&,      long double (*)(std::complex<float> const&), long double>,
    
        return_type_test_type<std::complex<double>,        long double (*)(std::complex<double>),        long double>,
        return_type_test_type<std::complex<double>,        long double (*)(std::complex<double> const&), long double>,
        return_type_test_type<std::complex<double> const,  long double (*)(std::complex<double> const&), long double>,
        return_type_test_type<std::complex<double>&,       long double (*)(std::complex<double> const&), long double>,
        return_type_test_type<std::complex<double> const&, long double (*)(std::complex<double> const&), long double>,
        return_type_test_type<std::complex<double>&&,      long double (*)(std::complex<double> const&), long double>,
    
        return_type_test_type<std::complex<long double>,        long double (*)(std::complex<long double>),        long double>,
        return_type_test_type<std::complex<long double>,        long double (*)(std::complex<long double> const&), long double>,
        return_type_test_type<std::complex<long double> const,  long double (*)(std::complex<long double> const&), long double>,
        return_type_test_type<std::complex<long double>&,       long double (*)(std::complex<long double> const&), long double>,
        return_type_test_type<std::complex<long double> const&, long double (*)(std::complex<long double> const&), long double>,
        return_type_test_type<std::complex<long double>&&,      long double (*)(std::complex<long double> const&), long double>,
    
        return_type_test_type<char,        std::string (*)(char),        std::string>,
        return_type_test_type<char,        std::string (*)(char const&), std::string>,
        return_type_test_type<char const,  std::string (*)(char const&), std::string>,
        return_type_test_type<char&,       std::string (*)(char const&), std::string>,
        return_type_test_type<char const&, std::string (*)(char const&), std::string>,
        return_type_test_type<char&&,      std::string (*)(char const&), std::string>,
    
        return_type_test_type<int,        std::string (*)(int),        std::string>,
        return_type_test_type<int,        std::string (*)(int const&), std::string>,
        return_type_test_type<int const,  std::string (*)(int const&), std::string>,
        return_type_test_type<int&,       std::string (*)(int const&), std::string>,
        return_type_test_type<int const&, std::string (*)(int const&), std::string>,
        return_type_test_type<int&&,      std::string (*)(int const&), std::string>
    >;
    
    BOOST_AUTO_TEST_CASE_TEMPLATE(return_type, Types, return_type_test_types)
    {
        //using Container = std::tuple_element_t<0, Types>;
        //using Function  = std::tuple_element_t<1, Types>;
        using Expected = std::tuple_element_t<2, Types>;
        using Result = std::tuple_element_t<3, Types>;
    
        BOOST_TEST((std::is_same_v<Expected, Result>));
    }
    
  • The part of the input type with non-recursive std::optional

    return_type_test_type<std::optional<char>, char (*)(std::optional<char>), char>,
    
    return_type_test_type<std::optional<int>, char (*)(std::optional<int>), char>,
    
    return_type_test_type<std::optional<short>, char (*)(std::optional<short>), char>,
    
    return_type_test_type<std::optional<long>, char (*)(std::optional<long>), char>,
    
    return_type_test_type<std::optional<long long int>, char (*)(std::optional<long long int>), char>,
    
    return_type_test_type<std::optional<float>, char (*)(std::optional<float>), char>,
    
    return_type_test_type<std::optional<double>, char (*)(std::optional<double>), char>,
    
    return_type_test_type<std::optional<long double>, char (*)(std::optional<long double>), char>,
    
    return_type_test_type<std::optional<char>, int (*)(std::optional<char>), int>,
    
    return_type_test_type<std::optional<int>, int (*)(std::optional<int>), int>,
    
    return_type_test_type<std::optional<short>, int (*)(std::optional<short>), int>,
    
    return_type_test_type<std::optional<long>, int (*)(std::optional<long>), int>,
    
    return_type_test_type<std::optional<long long int>, int (*)(std::optional<long long int>), int>,
    
    return_type_test_type<std::optional<float>, int (*)(std::optional<float>), int>,
    
    return_type_test_type<std::optional<double>, int (*)(std::optional<double>), int>,
    
    return_type_test_type<std::optional<long double>, int (*)(std::optional<long double>), int>,
    
    return_type_test_type<std::optional<char>, short (*)(std::optional<char>), short>,
    
    return_type_test_type<std::optional<int>, short (*)(std::optional<int>), short>,
    
    return_type_test_type<std::optional<short>, short (*)(std::optional<short>), short>,
    
    return_type_test_type<std::optional<long>, short (*)(std::optional<long>), short>,
    
    return_type_test_type<std::optional<long long int>, short (*)(std::optional<long long int>), short>,
    
    return_type_test_type<std::optional<float>, short (*)(std::optional<float>), short>,
    
    return_type_test_type<std::optional<double>, short (*)(std::optional<double>), short>,
    
    return_type_test_type<std::optional<long double>, short (*)(std::optional<long double>), short>,
    
    return_type_test_type<std::optional<char>, long (*)(std::optional<char>), long>,
    
    return_type_test_type<std::optional<int>, long (*)(std::optional<int>), long>,
    
    return_type_test_type<std::optional<short>, long (*)(std::optional<short>), long>,
    
    return_type_test_type<std::optional<long>, long (*)(std::optional<long>), long>,
    
    return_type_test_type<std::optional<long long int>, long (*)(std::optional<long long int>), long>,
    
    return_type_test_type<std::optional<float>, long (*)(std::optional<float>), long>,
    
    return_type_test_type<std::optional<double>, long (*)(std::optional<double>), long>,
    
    return_type_test_type<std::optional<long double>, long (*)(std::optional<long double>), long>,
    
    return_type_test_type<std::optional<char>, long long int (*)(std::optional<char>), long long int>,
    
    return_type_test_type<std::optional<int>, long long int (*)(std::optional<int>), long long int>,
    
    return_type_test_type<std::optional<short>, long long int (*)(std::optional<short>), long long int>,
    
    return_type_test_type<std::optional<long>, long long int (*)(std::optional<long>), long long int>,
    
    return_type_test_type<std::optional<long long int>, long long int (*)(std::optional<long long int>), long long int>,
    
    return_type_test_type<std::optional<float>, long long int (*)(std::optional<float>), long long int>,
    
    return_type_test_type<std::optional<double>, long long int (*)(std::optional<double>), long long int>,
    
    return_type_test_type<std::optional<long double>, long long int (*)(std::optional<long double>), long long int>,
    
    return_type_test_type<std::optional<char>, float (*)(std::optional<char>), float>,
    
    return_type_test_type<std::optional<int>, float (*)(std::optional<int>), float>,
    
    return_type_test_type<std::optional<short>, float (*)(std::optional<short>), float>,
    
    return_type_test_type<std::optional<long>, float (*)(std::optional<long>), float>,
    
    return_type_test_type<std::optional<long long int>, float (*)(std::optional<long long int>), float>,
    
    return_type_test_type<std::optional<float>, float (*)(std::optional<float>), float>,
    
    return_type_test_type<std::optional<double>, float (*)(std::optional<double>), float>,
    
    return_type_test_type<std::optional<long double>, float (*)(std::optional<long double>), float>,
    
    return_type_test_type<std::optional<char>, double (*)(std::optional<char>), double>,
    
    return_type_test_type<std::optional<int>, double (*)(std::optional<int>), double>,
    
    return_type_test_type<std::optional<short>, double (*)(std::optional<short>), double>,
    
    return_type_test_type<std::optional<long>, double (*)(std::optional<long>), double>,
    
    return_type_test_type<std::optional<long long int>, double (*)(std::optional<long long int>), double>,
    
    return_type_test_type<std::optional<float>, double (*)(std::optional<float>), double>,
    
    return_type_test_type<std::optional<double>, double (*)(std::optional<double>), double>,
    
    return_type_test_type<std::optional<long double>, double (*)(std::optional<long double>), double>,
    
    return_type_test_type<std::optional<char>, long double (*)(std::optional<char>), long double>,
    
    return_type_test_type<std::optional<int>, long double (*)(std::optional<int>), long double>,
    
    return_type_test_type<std::optional<short>, long double (*)(std::optional<short>), long double>,
    
    return_type_test_type<std::optional<long>, long double (*)(std::optional<long>), long double>,
    
    return_type_test_type<std::optional<long long int>, long double (*)(std::optional<long long int>), long double>,
    
    return_type_test_type<std::optional<float>, long double (*)(std::optional<float>), long double>,
    
    return_type_test_type<std::optional<double>, long double (*)(std::optional<double>), long double>,
    
    return_type_test_type<std::optional<long double>, long double (*)(std::optional<long double>), long double>,
    
  • The part of non-recursive std::optional input and non-recursive std::optional output

    return_type_test_type<std::optional<char>, std::optional<char> (*)(std::optional<char>), std::optional<char>>,
    
    return_type_test_type<std::optional<int>, std::optional<char> (*)(std::optional<int>), std::optional<char>>,
    
    return_type_test_type<std::optional<short>, std::optional<char> (*)(std::optional<short>), std::optional<char>>,
    
    return_type_test_type<std::optional<long>, std::optional<char> (*)(std::optional<long>), std::optional<char>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<char> (*)(std::optional<long long int>), std::optional<char>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<char> (*)(std::optional<unsigned char>), std::optional<char>>,
    
    return_type_test_type<std::optional<float>, std::optional<char> (*)(std::optional<float>), std::optional<char>>,
    
    return_type_test_type<std::optional<double>, std::optional<char> (*)(std::optional<double>), std::optional<char>>,
    
    return_type_test_type<std::optional<long double>, std::optional<char> (*)(std::optional<long double>), std::optional<char>>,
    
    return_type_test_type<std::optional<char>, std::optional<int> (*)(std::optional<char>), std::optional<int>>,
    
    return_type_test_type<std::optional<int>, std::optional<int> (*)(std::optional<int>), std::optional<int>>,
    
    return_type_test_type<std::optional<short>, std::optional<int> (*)(std::optional<short>), std::optional<int>>,
    
    return_type_test_type<std::optional<long>, std::optional<int> (*)(std::optional<long>), std::optional<int>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<int> (*)(std::optional<long long int>), std::optional<int>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<int> (*)(std::optional<unsigned char>), std::optional<int>>,
    
    return_type_test_type<std::optional<float>, std::optional<int> (*)(std::optional<float>), std::optional<int>>,
    
    return_type_test_type<std::optional<double>, std::optional<int> (*)(std::optional<double>), std::optional<int>>,
    
    return_type_test_type<std::optional<long double>, std::optional<int> (*)(std::optional<long double>), std::optional<int>>,
    
    return_type_test_type<std::optional<char>, std::optional<short> (*)(std::optional<char>), std::optional<short>>,
    
    return_type_test_type<std::optional<int>, std::optional<short> (*)(std::optional<int>), std::optional<short>>,
    
    return_type_test_type<std::optional<short>, std::optional<short> (*)(std::optional<short>), std::optional<short>>,
    
    return_type_test_type<std::optional<long>, std::optional<short> (*)(std::optional<long>), std::optional<short>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<short> (*)(std::optional<long long int>), std::optional<short>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<short> (*)(std::optional<unsigned char>), std::optional<short>>,
    
    return_type_test_type<std::optional<float>, std::optional<short> (*)(std::optional<float>), std::optional<short>>,
    
    return_type_test_type<std::optional<double>, std::optional<short> (*)(std::optional<double>), std::optional<short>>,
    
    return_type_test_type<std::optional<long double>, std::optional<short> (*)(std::optional<long double>), std::optional<short>>,
    
    return_type_test_type<std::optional<char>, std::optional<long> (*)(std::optional<char>), std::optional<long>>,
    
    return_type_test_type<std::optional<int>, std::optional<long> (*)(std::optional<int>), std::optional<long>>,
    
    return_type_test_type<std::optional<short>, std::optional<long> (*)(std::optional<short>), std::optional<long>>,
    
    return_type_test_type<std::optional<long>, std::optional<long> (*)(std::optional<long>), std::optional<long>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<long> (*)(std::optional<long long int>), std::optional<long>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<long> (*)(std::optional<unsigned char>), std::optional<long>>,
    
    return_type_test_type<std::optional<float>, std::optional<long> (*)(std::optional<float>), std::optional<long>>,
    
    return_type_test_type<std::optional<double>, std::optional<long> (*)(std::optional<double>), std::optional<long>>,
    
    return_type_test_type<std::optional<long double>, std::optional<long> (*)(std::optional<long double>), std::optional<long>>,
    
    return_type_test_type<std::optional<char>, std::optional<long long int> (*)(std::optional<char>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<int>, std::optional<long long int> (*)(std::optional<int>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<short>, std::optional<long long int> (*)(std::optional<short>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<long>, std::optional<long long int> (*)(std::optional<long>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<long long int> (*)(std::optional<long long int>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<long long int> (*)(std::optional<unsigned char>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<float>, std::optional<long long int> (*)(std::optional<float>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<double>, std::optional<long long int> (*)(std::optional<double>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<long double>, std::optional<long long int> (*)(std::optional<long double>), std::optional<long long int>>,
    
    return_type_test_type<std::optional<char>, std::optional<unsigned char> (*)(std::optional<char>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<int>, std::optional<unsigned char> (*)(std::optional<int>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<short>, std::optional<unsigned char> (*)(std::optional<short>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<long>, std::optional<unsigned char> (*)(std::optional<long>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<unsigned char> (*)(std::optional<long long int>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<unsigned char> (*)(std::optional<unsigned char>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<float>, std::optional<unsigned char> (*)(std::optional<float>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<double>, std::optional<unsigned char> (*)(std::optional<double>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<long double>, std::optional<unsigned char> (*)(std::optional<long double>), std::optional<unsigned char>>,
    
    return_type_test_type<std::optional<char>, std::optional<float> (*)(std::optional<char>), std::optional<float>>,
    
    return_type_test_type<std::optional<int>, std::optional<float> (*)(std::optional<int>), std::optional<float>>,
    
    return_type_test_type<std::optional<short>, std::optional<float> (*)(std::optional<short>), std::optional<float>>,
    
    return_type_test_type<std::optional<long>, std::optional<float> (*)(std::optional<long>), std::optional<float>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<float> (*)(std::optional<long long int>), std::optional<float>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<float> (*)(std::optional<unsigned char>), std::optional<float>>,
    
    return_type_test_type<std::optional<float>, std::optional<float> (*)(std::optional<float>), std::optional<float>>,
    
    return_type_test_type<std::optional<double>, std::optional<float> (*)(std::optional<double>), std::optional<float>>,
    
    return_type_test_type<std::optional<long double>, std::optional<float> (*)(std::optional<long double>), std::optional<float>>,
    
    return_type_test_type<std::optional<char>, std::optional<double> (*)(std::optional<char>), std::optional<double>>,
    
    return_type_test_type<std::optional<int>, std::optional<double> (*)(std::optional<int>), std::optional<double>>,
    
    return_type_test_type<std::optional<short>, std::optional<double> (*)(std::optional<short>), std::optional<double>>,
    
    return_type_test_type<std::optional<long>, std::optional<double> (*)(std::optional<long>), std::optional<double>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<double> (*)(std::optional<long long int>), std::optional<double>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<double> (*)(std::optional<unsigned char>), std::optional<double>>,
    
    return_type_test_type<std::optional<float>, std::optional<double> (*)(std::optional<float>), std::optional<double>>,
    
    return_type_test_type<std::optional<double>, std::optional<double> (*)(std::optional<double>), std::optional<double>>,
    
    return_type_test_type<std::optional<long double>, std::optional<double> (*)(std::optional<long double>), std::optional<double>>,
    
    return_type_test_type<std::optional<char>, std::optional<long double> (*)(std::optional<char>), std::optional<long double>>,
    
    return_type_test_type<std::optional<int>, std::optional<long double> (*)(std::optional<int>), std::optional<long double>>,
    
    return_type_test_type<std::optional<short>, std::optional<long double> (*)(std::optional<short>), std::optional<long double>>,
    
    return_type_test_type<std::optional<long>, std::optional<long double> (*)(std::optional<long>), std::optional<long double>>,
    
    return_type_test_type<std::optional<long long int>, std::optional<long double> (*)(std::optional<long long int>), std::optional<long double>>,
    
    return_type_test_type<std::optional<unsigned char>, std::optional<long double> (*)(std::optional<unsigned char>), std::optional<long double>>,
    
    return_type_test_type<std::optional<float>, std::optional<long double> (*)(std::optional<float>), std::optional<long double>>,
    
    return_type_test_type<std::optional<double>, std::optional<long double> (*)(std::optional<double>), std::optional<long double>>,
    
    return_type_test_type<std::optional<long double>, std::optional<long double> (*)(std::optional<long double>), std::optional<long double>>,
    
  • The part of non-recursive std::array return type test

    // Non-recursive array.
    return_type_test_type<std::array<char, 5>, char (*)(char), std::array<char, 5>>,
    
    return_type_test_type<std::array<int, 5>, char (*)(int), std::array<char, 5>>,
    
    return_type_test_type<std::array<short, 5>, char (*)(short), std::array<char, 5>>,
    
    return_type_test_type<std::array<long, 5>, char (*)(long), std::array<char, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, char (*)(long long int), std::array<char, 5>>,
    
    return_type_test_type<std::array<float, 5>, char (*)(float), std::array<char, 5>>,
    
    return_type_test_type<std::array<double, 5>, char (*)(double), std::array<char, 5>>,
    
    return_type_test_type<std::array<long double, 5>, char (*)(long double), std::array<char, 5>>,
    
    return_type_test_type<std::array<char, 5>, int (*)(char), std::array<int, 5>>,
    
    return_type_test_type<std::array<int, 5>, int (*)(int), std::array<int, 5>>,
    
    return_type_test_type<std::array<short, 5>, int (*)(short), std::array<int, 5>>,
    
    return_type_test_type<std::array<long, 5>, int (*)(long), std::array<int, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, int (*)(long long int), std::array<int, 5>>,
    
    return_type_test_type<std::array<float, 5>, int (*)(float), std::array<int, 5>>,
    
    return_type_test_type<std::array<double, 5>, int (*)(double), std::array<int, 5>>,
    
    return_type_test_type<std::array<long double, 5>, int (*)(long double), std::array<int, 5>>,
    
    return_type_test_type<std::array<char, 5>, short (*)(char), std::array<short, 5>>,
    
    return_type_test_type<std::array<int, 5>, short (*)(int), std::array<short, 5>>,
    
    return_type_test_type<std::array<short, 5>, short (*)(short), std::array<short, 5>>,
    
    return_type_test_type<std::array<long, 5>, short (*)(long), std::array<short, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, short (*)(long long int), std::array<short, 5>>,
    
    return_type_test_type<std::array<float, 5>, short (*)(float), std::array<short, 5>>,
    
    return_type_test_type<std::array<double, 5>, short (*)(double), std::array<short, 5>>,
    
    return_type_test_type<std::array<long double, 5>, short (*)(long double), std::array<short, 5>>,
    
    return_type_test_type<std::array<char, 5>, long (*)(char), std::array<long, 5>>,
    
    return_type_test_type<std::array<int, 5>, long (*)(int), std::array<long, 5>>,
    
    return_type_test_type<std::array<short, 5>, long (*)(short), std::array<long, 5>>,
    
    return_type_test_type<std::array<long, 5>, long (*)(long), std::array<long, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, long (*)(long long int), std::array<long, 5>>,
    
    return_type_test_type<std::array<float, 5>, long (*)(float), std::array<long, 5>>,
    
    return_type_test_type<std::array<double, 5>, long (*)(double), std::array<long, 5>>,
    
    return_type_test_type<std::array<long double, 5>, long (*)(long double), std::array<long, 5>>,
    
    return_type_test_type<std::array<char, 5>, long long int (*)(char), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<int, 5>, long long int (*)(int), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<short, 5>, long long int (*)(short), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<long, 5>, long long int (*)(long), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, long long int (*)(long long int), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<float, 5>, long long int (*)(float), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<double, 5>, long long int (*)(double), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<long double, 5>, long long int (*)(long double), std::array<long long int, 5>>,
    
    return_type_test_type<std::array<char, 5>, float (*)(char), std::array<float, 5>>,
    
    return_type_test_type<std::array<int, 5>, float (*)(int), std::array<float, 5>>,
    
    return_type_test_type<std::array<short, 5>, float (*)(short), std::array<float, 5>>,
    
    return_type_test_type<std::array<long, 5>, float (*)(long), std::array<float, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, float (*)(long long int), std::array<float, 5>>,
    
    return_type_test_type<std::array<float, 5>, float (*)(float), std::array<float, 5>>,
    
    return_type_test_type<std::array<double, 5>, float (*)(double), std::array<float, 5>>,
    
    return_type_test_type<std::array<long double, 5>, float (*)(long double), std::array<float, 5>>,
    
    return_type_test_type<std::array<char, 5>, double (*)(char), std::array<double, 5>>,
    
    return_type_test_type<std::array<int, 5>, double (*)(int), std::array<double, 5>>,
    
    return_type_test_type<std::array<short, 5>, double (*)(short), std::array<double, 5>>,
    
    return_type_test_type<std::array<long, 5>, double (*)(long), std::array<double, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, double (*)(long long int), std::array<double, 5>>,
    
    return_type_test_type<std::array<float, 5>, double (*)(float), std::array<double, 5>>,
    
    return_type_test_type<std::array<double, 5>, double (*)(double), std::array<double, 5>>,
    
    return_type_test_type<std::array<long double, 5>, double (*)(long double), std::array<double, 5>>,
    
    return_type_test_type<std::array<char, 5>, long double (*)(char), std::array<long double, 5>>,
    
    return_type_test_type<std::array<int, 5>, long double (*)(int), std::array<long double, 5>>,
    
    return_type_test_type<std::array<short, 5>, long double (*)(short), std::array<long double, 5>>,
    
    return_type_test_type<std::array<long, 5>, long double (*)(long), std::array<long double, 5>>,
    
    return_type_test_type<std::array<long long int, 5>, long double (*)(long long int), std::array<long double, 5>>,
    
    return_type_test_type<std::array<float, 5>, long double (*)(float), std::array<long double, 5>>,
    
    return_type_test_type<std::array<double, 5>, long double (*)(double), std::array<long double, 5>>,
    
    return_type_test_type<std::array<long double, 5>, long double (*)(long double), std::array<long double, 5>>,
    

All suggestions are welcome.

The summary information:

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.