12

So I'm trying to make a type trait that says whether two "outer" class types are the same.

ie. std::vector<int> is the same as std::vector<double>, I don't care about any inner arguments for my type trait.

A problem that I had with trying to make a generic type trait for this is that I only know how to handle the typed variadic templates separately to the non-typed ones, which appears to stop me from making it generic.

Is it possible to handle any permutation of typed and non-typed template arguments?

Here's what I've implemented (including an example of where it fails):

// g++ -std=c++17

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

// If the outer types don't match
template <typename, typename>
struct is_outer_type_same : std::false_type {};


// if the arguments of the compared Type contains only types
// ie. std::vector<int,std::allocator<int>>
// (the inner arguments are also types)

template <template<typename...> typename OuterType,
                   typename... InnerTypes1,
                   typename... InnerTypes2
         >
struct is_outer_type_same < OuterType<InnerTypes1...>,
                            OuterType<InnerTypes2...>
                          >
        : std::true_type {};


// if the arguments of the compared Type contains only non-types
// eg. SomeClassName<4,5,2>

template <template<auto...> typename OuterType,
                   auto... InnerVariables1,
                   auto... InnerVariables2
         >
struct is_outer_type_same < OuterType<InnerVariables1...>,
                            OuterType<InnerVariables2...>
                          >
        : std::true_type {};


// if the arguments of the compared Type contains a single
// typed-argument followed by some non-typed arguments
// ie. std::array<int, 4>

template <template<typename, auto...> typename OuterType,
        typename InnerType1, auto... InnerVariables1,
        typename InnerType2, auto... InnerVariables2
         >
struct is_outer_type_same < OuterType<InnerType1, InnerVariables1...>,
                            OuterType<InnerType2, InnerVariables2...>
                          >
        : std::true_type {};


// For any outer types whose arguments have the pattern:
// single variable argument followed by a sequence of typed arguments:

template <template<auto, typename...> typename OuterType,
    auto InnerVariable1, typename... InnerTypes1,
    auto InnerVariable2, typename... InnerTypes2
         >
struct is_outer_type_same < OuterType<InnerVariable1, InnerTypes1...>, 
                            OuterType<InnerVariable2, InnerTypes2...>
                          >
        : std::true_type {};


// This is to make it neater to evaluate:

template <typename S, typename T>
inline constexpr bool is_outer_type_same_v
                    = is_outer_type_same<S,T>::value;


// Example type that fails to be handled
// correctly by the above struct templates: 
template <typename A, typename B, int C>
struct ExampleType
{
    A data1;
    B data2;
    const int data3 = C;
};


