Universal and existential quantification using C++ template magic - c++

Question

Is there a way to implement universal and existential quantification using C++ template magic (maybe using SFINAE etc.)? Something like this:
template
<
template <typename Argument> class Predicate
>
struct UniversalQuantification
{
static const bool value =
/*for any Argument Predicate<Argument>::value == true ? true : false*/;
};
template
<
template <typename Argument> class Predicate
>
struct ExistentialQuantification
{
static const bool value =
/*for some Argument Predicate<Argument>::value == true ? true : false*/;
};

Answer 1

If you pass a finite set of possible template arguments to the template, it is indeed possible to evaluate this at compile-time. However, it is impossible to evaluate this for every argument the passed template has been used with, as these types/args are unknown.
This is the solution for a finite set of arguments for the ExistentialQuantification class. In order to achieve the behaviour of the UniversalQuantification class, you simple have to change the || to a &&:
template<typename Arg>
struct Pred1;
template<>
struct Pred1<float> { static const bool value = true; };
template<>
struct Pred1<double> { static const bool value = false; };
template<>
struct Pred1<long> { static const bool value = true; };
template<template <typename Argument> class Predicate, typename... Types>
struct ExistentialQuantification;
template<template <typename Argument> class Predicate, typename Arg>
struct ExistentialQuantification<Predicate, Arg>
{
static const bool value = Predicate<Arg>::value;
};
template<template <typename Argument> class Predicate, typename Arg, typename... Types>
struct ExistentialQuantification<Predicate, Arg, Types...>
{
static const bool value = Predicate<Arg>::value || ExistentialQuantification<Predicate, Types...>::value;
};
int main()
{
std::cout << ExistentialQuantification<Pred1, long, double, float>::value << std::endl;
}
In this example, value will evaluate to true || false || true and is thus true of course.

Answer 2

Ok, if we're just being smart here, and if we're allowed a couple of constraints, here are two constraints on the programmer, that really solve the problem, smoothly.
if a predicate is needed in the code that is always true, only use the following:
template<typename> struct always : std::true_type { };
if a predicate is needed in the code that is never true, only use the following:
template<typename> struct never : std::false_type { };
Now, the solution is simple:
template<template<typename> class>
struct UniversalQuantification : std::false_type { };
template<>
struct UniversalQuantification<always> : std::true_type { };
template<template<typename> class>
struct ExistentialQuantification : std::true_type { };
template<>
struct ExistentialQuantification<never> : std::false_type { };

Answer 3

Using a library like Boost.MPL, if you can put your universe of allowed types into a type list, e.g. in a boost::mpl::vector, then your quantifiers are just the compile-time version of std::all_of and std::any_of. You can define them as:
#include <ios>
#include <iostream>
#include <type_traits> // is_same, is_base_of
#include <boost/mpl/end.hpp> // end
#include <boost/mpl/find_if.hpp> // find_if
#include <boost/mpl/lambda.hpp> // lambda
#include <boost/mpl/logical.hpp> // not_
#include <boost/mpl/placeholders.hpp> // _1
#include <boost/mpl/vector.hpp> // vector
template<typename Sequence, typename Pred>
struct all_of
:
std::is_same< typename
boost::mpl::find_if<
Sequence,
boost::mpl::not_<Pred>
>::type, typename
boost::mpl::end<Sequence>::type
>
{};
template<typename Sequence, typename Pred>
struct none_of
:
all_of< Sequence, boost::mpl::not_< Pred > >
{};
template<typename Sequence, typename Pred>
struct any_of
:
boost::mpl::not_< none_of< Sequence, Pred > >
{};
struct B {};
struct D : B {};
struct X {};
using Universe = boost::mpl::vector<B, D, X>;
using Predicate = boost::mpl::lambda<std::is_base_of<B, boost::mpl::_1>>;
int main()
{
std::cout << std::boolalpha;
std::cout << all_of<Universe, Predicate>{} << "\n";
std::cout << any_of<Universe, Predicate>{} << "\n";
}
Live Example.
As you can see, because X does not have B as a base class, the universal quantification fails, but because D does have B as a base class, the existential quantification succeeds.

Answer 4

Well, if we're just talking about n-ary (variadic) functions and, or as in the answer by TemplateRex, here's my preferred way without Boost:
using _true = std::integral_constant <bool, true>;
using _false = std::integral_constant <bool, false>;
template <bool C, typename T, typename E>
using _if = typename std::conditional <C, T, E>::type;
template <typename...> struct _and;
template <typename...> struct _or;
template <typename A, typename... B>
struct _and <A, B...> : _if <A{}, _and <B...>, _false> { };
template <typename A, typename... B>
struct _or <A, B...> : _if <A{}, _true, _or <B...> > { };
template <> struct _and <> : _true { };
template <> struct _or <> : _false { };