Add and use C++17-style conjunction/disjunction

C++17 has std::conjunction/disjunction which are very similar to our
`all_of_t` and `any_of_t` in practice.  (They can differ if you pass in
a Predicate with a non-bool ::value, but we don't do that).

Essentially `detail::all_of_t<P, T...>` is equivalent to
`std::conjunction<P<T>...>`, and `any_of_t<P, T...>` corresponds to
`std::disjunction<P<T>...>`.

Unlike `any`/`all_of_t`, `dis`/`conjunction` aren't tied to a single
predicate, so it can be used as a compile-time `and` across multiple
types with `::value`s, allowing some nice reduction in code in a few
places.

I also removed the `count_t` since `any_of_t` and `all_of_t` was the
only thing using it.

This commit also uses aliases to the `std` implementations for C++14/17
features when under the appropriate compiler mode, as we were already
doing for a few things (like index_sequence).  Most of these aren't
saving much (the implementation for enable_if_t, for example, is
trivial), but I think it makes the intention of the code instantly
clear.

Since this introduces a slightly different implementation when compiling
under C++17, I've also added a travis-ci build to compile in C++17 mode
under gcc 6.  (I tried adding an experimental build with a recent gcc 7
snapshot, but pybind triggers an ICE in c++17 mode with the current g++
snapshot.)

Author: jagerman

.travis.yml

@@ -20,6 +20,9 @@ matrix:
   - sudo: true
     services: docker
     env: PYTHON=3.5 CPP=14 GCC=6 DEBUG=1
+  - sudo: true
+    services: docker
+    env: PYTHON=3.5 CPP=17 GCC=6
   - os: osx
     osx_image: xcode7.3
     env: PYTHON=2.7 CPP=14 CLANG

include/pybind11/cast.h

@@ -1004,31 +1004,32 @@ class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caste
 // - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
 //   must have ref_count() == 1)h
 // If any of the above are not satisfied, we fall back to copying.
-template <typename T, typename SFINAE = void> struct move_is_plain_type : std::false_type {};
-template <typename T> struct move_is_plain_type<T, enable_if_t<
-        !std::is_void<T>::value && !std::is_pointer<T>::value && !std::is_reference<T>::value && !std::is_const<T>::value
-    >> : std::true_type { };
+template <typename T> using move_is_plain_type = negation<disjunction<
+    std::is_void<T>, std::is_pointer<T>, std::is_reference<T>, std::is_const<T>
+>>;
 template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
-template <typename T> struct move_always<T, enable_if_t<
-        move_is_plain_type<T>::value &&
-        !std::is_copy_constructible<T>::value && std::is_move_constructible<T>::value &&
-        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
-    >> : std::true_type { };
+template <typename T> struct move_always<T, enable_if_t<conjunction<
+    move_is_plain_type<T>,
+    negation<std::is_copy_constructible<T>>,
+    std::is_move_constructible<T>,
+    std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>
+>::value>> : std::true_type {};
 template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
-template <typename T> struct move_if_unreferenced<T, enable_if_t<
-        move_is_plain_type<T>::value &&
-        !move_always<T>::value && std::is_move_constructible<T>::value &&
-        std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>::value
-    >> : std::true_type { };
-template <typename T> using move_never = std::integral_constant<bool, !move_always<T>::value && !move_if_unreferenced<T>::value>;
+template <typename T> struct move_if_unreferenced<T, enable_if_t<conjunction<
+    move_is_plain_type<T>,
+    negation<move_always<T>>,
+    std::is_move_constructible<T>,
+    std::is_same<decltype(std::declval<type_caster<T>>().operator T&()), T&>
+>::value>> : std::true_type {};
+template <typename T> using move_never = negation<disjunction<move_always<T>, move_if_unreferenced<T>>>;
 
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
 // reference or pointer to a local variable of the type_caster.  Basically, only
 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
 // everything else returns a reference/pointer to a local variable.
-template <typename type> using cast_is_temporary_value_reference = bool_constant<
-    (std::is_reference<type>::value || std::is_pointer<type>::value) &&
-    !std::is_base_of<type_caster_generic, make_caster<type>>::value
+template <typename type> using cast_is_temporary_value_reference = conjunction<
+    disjunction<std::is_reference<type>, std::is_pointer<type>>,
+    negation<std::is_base_of<type_caster_generic, make_caster<type>>>
 >;
 
 // Basic python -> C++ casting; throws if casting fails
@@ -1427,14 +1428,14 @@ class unpacking_collector {
 
 /// Collect only positional arguments for a Python function call
 template <return_value_policy policy, typename... Args,
-          typename = enable_if_t<all_of_t<is_positional, Args...>::value>>
+          typename = enable_if_t<conjunction<is_positional<Args>...>::value>>
 simple_collector<policy> collect_arguments(Args &&...args) {
     return simple_collector<policy>(std::forward<Args>(args)...);
 }
 
 /// Collect all arguments, including keywords and unpacking (only instantiated when needed)
 template <return_value_policy policy, typename... Args,
-          typename = enable_if_t<!all_of_t<is_positional, Args...>::value>>
+          typename = enable_if_t<!conjunction<is_positional<Args>...>::value>>
 unpacking_collector<policy> collect_arguments(Args &&...args) {
     // Following argument order rules for generalized unpacking according to PEP 448
     static_assert(

include/pybind11/common.h

@@ -345,17 +345,39 @@ struct internals {
 /// Return a reference to the current 'internals' information
 inline internals &get_internals();
 
-/// Index sequence for convenient template metaprogramming involving tuples
+/// from __cpp_future__ import (convenient aliases from C++14/17)
 #ifdef PYBIND11_CPP14
+using std::enable_if_t;
+using std::conditional_t;
 using std::index_sequence;
 using std::make_index_sequence;
 #else
+template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
 template<size_t ...> struct index_sequence  { };
 template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { };
 template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; };
 template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type;
 #endif
 
+#if defined(PYBIND11_CPP17) || defined(_MSC_VER)
+using std::bool_constant;
+using std::conjunction;
+using std::disjunction;
+using std::negation;
+#else
+template <bool B> using bool_constant = std::integral_constant<bool, B>;
+template <typename...> struct conjunction : std::true_type {};
+template <typename B> struct conjunction<B> : B {};
+template <typename B, typename... Bmore> struct conjunction<B, Bmore...>
+    : conditional_t<B::value, conjunction<Bmore...>, B> {};
+template <typename...> struct disjunction : std::false_type {};
+template <typename B> struct disjunction<B> : B {};
+template <typename B, typename... Bmore> struct disjunction<B, Bmore...>
+    : conditional_t<B::value, B, disjunction<Bmore...>> {};
+template <class T> using negation = bool_constant<!T::value>;
+#endif
+
 /// Strip the class from a method type
 template <typename T> struct remove_class { };
 template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); };
@@ -377,35 +399,11 @@ struct void_type { };
 /// Helper template which holds a list of types
 template <typename...> struct type_list { };
 
-/// from __cpp_future__ import (convenient aliases from C++14/17)
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <class T> using negation = bool_constant<!T::value>;
-template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
-
 /// Compile-time integer sum
 constexpr size_t constexpr_sum() { return 0; }
 template <typename T, typename... Ts>
 constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
 
-// Counts the number of types in the template parameter pack matching the predicate
-#if !defined(_MSC_VER)
-template <template<typename> class Predicate, typename... Ts>
-using count_t = std::integral_constant<size_t, constexpr_sum(Predicate<Ts>::value...)>;
-#else
-// MSVC workaround (2015 Update 3 has issues with some member type aliases and constexpr)
-template <template<typename> class Predicate, typename... Ts> struct count_t;
-template <template<typename> class Predicate> struct count_t<Predicate> : std::integral_constant<size_t, 0> {};
-template <template<typename> class Predicate, class T, class... Ts>
-struct count_t<Predicate, T, Ts...> : std::integral_constant<size_t, Predicate<T>::value + count_t<Predicate, Ts...>::value> {};
-#endif
-
-/// Return true if all/any Ts satify Predicate<T>
-template <template<typename> class Predicate, typename... Ts>
-using all_of_t = bool_constant<(count_t<Predicate, Ts...>::value == sizeof...(Ts))>;
-template <template<typename> class Predicate, typename... Ts>
-using any_of_t = bool_constant<(count_t<Predicate, Ts...>::value > 0)>;
-
 // Extracts the first type from the template parameter pack matching the predicate, or Default if none match.
 template <template<class> class Predicate, class Default, class... Ts> struct first_of;
 template <template<class> class Predicate, class Default> struct first_of<Predicate, Default> {

include/pybind11/eigen.h

@@ -42,9 +42,10 @@ template <typename T> using is_eigen_ref = is_template_base_of<Eigen::RefBase, T
 // basically covers anything that can be assigned to a dense matrix but that don't have a typical
 // matrix data layout that can be copied from their .data().  For example, DiagonalMatrix and
 // SelfAdjointView fall into this category.
-template <typename T> using is_eigen_base = bool_constant<
-    is_template_base_of<Eigen::EigenBase, T>::value
-    && !is_eigen_dense<T>::value && !is_eigen_sparse<T>::value
+template <typename T> using is_eigen_base = conjunction<
+    is_template_base_of<Eigen::EigenBase, T>,
+    negation<is_eigen_dense<T>>,
+    negation<is_eigen_sparse<T>>
 >;
 
 template<typename Type>

include/pybind11/pybind11.h

@@ -924,12 +924,7 @@ class class_ : public detail::generic_type {
     template <typename T> using is_holder = detail::is_holder_type<type_, T>;
     template <typename T> using is_subtype = detail::bool_constant<std::is_base_of<type_, T>::value && !std::is_same<T, type_>::value>;
     template <typename T> using is_base = detail::bool_constant<std::is_base_of<T, type_>::value && !std::is_same<T, type_>::value>;
-    template <typename T> using is_valid_class_option =
-        detail::bool_constant<
-            is_holder<T>::value ||
-            is_subtype<T>::value ||
-            is_base<T>::value
-        >;
+    template <typename T> struct is_valid_class_option : detail::disjunction<is_holder<T>, is_subtype<T>, is_base<T>> {};
 
 public:
     using type = type_;
@@ -938,7 +933,7 @@ class class_ : public detail::generic_type {
     using holder_type = detail::first_of_t<is_holder, std::unique_ptr<type>, options...>;
     using instance_type = detail::instance<type, holder_type>;
 
-    static_assert(detail::all_of_t<is_valid_class_option, options...>::value,
+    static_assert(detail::conjunction<is_valid_class_option<options>...>::value,
             "Unknown/invalid class_ template parameters provided");
 
     PYBIND11_OBJECT(class_, generic_type, PyType_Check)

include/pybind11/pytypes.h

@@ -257,8 +257,8 @@ class accessor : public object_api<accessor<Policy>> {
 
     template <typename T = Policy>
     PYBIND11_DEPRECATED("Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)")
-    explicit operator enable_if_t<std::is_same<T, accessor_policies::str_attr>::value ||
-            std::is_same<T, accessor_policies::obj_attr>::value, bool>() const {
+    explicit operator enable_if_t<disjunction<std::is_same<T, accessor_policies::str_attr>,
+            std::is_same<T, accessor_policies::obj_attr>>::value, bool>() const {
         return hasattr(obj, key);
     }
     template <typename T = Policy>
@@ -410,12 +410,10 @@ class args_proxy : public handle {
 template <typename T> using is_keyword = std::is_base_of<arg, T>;
 template <typename T> using is_s_unpacking = std::is_same<args_proxy, T>; // * unpacking
 template <typename T> using is_ds_unpacking = std::is_same<kwargs_proxy, T>; // ** unpacking
-template <typename T> using is_positional = bool_constant<
-    !is_keyword<T>::value && !is_s_unpacking<T>::value && !is_ds_unpacking<T>::value
->;
-template <typename T> using is_keyword_or_ds = bool_constant<
-    is_keyword<T>::value || is_ds_unpacking<T>::value
->;
+template <typename T> using is_positional = negation<disjunction<
+    is_keyword<T>, is_s_unpacking<T>, is_ds_unpacking<T>
+>>;
+template <typename T> using is_keyword_or_ds = disjunction<is_keyword<T>, is_ds_unpacking<T>>;
 
 // Call argument collector forward declarations
 template <return_value_policy policy = return_value_policy::automatic_reference>
@@ -754,7 +752,7 @@ class dict : public object {
         if (!m_ptr) pybind11_fail("Could not allocate dict object!");
     }
     template <typename... Args,
-              typename = detail::enable_if_t<detail::all_of_t<detail::is_keyword_or_ds, Args...>::value>,
+              typename = detail::enable_if_t<detail::conjunction<detail::is_keyword_or_ds<Args>...>::value>,
               // MSVC workaround: it can't compile an out-of-line definition, so defer the collector
               typename collector = detail::deferred_t<detail::unpacking_collector<>, Args...>>
     explicit dict(Args &&...args) : dict(collector(std::forward<Args>(args)...).kwargs()) { }

include/pybind11/stl_bind.h

@@ -253,8 +253,8 @@ void vector_modifiers(enable_if_t<std::is_copy_constructible<typename Vector::va
 
 // If the type has an operator[] that doesn't return a reference (most notably std::vector<bool>),
 // we have to access by copying; otherwise we return by reference.
-template <typename Vector> using vector_needs_copy = bool_constant<
-    !std::is_same<decltype(std::declval<Vector>()[typename Vector::size_type()]), typename Vector::value_type &>::value>;
+template <typename Vector> using vector_needs_copy = detail::negation<
+    std::is_same<decltype(std::declval<Vector>()[typename Vector::size_type()]), typename Vector::value_type &>>;
 
 // The usual case: access and iterate by reference
 template <typename Vector, typename Class_>