int main ()
{   
    // Examples to show where it fails:

    std::cout << "Fails to find match for ExampleType: "

    << is_outer_type_same_v<ExampleType<double,int,2>,
                            ExampleType<double,int,2>>

    << std::endl << std::endl



    // Examples to show where it works:

    << "Finds correctly: " << std::endl


    << std::endl << "Matches for std::vector: "

    << is_outer_type_same_v<std::vector<int>,
                            std::vector<double>>

    << is_outer_type_same_v<std::vector<std::vector<int>>,
                            std::vector<double>>

    << is_outer_type_same_v<std::vector<std::array<int,3>>,
                            std::vector<double>>


    << std::endl << "Mismatches for std::vector: "

    << is_outer_type_same_v<int,
                            std::vector<int>>

    << is_outer_type_same_v<std::array<int, 3>,
                            std::vector<int>>

    << is_outer_type_same_v<std::array<std::vector<int>, 3>,
                            std::vector<int>>


    << std::endl << "Matches for std::array: "

    << is_outer_type_same_v<std::array<int, 3>,
                            std::array<double, 7>>

    << is_outer_type_same_v<std::array<std::vector<int>, 7>,
                            std::array<double, 2>>

    << is_outer_type_same_v<std::array<std::array<int,3>, 8>,
                            std::array<std::vector<double>, 5>>


    << std::endl << "Mismatches for std::array: "

    << is_outer_type_same_v<int,
                            std::array<int,2>>

    << is_outer_type_same_v<std::vector<int>,
                            std::array<int,8>>

    << is_outer_type_same_v<std::vector<std::array<int,3>>,
                            std::array<int,2>>

    << std::endl;

    return 0;
}
Elliott
  • 2,603
  • 2
  • 18
  • 35
  • 7
    AFAIK there is no generic solution for this. We either need reflection or some new type of template syntax that allows the parameter to be a type or non type parameter. – NathanOliver Dec 04 '19 at 16:03
  • This is indeed a limitation that the language currently does not have a work-around for. At least AFAIK. At the same time, mixing typed and untyped template parameters are fairly rare. Your version with `auto...` will work in most cases. – super Dec 04 '19 at 16:03
  • 3
    @super I'm not sure I would call it rare. `std::array` is a major use case and there are plenty of classes out there like it for matrices and things of the like. – NathanOliver Dec 04 '19 at 16:04
  • 5
    @NathanOliver-ReinstateMonica And `std::array` styled things will work with the double-pack solution given here. It's not rare to mix, it rare to mix in the form of `non-type, type, non-type`, where as `types.., non-types...` is fairly common. – super Dec 04 '19 at 16:06
  • @super Ah. Yeah, I have not seen anyone doing that. – NathanOliver Dec 04 '19 at 16:09
  • @super How would you handle the case of `types..., non-types...`? When I try to do that I always get errors. It’s not as generic as original question, but an answer to it would make my solution much better than what I have now... – Elliott Dec 04 '19 at 16:57
  • @ElliottSmith I don't think even that can be done in a generic way. You would have to add specialization for `type, non-types...`, `type, type, non-types...` ect. Not very clean code, but once you stuff it away in your header you hpefully don't have to look at it very often. :-) – super Dec 04 '19 at 17:51
  • 3
    @ElliottSmith Yes, that's what I mean when I say you need to add specializations. The `non-type` can be a pack, but the leading types would need one specialization each. `type, non-types...` and `type, type, non-type...` would be 2 specialization. If you add 10 you should have the behaviour you want with some arguably ugly code. – super Dec 04 '19 at 18:26
  • @super Okay, Thanks for your help. It sounds like it’s not worth adding more specialisations without a specific need. It’s a shame to not have this functionality for library implementations... – Elliott Dec 04 '19 at 18:34
  • 3
    Possible duplicate of [Unify type and non-type template parameters](https://stackoverflow.com/questions/29342064/unify-type-and-non-type-template-parameters) – Davis Herring Dec 06 '19 at 03:30
  • @DavisHerring, Actually that question seems to combine my problem with the problem of passing incomplete data types as arguments, meaning each separate struct that handles the problem needs its own type/non-type permutation *before* specialization - hence that appears to be a much harder problem. Also the accepted answer is to the problem hasn't solved the questioner's original problem, nor has it solved mine. Also if they used my code they code solve it more neatly anyway, because I'm able to take advantage of c++17. What I'd like to know is if it's possible with modern c++... – Elliott Dec 23 '19 at 15:43
  • @Elliott-ReinstateMonica: When your question is “Is it possible to…?”, an answer that shows as close as you can get is an answer. There may well be a better duplicate that uses (and shows the limitations of) `auto` template parameters. – Davis Herring Dec 23 '19 at 15:48
  • Very interesting question, despite the answer seems to be "it's not possible". Fwiw, I think the question could be rephrased to "How do I pull the first template argument, being it a type or non-type, out of a type?". Well, pulling it out means putting it somewhere, and that somewhere can't be assigned indefferently a type and non-type. – Enlico Apr 25 '21 at 08:16
  • @Enlico, Maybe I wasn't so clear, but the desired result should always be a `type`. I'm not interested n the first `type`/`non-type` of the list of args, instead i want to ignore the args entirely - I dont care about them in this case. – Elliott Apr 25 '21 at 14:38

1 Answers1

0

Can you do it generically? No, not yet. But there are ways to do this (although they aren't the cleanest).

The first step would be to compare the inner "values". While struct template arguments don't do exactly what you want, function template arguments do (you can create "overloads" for typename/auto).

So with that knowledge, you can do something like this:

enum version {
    type, value
};

template <version...EE>
struct version_list {};

template <version...EE>
inline constexpr version_list<EE...> VL {};


template <template <class> class C, class T1>
constexpr auto decompose(C<T1>&)     { return VL<type>; }

template <template <auto> class C, auto V1>
constexpr auto decompose(C<V1>&)     { return VL<value>; }

template <template <class, class> class C, class T1, class T2>
constexpr auto decompose(C<T1, T2>&) { return VL<type, type>; }

template <template <class, auto> class C, class T1, auto V1>
constexpr auto decompose(C<T1, V1>&) { return VL<type, value>; }

/* continue repeating for different variations... */

This will allow you to compare the amount/type of template arguments like so:

template <typename T>
using decompose_t = decltype(decompose(std::declval<T&>()));

template <version...EE1, version...EE2>
constexpr bool compare_versions(
    const version_list<EE1...>, 
    const version_list<EE2...>) 
{
    if constexpr(sizeof...(EE1) != sizeof...(EE2)) return false;
    else return ((EE1 == EE2) && ...);
}

template <typename T, typename U>
inline constexpr bool compare_versions_v 
     = compare_versions(decompose_t<T>{}, decompose_t<U>{});

Finally, you can create your comparison like so:

template <typename T, typename U>
constexpr bool is_outer_type_same() {
    if(compare_versions_v<T, U>) {
        /* Comparison logic */
    }
    else return false;
}

template <typename T, typename U>
inline constexpr bool is_outer_type_same_v = is_outer_type_same<T, U>();

Where you don't even attempt to check if the outer types match if they don't have the same template parameters.

I left out the actual comparison logic because it's very similar to what you would be doing in the first check. You would probably want to write some code to generate all these functions and write them to a file, which you can then include/import into the code actually being exposed.

But all of this could be avoided if we had typename auto :P

Eightfold
  • 41
  • 2