C++17: Update from murrayc-tuple-utils.

From https://github.com/murraycu/murrayc-tuple-utils/commits/master
This also uses the C++17 nested namespace syntax.

Apart from tuple_transform_each, which seems to have a memory access
problem, with both g++ and clang++, in its C++17 version.

sigc++/tuple-utils/tuple_cdr.h

@@ -22,11 +22,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace sigc
-{
-
-namespace internal
-{
+namespace sigc::internal {
 
 /**
  * Get the type of a tuple without the first item.
@@ -41,11 +37,11 @@ struct tuple_type_cdr<std::tuple<H, T...>>
   using type = std::tuple<T...>;
 };
 
-namespace detail
-{
+namespace detail {
 
 template <typename T, std::size_t... I>
-constexpr decltype(auto)
+constexpr
+decltype(auto)
 tuple_cdr_impl(T&& t, std::index_sequence<0, I...>)
 {
   using cdr = typename tuple_type_cdr<std::decay_t<T>>::type;
@@ -59,19 +55,17 @@ tuple_cdr_impl(T&& t, std::index_sequence<0, I...>)
  * This is analogous to std::tuple_cat().
  */
 template <typename T>
-constexpr decltype(auto)
-tuple_cdr(T&& t)
-{
-  // We use std::decay_t<> because tuple_size is not defined for references.
+constexpr
+decltype(auto)
+tuple_cdr(T&& t) {
+  //We use std::decay_t<> because tuple_size is not defined for references.
   constexpr auto size = std::tuple_size<std::decay_t<T>>::value;
 
   static_assert(size != 0, "tuple size must be non-zero");
   using seq = std::make_index_sequence<size>;
   return detail::tuple_cdr_impl(std::forward<T>(t), seq{});
 }
 
-} // namespace internal
-
-} // namespace sigc
+} // namespace sigc::internal
 
-#endif // SIGC_TUPLE_UTILS_TUPLE_CDR_H
+#endif //SIGC_TUPLE_UTILS_TUPLE_CDR_H

sigc++/tuple-utils/tuple_end.h

@@ -20,58 +20,55 @@
 
 #include <sigc++/tuple-utils/tuple_cdr.h>
 
-namespace sigc
-{
+namespace sigc::internal {
 
-namespace internal
-{
-
-namespace detail
-{
+namespace detail {
 
 template <typename T, std::size_t remove_from_start>
-struct tuple_end_impl
-{
-  constexpr static decltype(auto) // typename tuple_type_end<T, size - remove_from_start>::type
-    tuple_end(T&& t)
-  {
-    static_assert(remove_from_start > 0, "remove_from_start must be more than zero.");
-
-    using cdr = typename tuple_type_cdr<std::decay_t<T>>::type;
-    return tuple_end_impl<cdr, remove_from_start - 1>::tuple_end(tuple_cdr(std::forward<T>(t)));
-  }
-};
-
-template <typename T>
-struct tuple_end_impl<T, 1>
-{
-  constexpr static decltype(auto) tuple_end(T&& t) { return tuple_cdr(std::forward<T>(t)); }
+struct tuple_type_end_impl {
+  using type = typename tuple_type_end_impl<typename tuple_type_cdr<std::decay_t<T>>::type,
+    remove_from_start - 1>::type;
 };
 
 template <typename T>
-struct tuple_end_impl<T, 0>
-{
-  constexpr static decltype(auto) tuple_end(T&& t) { return std::forward<T>(t); }
+struct tuple_type_end_impl<T, 0> {
+  using type = T;
 };
 
 } // detail namespace
 
+/**
+ * Get the type of a tuple with the last @a len types of the original.
+ */
+template <typename T, std::size_t len>
+struct tuple_type_end
+  : detail::tuple_type_end_impl<T, std::tuple_size<T>::value - len> {};
+
 /**
  * Get the tuple with the last @a len items of the original.
  */
 template <std::size_t len, typename T>
-constexpr decltype(auto) // typename tuple_type_end<T, len>::type
-  tuple_end(T&& t)
-{
-  // We use std::decay_t<> because tuple_size is not defined for references.
+constexpr
+decltype(auto) // typename tuple_type_end<T, len>::type
+tuple_end(T&& t) {
+  //We use std::decay_t<> because tuple_size is not defined for references.
   constexpr auto size = std::tuple_size<std::decay_t<T>>::value;
   static_assert(len <= size, "The tuple size must be less than or equal to the length.");
-  constexpr auto size_start = size - len;
-  return detail::tuple_end_impl<T, size_start>::tuple_end(std::forward<T>(t));
-}
 
-} // namespace internal
+  if constexpr(len == 0) {
+    // Recursive calls to tuple_cdr() would result in this eventually,
+    // but this avoids the extra work:
+    return std::tuple<>();
+  } else if constexpr(size - len == 0) {
+    return std::forward<T>(t);
+  } else if constexpr(size - len == 1) {
+    return tuple_cdr(std::forward<T>(t));
+  } else {
+    return tuple_end<len>(
+        tuple_cdr(std::forward<T>(t)));
+  }
+}
 
-} // namespace sigc
+} // namespace sigc::internal;
 
-#endif // SIGC_TUPLE_UTILS_TUPLE_END_H
+#endif //SIGC_TUPLE_UTILS_TUPLE_END_H

sigc++/tuple-utils/tuple_start.h

@@ -21,21 +21,15 @@
 #include <tuple>
 #include <utility>
 
-namespace sigc
-{
+namespace sigc::internal {
 
-namespace internal
-{
-
-namespace detail
-{
+namespace detail {
 
 template <typename T, typename Seq>
 struct tuple_type_start_impl;
 
 template <typename T, std::size_t... I>
-struct tuple_type_start_impl<T, std::index_sequence<I...>>
-{
+struct tuple_type_start_impl<T, std::index_sequence<I...>> {
   using type = std::tuple<typename std::tuple_element<I, T>::type...>;
 };
 
@@ -45,21 +39,20 @@ struct tuple_type_start_impl<T, std::index_sequence<I...>>
  * Get the type of a tuple with just the first @len items.
  */
 template <typename T, std::size_t len>
-struct tuple_type_start : detail::tuple_type_start_impl<T, std::make_index_sequence<len>>
-{
-};
+struct tuple_type_start
+  : detail::tuple_type_start_impl<T, std::make_index_sequence<len>> {};
 
-namespace detail
-{
+namespace detail {
 
 template <typename T, typename Seq>
 struct tuple_start_impl;
 
 template <typename T, std::size_t... I>
-struct tuple_start_impl<T, std::index_sequence<I...>>
-{
-  static constexpr decltype(auto) tuple_start(T&& t)
-  {
+struct tuple_start_impl<T, std::index_sequence<I...>> {
+  static
+  constexpr
+  decltype(auto)
+  tuple_start(T&& t) {
     constexpr auto size = std::tuple_size<std::decay_t<T>>::value;
     constexpr auto len = sizeof...(I);
     static_assert(len <= size, "The tuple size must be less than or equal to the length.");
@@ -75,19 +68,17 @@ struct tuple_start_impl<T, std::index_sequence<I...>>
  * Get the tuple with the last @a len items of the original.
  */
 template <std::size_t len, typename T>
-constexpr decltype(auto) // typename tuple_type_end<T, len>::type
-  tuple_start(T&& t)
-{
-  // We use std::decay_t<> because tuple_size is not defined for references.
+constexpr
+decltype(auto) // typename tuple_type_end<T, len>::type
+tuple_start(T&& t) {
+  //We use std::decay_t<> because tuple_size is not defined for references.
   constexpr auto size = std::tuple_size<std::decay_t<T>>::value;
   static_assert(len <= size, "The tuple size must be less than or equal to the length.");
 
   return detail::tuple_start_impl<T, std::make_index_sequence<len>>::tuple_start(
     std::forward<T>(t));
 }
 
-} // namespace internal
-
-} // namespace sigc
+} // namespace sigc::internal;
 
-#endif // SIGC_TUPLE_UTILS_TUPLE_START_H
+#endif //SIGC_TUPLE_UTILS_TUPLE_START_H