The right way to define a reverse comparer - c++

Question

I have a simple reverse comparer defined as follows:
template <class T, class Compare>
class ReverseCompare
{
public:
//The same as Container::value_type, for example std::shared_ptr<A>.
using value_type = T;
//The type of the key for heterogeneous lookup.
using key_type = typename Compare::key_type;
ReverseCompare(Compare comp = Compare()) : m_comp(std::move(comp))
{
}
constexpr bool operator()(const T& left, const T& right) const
{
return m_comp(right, left);
}
constexpr bool operator()(const T& val, const key_type& id) const
{
return m_comp(id, val);
}
constexpr bool operator()(const key_type& id, const T& val) const
{
return m_comp(val, id);
}
using is_transparent = void;
private:
Compare m_comp;
};
template <class T, class Compare>
ReverseCompare<T, Compare> reverse_comparer(Compare comp)
{
return ReverseCompare<T, Compare>(std::move(comp));
}
it assumes that its underlying comparer is transparent like this:
struct Comparator
{
using is_transparent = std::true_type;
bool operator()(const sw& lhs, const std::string& rhs) const { return lhs.getString() < rhs; }
bool operator()(const std::string& lhs, const sw& rhs) const { return lhs < rhs.getString(); }
bool operator()(const sw& lhs, const sw& rhs) const { return lhs < rhs; }
};
but it would not compile if the underlying comparer is a simple lambda, for example:
void main()
{
auto comp = [](const int& left, const int& right) -> bool
{
return left < right;
};
auto r_comp = reverse_comparer<int>(comp);
return 1;
}
GCC error message:
prog.cc: In instantiation of 'class ReverseCompare<int, main()::<lambda(const int&, const int&)> >':
prog.cc:53:36: required from here
prog.cc:12:11: error: no type named 'key_type' in 'struct main()::<lambda(const int&, const int&)>'
12 | using key_type = typename Compare::key_type;
| ^~~~~~~~
what is the right way to fix this?
Should I define a separate class or there is a better way?
EDIT1
I need key_type because I have CompositeCompare that requires it:
template <class T, class ... Cs>
class CompositeCompare
{
public:
//The same as Container::value_type, for example std::shared_ptr<A>.
using value_type = T;
//The type of the key for heterogeneous lookup.
using key_type = std::tuple<typename std::decay_t<Cs>::key_type...>;
//Can be used if all the comparers are default constructible.
CompositeCompare() = default;
//A template parameter pack cannot have a default argument.
CompositeCompare(Cs... comp) : m_comps(std::move(comp) ...)
{
}
constexpr bool operator()(const T& left, const T& right) const
{
return Compare<0u>(left, right);
}
constexpr bool operator()(const T& val, const key_type& id) const
{
return Compare<0u>(val, id);
}
constexpr bool operator()(const key_type& id, const T& val) const
{
return Compare<0u>(id, val);
}
using is_transparent = void;
private:
using Tuple = std::tuple<std::decay_t<Cs>...>;
template <std::size_t Index>
bool Compare(const T& left, const T& right) const
{
if constexpr (Index == std::tuple_size_v<Tuple>)
{
static_cast<void>(left);
static_cast<void>(right);
return false;
}
else
{
auto& comp = std::get<Index>(m_comps);
if (comp(left, right))
{
return true;
}
if (comp(right, left))
{
return false;
}
return Compare<Index + 1>(left, right);
}
}
template <std::size_t Index>
bool Compare(const T& left, const key_type& right_key) const
{
if constexpr (Index == std::tuple_size_v<Tuple>)
{
static_cast<void>(left);
static_cast<void>(right_key);
return false;
}
else
{
auto& comp = std::get<Index>(m_comps);
auto right = std::get<Index>(right_key);
if (comp(left, right))
{
return true;
}
if (comp(right, left))
{
return false;
}
return Compare<Index + 1>(left, right_key);
}
}
template <std::size_t Index>
bool Compare(const key_type& left_key, const T& right) const
{
if constexpr (Index == std::tuple_size_v<Tuple>)
{
static_cast<void>(left_key);
static_cast<void>(right);
return false;
}
else
{
auto& comp = std::get<Index>(m_comps);
auto left = std::get<Index>(left_key);
if (comp(left, right))
{
return true;
}
if (comp(right, left))
{
return false;
}
return Compare<Index + 1>(left_key, right);
}
}
Tuple m_comps;
};
template <class T, class ... Cs>
CompositeCompare<T, Cs ...> compose_comparers(Cs... comp)
{
return CompositeCompare<T, Cs ...>(std::move(comp) ...);
}
CompositeCompare assumes all its underlying comparers are transparent, and if they are not it ideally should not be transparent. Its usage:
struct X
{
int a;
std::string b;
};
using ACompare = ...
using BCompare = ...
auto comp = compose_comparers<X>(ACompare(), BCompare());