[libcxx] Add <experimental/tuple>

[EricWF]

Summary

This patch adds <experimental/tuple>. <experimental/tuple> contains tuple_size_v and apply(F&&, Tuple&&).

In order to implement apply the existing functionality of __invoke in <__functional_base> is used. In order for apply to be constexpr all of the existing __invoke overloads were marked as constexpr.

Because __invoke is used apply supports all function types specified in the INVOKE macro specification. This means apply has extended support for pointers to member functions and pointers to member objects. This extension is tested in libcxx/test/libcxx/experimental/utilities/tuple/tuple.apply/extended_types.pas.cpp.

[EricWF]

LGW just moved an issue to define this is terms of INVOKE. So this implementation using invoke no longer an extension.

[mclow.lists]

This looks good to me.

include/experimental/tuple

54

I just added a new config macro: _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
Please use that instead.

[EricWF]

1. Address @mclow.lists comments about _LIBCPP_HAS_NO_VARIABLE_TEMPLATES.
2. Move some tests from test/libcxx to test/std because they no longer test extensions.
3. Remove test for feature macro.

[EricWF]

I'm not quite sure what happened here but I somehow had two different code reviews out for the same thing. This was reviewed as D4512.

include/__functional_base

 
 template <class _Fp, class _A0, class ..._Args,
             class>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))

 
 template <class _Fp, class _A0, class ..._Args,
             class>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))

 
 template <class _Fp, class _A0,
             class>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
     -> decltype(_VSTD::forward<_A0>(__a0).*__f)

 
 template <class _Fp, class _A0,
             class>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
     -> decltype((*_VSTD::forward<_A0>(__a0)).*__f)

 // bullet 5
 
 template <class _Fp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _Args&& ...__args)
     -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))

include/experimental/tuple

+// -*- C++ -*-
+//===----------------------------- tuple ----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_TUPLE
+#define _LIBCPP_EXPERIMENTAL_TUPLE
+
+/*
+    experimental/tuple synopsis
+
+// C++1y
+
+#include <tuple>
+
+namespace std {
+namespace experimental {
+inline namespace fundamentals_v1 {
+
+  // See C++14 20.4.2.5, tuple helper classes
+  template <class T> constexpr size_t tuple_size_v
+    = tuple_size<T>::value;
+
+  // 3.2.2, Calling a function with a tuple of arguments
+  template <class F, class Tuple>
+  constexpr decltype(auto) apply(F&& f, Tuple&& t);
+
+} // namespace fundamentals_v1
+} // namespace experimental
+} // namespace std
+
+ */
+
+# include <experimental/__config>
+
+#if _LIBCPP_STD_VER > 11
+
+# include <tuple>
+# include <utility>
+# include <__functional_base>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
+template <class _Tp>
+_LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value;
+#endif
+
+#define _LIBCPP_AUTO_RETURN(_Tp) -> decltype(_Tp) { return _Tp; }
+
+template <class _Fn, class _Tuple, size_t ..._Id>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+auto __apply_tuple_impl(_Fn && __f, _Tuple && __t, integer_sequence<size_t, _Id...>)
+_LIBCPP_AUTO_RETURN(
+    _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
+  )
+
+template <class _Fn, class _Tuple>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+auto apply(_Fn && __f, _Tuple && __t)
+_LIBCPP_AUTO_RETURN(
+    _VSTD_LFTS::__apply_tuple_impl(
+        _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t)
+      , make_index_sequence<tuple_size<typename decay<_Tuple>::type>::value>()
+      )
+)
+#undef _LIBCPP_AUTO_RETURN
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+#endif /* _LIBCPP_STD_VER > 11 */
+
+#endif /* _LIBCPP_EXPERIMENTAL_TUPLE */

include/type_traits

                            typename remove_reference<_A0>::type>::value
             >::type
          >
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));

                            typename remove_reference<_A0>::type>::value
             >::type
          >
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));

                            typename remove_reference<_A0>::type>::value
             >::type
          >
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
     -> decltype(_VSTD::forward<_A0>(__a0).*__f);

                            typename remove_reference<_A0>::type>::value
             >::type
          >
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _A0&& __a0)
     -> decltype((*_VSTD::forward<_A0>(__a0)).*__f);

 // bullet 5
 
 template <class _Fp, class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 auto
 __invoke(_Fp&& __f, _Args&& ...__args)
     -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...));

test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/tuple>
+
+#include <experimental/tuple>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+# ifndef _LIBCPP_TUPLE
+#   error "<experimental/tuple> must include <tuple>"
+# endif
+#endif /* _LIBCPP_STD_VER > 11 */
+}

test/libcxx/experimental/utilities/tuple/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/tuple>
+
+#include <experimental/tuple>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}

test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+#include <experimental/tuple>
+
+int main()
+{
+  std::tuple<int> x(1);
+}

test/std/experimental/utilities/tuple/tuple.apply/arg_type.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Test with different ref/ptr/cv qualified argument types.
+
+#include <experimental/tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+namespace ex = std::experimental;
+
+int call_with_value(int x, int y) { return (x + y); }
+int call_with_ref(int & x, int & y) { return (x + y); }
+int call_with_const_ref(int const & x, int const & y) { return (x + y); }
+int call_with_rvalue_ref(int && x, int && y) { return (x + y); }
+int call_with_pointer(int * x, int * y) { return (*x + *y); }
+int call_with_const_pointer(int const* x, int const * y) { return (*x + *y); }
+
+
+template <class Tuple>
+void test_values()
+{
+    {
+        Tuple t{1, 2};
+        assert(3 == ex::apply(call_with_value, t));
+    }
+    {
+        Tuple t{2, 2};
+        assert(4 == ex::apply(call_with_ref, t));
+    }
+    {
+        Tuple t{2, 3};
+        assert(5 == ex::apply(call_with_const_ref, t));
+    }
+    {
+        Tuple t{3, 3};
+        assert(6 == ex::apply(call_with_rvalue_ref, static_cast<Tuple &&>(t)));
+    }
+    {
+        Tuple const t{4, 4};
+        assert(8 == ex::apply(call_with_value, t));
+    }
+    {
+        Tuple const t{4, 5};
+        assert(9 == ex::apply(call_with_const_ref, t));
+    }
+}
+
+template <class Tuple>
+void test_refs()
+{
+    int x = 0;
+    int y = 0;
+    {
+        x = 1; y = 2;
+        Tuple t{x, y};
+        assert(3 == ex::apply(call_with_value, t));
+    }
+    {
+        x = 2; y = 2;
+        Tuple t{x, y};
+        assert(4 == ex::apply(call_with_ref, t));
+    }
+    {
+        x = 2; y = 3;
+        Tuple t{x, y};
+        assert(5 == ex::apply(call_with_const_ref, t));
+    }
+    {
+        x = 3; y = 3;
+        Tuple const t{x, y};
+        assert(6 == ex::apply(call_with_value, t));
+    }
+    {
+        x = 3; y = 4;
+        Tuple const t{x, y};
+        assert(7 == ex::apply(call_with_const_ref, t));
+    }
+}
+
+template <class Tuple>
+void test_const_refs()
+{
+    int x = 0;
+    int y = 0;
+    {
+        x = 1; y = 2;
+        Tuple t{x, y};
+        assert(3 == ex::apply(call_with_value, t));
+    }
+    {
+        x = 2; y = 3;
+        Tuple t{x, y};
+        assert(5 == ex::apply(call_with_const_ref, t));
+    }
+    {
+        x = 3; y = 3;
+        Tuple const t{x, y};
+        assert(6 == ex::apply(call_with_value, t));
+    }
+    {
+        x = 3; y = 4;
+        Tuple const t{x, y};
+        assert(7 == ex::apply(call_with_const_ref, t));
+    }
+}
+
+
+template <class Tuple>
+void test_pointer()
+{
+    int x = 0;
+    int y = 0;
+    {
+        x = 2; y = 2;
+        Tuple t{&x, &y};
+        assert(4 == ex::apply(call_with_pointer, t));
+    }
+    {
+        x = 2; y = 3;
+        Tuple t{&x, &y};
+        assert(5 == ex::apply(call_with_const_pointer, t));
+    }
+    {
+        x = 3; y = 4;
+        Tuple const t{&x, &y};
+        assert(7 == ex::apply(call_with_const_pointer, t));
+    }
+}
+
+
+template <class Tuple>
+void test_const_pointer()
+{
+    int x = 0;
+    int y = 0;
+    {
+        x = 2; y = 3;
+        Tuple t{&x, &y};
+        assert(5 == ex::apply(call_with_const_pointer, t));
+    }
+    {
+        x = 3; y = 4;
+        Tuple const t{&x, &y};
+        assert(7 == ex::apply(call_with_const_pointer, t));
+    }
+}
+
+
+int main()
+{
+    test_values<std::tuple<int, int>>();
+    test_values<std::pair<int, int>>();
+    test_values<std::array<int, 2>>();
+
+    test_refs<std::tuple<int &, int &>>();
+    test_refs<std::pair<int &, int &>>();
+
+    test_const_refs<std::tuple<int const &, int const &>>();
+    test_const_refs<std::pair<int const &, int const &>>();
+
+    test_pointer<std::tuple<int *, int *>>();
+    test_pointer<std::pair<int *, int *>>();
+    test_pointer<std::array<int *, 2>>();
+
+    test_const_pointer<std::tuple<int const *, int const *>>();
+    test_const_pointer<std::pair<int const *, int const *>>();
+    test_const_pointer<std::array<int const *, 2>>();
+}

test/std/experimental/utilities/tuple/tuple.apply/constexpr_types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Testing constexpr evaluation
+
+#include <experimental/tuple>
+#include <utility>
+#include <cassert>
+
+constexpr int f_int_0() { return 1; }
+constexpr int f_int_1(int x) { return  x; }
+constexpr int f_int_2(int x, int y) { return (x + y); }
+
+struct A_int_0
+{
+    constexpr A_int_0() {}
+    constexpr int operator()() const { return 1; }
+};
+
+struct A_int_1
+{
+    constexpr A_int_1() {}
+    constexpr int operator()(int x) const { return x; }
+};
+
+struct A_int_2
+{
+    constexpr A_int_2() {}
+    constexpr int operator()(int x, int y) const { return (x + y); }
+};
+
+namespace ex = std::experimental;
+
+template <class Tuple>
+void test_0()
+{
+    // function
+    {
+        constexpr Tuple t{};
+        static_assert(1 == ex::apply(f_int_0, t), "");
+    }
+    // function pointer
+    {
+        constexpr Tuple t{};
+        constexpr auto fp = &f_int_0;
+        static_assert(1 == ex::apply(fp, t), "");
+    }
+    // functor
+    {
+        constexpr Tuple t{};
+        constexpr A_int_0 a;
+        static_assert(1 == ex::apply(a, t), "");
+    }
+}
+
+template <class Tuple>
+void test_1()
+{
+    // function
+    {
+        constexpr Tuple t{1};
+        static_assert(1 == ex::apply(f_int_1, t), "");
+    }
+    // function pointer
+    {
+        constexpr Tuple t{2};
+        constexpr int (*fp)(int) = f_int_1;
+        static_assert(2 == ex::apply(fp, t), "");
+    }
+    // functor
+    {
+        constexpr Tuple t{3};
+        constexpr A_int_1 fn;
+        static_assert(3 == ex::apply(fn, t), "");
+    }
+}
+
+template <class Tuple>
+void test_2()
+{
+    // function
+    {
+        constexpr Tuple t{1, 2};
+        static_assert(3 == ex::apply(f_int_2, t), "");
+    }
+        // function pointer
+    {
+        constexpr Tuple t{2, 3};
+        constexpr auto fp = &f_int_2;
+        static_assert(5 == ex::apply(fp, t), "");
+    }
+    // functor
+    {
+        constexpr Tuple t{3, 4};
+        constexpr A_int_2 a;
+        static_assert(7 == ex::apply(a, t), "");
+    }
+}
+
+int main()
+{
+    test_0<std::tuple<>>();
+    test_1<std::tuple<int>>();
+    test_2<std::tuple<int, int>>();
+    test_2<std::pair<int, int>>();
+}

test/std/experimental/utilities/tuple/tuple.apply/extended_types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Testing extended function types. The extented function types are those
+// named by INVOKE but that are not actual callable objects. These include
+// bullets 1-4 of invoke.
+
+#include <experimental/tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+int count = 0;
+
+struct A_int_0
+{
+    A_int_0() : obj1(0){}
+    A_int_0(int x) : obj1(x) {}
+    int mem1() { return ++count; }
+    int mem2() const { return ++count; }
+    int const obj1;
+};
+
+struct A_int_1
+{
+    A_int_1() {}
+    A_int_1(int) {}
+    int mem1(int x) { return count += x; }
+    int mem2(int x) const { return count += x; }
+};
+
+struct A_int_2
+{
+    A_int_2() {}
+    A_int_2(int) {}
+    int mem1(int x, int y) { return count += (x + y); }
+    int mem2(int x, int y) const { return count += (x + y); }
+};
+
+template <class A>
+struct A_wrap
+{
+    A_wrap() {}
+    A_wrap(int x) : m_a(x) {}
+    A & operator*() { return m_a; }
+    A const & operator*() const { return m_a; }
+    A m_a;
+};
+
+typedef A_wrap<A_int_0> A_wrap_0;
+typedef A_wrap<A_int_1> A_wrap_1;
+typedef A_wrap<A_int_2> A_wrap_2;
+
+
+template <class A>
+struct A_base : public A
+{
+    A_base() : A() {}
+    A_base(int x) : A(x) {}
+};
+
+typedef A_base<A_int_0> A_base_0;
+typedef A_base<A_int_1> A_base_1;
+typedef A_base<A_int_2> A_base_2;
+
+namespace ex = std::experimental;
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_0()
+{
+    count = 0;
+    typedef A_int_0 T;
+    typedef A_wrap_0 Wrap;
+    typedef A_base_0 Base;
+
+    typedef int(T::*mem1_t)();
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)() const;
+    mem2_t mem2 = &T::mem2;
+
+    typedef int const T::*obj1_t;
+    obj1_t obj1 = &T::obj1;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a};
+        assert(1 == ex::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a};
+        assert(1 == ex::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a};
+        assert(1 == ex::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a};
+        assert(1 == ex::apply(mem1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a};
+        assert(1 == ex::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a};
+        assert(1 == ex::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a};
+        assert(1 == ex::apply(mem2, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a};
+        assert(1 == ex::apply(mem2, t));
+        assert(1 == count);
+    }
+    // member object w/ref
+    {
+        T a{42};
+        Tuple t{a};
+        assert(42 == ex::apply(obj1, t));
+    }
+    // member object w/pointer
+    {
+        T a{42};
+        TuplePtr t{&a};
+        assert(42 == ex::apply(obj1, t));
+    }
+    // member object w/base
+    {
+        Base a{42};
+        TupleBase t{a};
+        assert(42 == ex::apply(obj1, t));
+    }
+    // member object w/wrapper
+    {
+        Wrap a{42};
+        TupleWrap t{a};
+        assert(42 == ex::apply(obj1, t));
+    }
+}
+
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_1()
+{
+    count = 0;
+    typedef A_int_1 T;
+    typedef A_wrap_1 Wrap;
+    typedef A_base_1 Base;
+
+    typedef int(T::*mem1_t)(int);
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)(int) const;
+    mem2_t mem2 = &T::mem2;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a, 2};
+        assert(2 == ex::apply(mem1, t));
+        assert(count == 2);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a, 3};
+        assert(3 == ex::apply(mem1, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a, 4};
+        assert(4 == ex::apply(mem1, t));
+        assert(count == 4);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a, 5};
+        assert(5 == ex::apply(mem1, t));
+        assert(count == 5);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a, 6};
+        assert(6 == ex::apply(mem2, t));
+        assert(count == 6);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a, 7};
+        assert(7 == ex::apply(mem2, t));
+        assert(count == 7);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a, 8};
+        assert(8 == ex::apply(mem2, t));
+        assert(count == 8);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a, 9};
+        assert(9 == ex::apply(mem2, t));
+        assert(9 == count);
+    }
+}
+
+
+template <
+    class Tuple, class ConstTuple
+  , class TuplePtr, class ConstTuplePtr
+  , class TupleWrap, class ConstTupleWrap
+  , class TupleBase, class ConstTupleBase
+  >
+void test_ext_int_2()
+{
+    count = 0;
+    typedef A_int_2 T;
+    typedef A_wrap_2 Wrap;
+    typedef A_base_2 Base;
+
+    typedef int(T::*mem1_t)(int, int);
+    mem1_t mem1 = &T::mem1;
+
+    typedef int(T::*mem2_t)(int, int) const;
+    mem2_t mem2 = &T::mem2;
+
+    // member function w/ref
+    {
+        T a;
+        Tuple t{a, 1, 1};
+        assert(2 == ex::apply(mem1, t));
+        assert(count == 2);
+    }
+    count = 0;
+    // member function w/pointer
+    {
+        T a;
+        TuplePtr t{&a, 1, 2};
+        assert(3 == ex::apply(mem1, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // member function w/base
+    {
+        Base a;
+        TupleBase t{a, 2, 2};
+        assert(4 == ex::apply(mem1, t));
+        assert(count == 4);
+    }
+    count = 0;
+    // member function w/wrap
+    {
+        Wrap a;
+        TupleWrap t{a, 2, 3};
+        assert(5 == ex::apply(mem1, t));
+        assert(count == 5);
+    }
+    count = 0;
+    // const member function w/ref
+    {
+        T const a;
+        ConstTuple t{a, 3, 3};
+        assert(6 == ex::apply(mem2, t));
+        assert(count == 6);
+    }
+    count = 0;
+    // const member function w/pointer
+    {
+        T const a;
+        ConstTuplePtr t{&a, 3, 4};
+        assert(7 == ex::apply(mem2, t));
+        assert(count == 7);
+    }
+    count = 0;
+    // const member function w/base
+    {
+        Base const a;
+        ConstTupleBase t{a, 4, 4};
+        assert(8 == ex::apply(mem2, t));
+        assert(count == 8);
+    }
+    count = 0;
+    // const member function w/wrapper
+    {
+        Wrap const a;
+        ConstTupleWrap t{a, 4, 5};
+        assert(9 == ex::apply(mem2, t));
+        assert(9 == count);
+    }
+}
+
+int main()
+{
+    {
+        test_ext_int_0<
+            std::tuple<A_int_0 &>, std::tuple<A_int_0 const &>
+          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
+          , std::tuple<A_wrap_0 &>, std::tuple<A_wrap_0 const &>
+          , std::tuple<A_base_0 &>, std::tuple<A_base_0 const &>
+          >();
+        test_ext_int_0<
+            std::tuple<A_int_0>, std::tuple<A_int_0 const>
+          , std::tuple<A_int_0 *>, std::tuple<A_int_0 const *>
+          , std::tuple<A_wrap_0>, std::tuple<A_wrap_0 const>
+          , std::tuple<A_base_0>, std::tuple<A_base_0 const>
+          >();
+        test_ext_int_0<
+            std::array<A_int_0, 1>, std::array<A_int_0 const, 1>
+          , std::array<A_int_0*, 1>, std::array<A_int_0 const*, 1>
+          , std::array<A_wrap_0, 1>, std::array<A_wrap_0 const, 1>
+          , std::array<A_base_0, 1>, std::array<A_base_0 const, 1>
+          >();
+    }
+    {
+        test_ext_int_1<
+            std::tuple<A_int_1 &, int>, std::tuple<A_int_1 const &, int>
+          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
+          , std::tuple<A_wrap_1 &, int>, std::tuple<A_wrap_1 const &, int>
+          , std::tuple<A_base_1 &, int>, std::tuple<A_base_1 const &, int>
+          >();
+        test_ext_int_1<
+            std::tuple<A_int_1, int>, std::tuple<A_int_1 const, int>
+          , std::tuple<A_int_1 *, int>, std::tuple<A_int_1 const *, int>
+          , std::tuple<A_wrap_1, int>, std::tuple<A_wrap_1 const, int>
+          , std::tuple<A_base_1, int>, std::tuple<A_base_1 const, int>
+          >();
+        test_ext_int_1<
+            std::pair<A_int_1 &, int>, std::pair<A_int_1 const &, int>
+          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
+          , std::pair<A_wrap_1 &, int>, std::pair<A_wrap_1 const &, int>
+          , std::pair<A_base_1 &, int>, std::pair<A_base_1 const &, int>
+          >();
+        test_ext_int_1<
+            std::pair<A_int_1, int>, std::pair<A_int_1 const, int>
+          , std::pair<A_int_1 *, int>, std::pair<A_int_1 const *, int>
+          , std::pair<A_wrap_1, int>, std::pair<A_wrap_1 const, int>
+          , std::pair<A_base_1, int>, std::pair<A_base_1 const, int>
+          >();
+    }
+    {
+        test_ext_int_2<
+            std::tuple<A_int_2 &, int, int>, std::tuple<A_int_2 const &, int, int>
+          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
+          , std::tuple<A_wrap_2 &, int, int>, std::tuple<A_wrap_2 const &, int, int>
+          , std::tuple<A_base_2 &, int, int>, std::tuple<A_base_2 const &, int, int>
+          >();
+        test_ext_int_2<
+            std::tuple<A_int_2, int, int>, std::tuple<A_int_2 const, int, int>
+          , std::tuple<A_int_2 *, int, int>, std::tuple<A_int_2 const *, int, int>
+          , std::tuple<A_wrap_2, int, int>, std::tuple<A_wrap_2 const, int, int>
+          , std::tuple<A_base_2, int, int>, std::tuple<A_base_2 const, int, int>
+          >();
+    }
+}

test/std/experimental/utilities/tuple/tuple.apply/large_arity.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Stress testing large arities with tuple and array.
+
+#include <experimental/tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+////////////////////////////////////////////////////////////////////////////////
+template <class T, std::size_t Dummy = 0>
+struct always_imp
+{
+    typedef T type;
+};
+
+template <class T, std::size_t Dummy = 0>
+using always_t = typename always_imp<T, Dummy>::type;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tuple, class Idx>
+struct make_function;
+
+template <class Tp, std::size_t ...Idx>
+struct make_function<Tp, std::integer_sequence<std::size_t, Idx...>>
+{
+    using type = bool (*)(always_t<Tp, Idx>...);
+};
+
+template <class Tp, std::size_t Size>
+using make_function_t = typename make_function<Tp, std::make_index_sequence<Size>>::type;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tp, class Idx>
+struct make_tuple_imp;
+
+////////////////////////////////////////////////////////////////////////////////
+template <class Tp, std::size_t ...Idx>
+struct make_tuple_imp<Tp, std::integer_sequence<std::size_t, Idx...>>
+{
+    using type = std::tuple<always_t<Tp, Idx>...>;
+};
+
+template <class Tp, std::size_t Size>
+using make_tuple_t = typename make_tuple_imp<Tp, std::make_index_sequence<Size>>::type;
+
+template <class ...Types>
+bool test_apply_fn(Types...) { return true; }
+
+namespace ex = std::experimental;
+
+template <std::size_t Size>
+void test_all()
+{
+
+    using A = std::array<int, Size>;
+    using ConstA = std::array<int const, Size>;
+
+    using Tuple = make_tuple_t<int, Size>;
+    using CTuple = make_tuple_t<const int, Size>;
+
+    using ValFn  = make_function_t<int, Size>;
+    ValFn val_fn = &test_apply_fn;
+
+    using RefFn  = make_function_t<int &, Size>;
+    RefFn ref_fn = &test_apply_fn;
+
+    using CRefFn = make_function_t<int const &, Size>;
+    CRefFn cref_fn = &test_apply_fn;
+
+    using RRefFn = make_function_t<int &&, Size>;
+    RRefFn rref_fn = &test_apply_fn;
+
+    {
+        A a{};
+        assert(ex::apply(val_fn, a));
+        assert(ex::apply(ref_fn, a));
+        assert(ex::apply(cref_fn, a));
+        assert(ex::apply(rref_fn, std::move(a)));
+    }
+    {
+        ConstA a{};
+        assert(ex::apply(val_fn, a));
+        assert(ex::apply(cref_fn, a));
+    }
+    {
+        Tuple a{};
+        assert(ex::apply(val_fn, a));
+        assert(ex::apply(ref_fn, a));
+        assert(ex::apply(cref_fn, a));
+        assert(ex::apply(rref_fn, std::move(a)));
+    }
+    {
+        CTuple a{};
+        assert(ex::apply(val_fn, a));
+        assert(ex::apply(cref_fn, a));
+    }
+
+}
+
+
+template <std::size_t Size>
+void test_one()
+{
+    using A = std::array<int, Size>;
+    using Tuple = make_tuple_t<int, Size>;
+
+    using ValFn  = make_function_t<int, Size>;
+    ValFn val_fn = &test_apply_fn;
+
+    {
+        A a{};
+        assert(ex::apply(val_fn, a));
+    }
+    {
+        Tuple a{};
+        assert(ex::apply(val_fn, a));
+    }
+}
+
+int main()
+{
+    // Instantiate with 1-5 arguments.
+    test_all<1>();
+    test_all<2>();
+    test_all<3>();
+    test_all<4>();
+    test_all<5>();
+
+    // Stress test with 128.
+    test_one<128>();
+    //test_one<256>();
+}

test/std/experimental/utilities/tuple/tuple.apply/ref_qualifiers.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Testing ref qualified functions
+
+#include <experimental/tuple>
+#include <cassert>
+
+struct func_obj
+{
+    constexpr func_obj() {}
+
+    constexpr int operator()() const & { return 1; }
+    constexpr int operator()() const && { return 2; }
+    constexpr int operator()() & { return 3; }
+    constexpr int operator()() && { return 4; }
+};
+
+namespace ex = std::experimental;
+
+int main()
+{
+    {
+        constexpr func_obj f;
+        constexpr std::tuple<> tp;
+
+        static_assert(1 == ex::apply(static_cast<func_obj const &>(f), tp), "");
+        static_assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp), "");
+    }
+    {
+        func_obj f;
+        std::tuple<> tp;
+        assert(1 == ex::apply(static_cast<func_obj const &>(f), tp));
+        assert(2 == ex::apply(static_cast<func_obj const &&>(f), tp));
+        assert(3 == ex::apply(static_cast<func_obj &>(f), tp));
+        assert(4 == ex::apply(static_cast<func_obj &&>(f), tp));
+    }
+}

test/std/experimental/utilities/tuple/tuple.apply/return_type.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Test the return type deduction.
+
+#include <experimental/tuple>
+#include <cassert>
+
+static int my_int = 42;
+
+template <int N> struct index {};
+
+void f(index<0>) {}
+
+int f(index<1>) { return 0; }
+int const f(index<2>) { return 0; }
+int volatile f(index<3>) { return 0; }
+int const volatile f(index<4>) { return 0; }
+
+int & f(index<5>) { return static_cast<int &>(my_int); }
+int const & f(index<6>) { return static_cast<int const &>(my_int); }
+int volatile & f(index<7>) { return static_cast<int volatile &>(my_int); }
+int const volatile & f(index<8>) { return static_cast<int const volatile &>(my_int); }
+
+int && f(index<9>) { return static_cast<int &&>(my_int); }
+int const && f(index<10>) { return static_cast<int const &&>(my_int); }
+int volatile && f(index<11>) { return static_cast<int volatile &&>(my_int); }
+int const volatile && f(index<12>) { return static_cast<int const volatile &&>(my_int); }
+
+int * f(index<13>) { return static_cast<int *>(&my_int); }
+int const * f(index<14>) { return static_cast<int const *>(&my_int); }
+int volatile * f(index<15>) { return static_cast<int volatile *>(&my_int); }
+int const volatile * f(index<16>) { return static_cast<int const volatile *>(&my_int); }
+
+
+template <int Func, class Expect>
+void test()
+{
+    using F = decltype((f(index<Func>{})));
+    static_assert(std::is_same<F, Expect>::value, "");
+}
+
+namespace ex = std::experimental;
+
+int main()
+{
+    test<0, void>();
+    test<1, int>();
+    //test<2, int const>();
+    //test<3, int volatile>();
+    //test<4, int const volatile>();
+    test<5, int &>();
+    test<6, int const &>();
+    test<7, int volatile &>();
+    test<8, int const volatile &>();
+    test<9, int &&>();
+    test<10, int const &&>();
+    test<11, int volatile &&>();
+    test<12, int const volatile &&>();
+    test<13, int *>();
+    test<14, int const *>();
+    test<15, int volatile *>();
+    test<16, int const volatile *>();
+}

test/std/experimental/utilities/tuple/tuple.apply/types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class F, class T> constexpr decltype(auto) apply(F &&, T &&)
+
+// Test function types.
+
+#include <experimental/tuple>
+#include <array>
+#include <utility>
+#include <cassert>
+
+namespace ex = std::experimental;
+
+int count = 0;
+
+void f_void_0() { ++count; }
+void f_void_1(int i) { count += i; }
+void f_void_2(int x, int y) { count += (x + y); }
+void f_void_3(int x, int y, int z) { count += (x + y + z); }
+
+int f_int_0() { return ++count; }
+int f_int_1(int x) { return count += x; }
+int f_int_2(int x, int y) { return count += (x + y); }
+int f_int_3(int x, int y, int z) { return count += (x + y + z); }
+
+struct A_void_0
+{
+    A_void_0() {}
+    void operator()() { ++count; }
+    void operator()() const { ++count; ++count; }
+};
+
+struct A_void_1
+{
+    A_void_1() {}
+    void operator()(int x) { count += x; }
+    void operator()(int x) const { count += x + 1; }
+};
+
+struct A_void_2
+{
+    A_void_2() {}
+    void operator()(int x, int y) { count += (x + y); }
+    void operator()(int x, int y) const { count += (x + y) + 1; }
+};
+
+struct A_void_3
+{
+    A_void_3() {}
+    void operator()(int x, int y, int z) { count += (x + y + z); }
+    void operator()(int x, int y, int z) const { count += (x + y + z) + 1; }
+};
+
+
+struct A_int_0
+{
+    A_int_0() {}
+    int operator()() { return ++count; }
+    int operator()() const { ++count; return ++count; }
+};
+
+struct A_int_1
+{
+    A_int_1() {}
+    int operator()(int x) { return count += x; }
+    int operator()(int x) const { return count += (x + 1); }
+
+};
+
+struct A_int_2
+{
+    A_int_2() {}
+    int operator()(int x, int y) { return count += (x + y); }
+    int operator()(int x, int y) const { return count += (x + y + 1); }
+};
+
+struct A_int_3
+{
+    A_int_3() {}
+    int operator()(int x, int y, int z) { return count += (x + y + z); }
+    int operator()(int x, int y, int z) const { return count += (x + y + z + 1); }
+};
+
+
+template <class Tuple>
+void test_void_0()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{};
+        ex::apply(f_void_0, t);
+        assert(count == 1);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{};
+        auto fp = &f_void_0;
+        ex::apply(fp, t);
+        assert(count == 1);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{};
+        A_void_0 a;
+        ex::apply(a, t);
+        assert(count == 1);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{};
+        A_void_0 const a;
+        ex::apply(a, t);
+        assert(count == 2);
+    }
+}
+
+template <class Tuple>
+void test_void_1()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1};
+        ex::apply(f_void_1, t);
+        assert(count == 1);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2};
+        void (*fp)(int) = f_void_1;
+        ex::apply(fp, t);
+        assert(count == 2);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3};
+        A_void_1 fn;
+        ex::apply(fn, t);
+        assert(count == 3);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4};
+        A_void_1 const a;
+        ex::apply(a, t);
+        assert(count == 5);
+    }
+}
+
+template <class Tuple>
+void test_void_2()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1, 2};
+        ex::apply(f_void_2, t);
+        assert(count == 3);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2, 3};
+        auto fp = &f_void_2;
+        ex::apply(fp, t);
+        assert(count == 5);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3, 4};
+        A_void_2 a;
+        ex::apply(a, t);
+        assert(count == 7);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4, 5};
+        A_void_2 const a;
+        ex::apply(a, t);
+        assert(count == 10);
+    }
+}
+
+template <class Tuple>
+void test_void_3()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1, 2, 3};
+        ex::apply(f_void_3, t);
+        assert(count == 6);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2, 3, 4};
+        auto fp = &f_void_3;
+        ex::apply(fp, t);
+        assert(count == 9);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3, 4, 5};
+        A_void_3 a;
+        ex::apply(a, t);
+        assert(count == 12);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4, 5, 6};
+        A_void_3 const a;
+        ex::apply(a, t);
+        assert(count == 16);
+    }
+}
+
+
+
+template <class Tuple>
+void test_int_0()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{};
+        assert(1 == ex::apply(f_int_0, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{};
+        auto fp = &f_int_0;
+        assert(1 == ex::apply(fp, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{};
+        A_int_0 a;
+        assert(1 == ex::apply(a, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{};
+        A_int_0 const a;
+        assert(2 == ex::apply(a, t));
+        assert(count == 2);
+    }
+}
+
+template <class Tuple>
+void test_int_1()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1};
+        assert(1 == ex::apply(f_int_1, t));
+        assert(count == 1);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2};
+        int (*fp)(int) = f_int_1;
+        assert(2 == ex::apply(fp, t));
+        assert(count == 2);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3};
+        A_int_1 fn;
+        assert(3 == ex::apply(fn, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4};
+        A_int_1 const a;
+        assert(5 == ex::apply(a, t));
+        assert(count == 5);
+    }
+}
+
+template <class Tuple>
+void test_int_2()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1, 2};
+        assert(3 == ex::apply(f_int_2, t));
+        assert(count == 3);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2, 3};
+        auto fp = &f_int_2;
+        assert(5 == ex::apply(fp, t));
+        assert(count == 5);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3, 4};
+        A_int_2 a;
+        assert(7 == ex::apply(a, t));
+        assert(count == 7);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4, 5};
+        A_int_2 const a;
+        assert(10 == ex::apply(a, t));
+        assert(count == 10);
+    }
+}
+
+template <class Tuple>
+void test_int_3()
+{
+    count = 0;
+    // function
+    {
+        Tuple t{1, 2, 3};
+        assert(6 == ex::apply(f_int_3, t));
+        assert(count == 6);
+    }
+    count = 0;
+    // function pointer
+    {
+        Tuple t{2, 3, 4};
+        auto fp = &f_int_3;
+        assert(9 == ex::apply(fp, t));
+        assert(count == 9);
+    }
+    count = 0;
+    // functor
+    {
+        Tuple t{3, 4, 5};
+        A_int_3 a;
+        assert(12 == ex::apply(a, t));
+        assert(count == 12);
+    }
+    count = 0;
+    // const functor
+    {
+        Tuple t{4, 5, 6};
+        A_int_3 const a;
+        assert(16 == ex::apply(a, t));
+        assert(count == 16);
+    }
+}
+
+template <class Tuple>
+void test_0()
+{
+    test_void_0<Tuple>();
+    test_int_0<Tuple>();
+}
+
+template <class Tuple>
+void test_1()
+{
+    test_void_1<Tuple>();
+    test_int_1<Tuple>();
+}
+
+template <class Tuple>
+void test_2()
+{
+    test_void_2<Tuple>();
+    test_int_2<Tuple>();
+}
+
+template <class Tuple>
+void test_3()
+{
+    test_void_3<Tuple>();
+    test_int_3<Tuple>();
+}
+
+int main()
+{
+    test_0<std::tuple<>>();
+
+    test_1<std::tuple<int>>();
+    test_1<std::array<int, 1>>();
+
+    test_2<std::tuple<int, int>>();
+    test_2<std::pair<int, int>>();
+    test_2<std::array<int, 2>>();
+
+    test_3<std::tuple<int, int, int>>();
+    test_3<std::array<int, 3>>();
+}

test/std/experimental/utilities/tuple/tuple_size_v.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+// Test with reference
+
+#include <experimental/tuple>
+
+namespace ex = std::experimental;
+
+int main()
+{
+    auto x = ex::tuple_size_v<std::tuple<> &>;
+}

test/std/experimental/utilities/tuple/tuple_size_v.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+#include <experimental/tuple>
+#include <utility>
+#include <array>
+
+namespace ex = std::experimental;
+
+template <class Tuple, int Expect>
+void test()
+{
+    static_assert(ex::tuple_size_v<Tuple> == Expect, "");
+    static_assert(ex::tuple_size_v<Tuple> == std::tuple_size<Tuple>::value, "");
+    static_assert(ex::tuple_size_v<Tuple const> == std::tuple_size<Tuple>::value, "");
+    static_assert(ex::tuple_size_v<Tuple volatile> == std::tuple_size<Tuple>::value, "");
+    static_assert(ex::tuple_size_v<Tuple const volatile> == std::tuple_size<Tuple>::value, "");
+}
+
+int main()
+{
+    test<std::tuple<>, 0>();
+
+    test<std::tuple<int>, 1>();
+    test<std::array<int, 1>, 1>();
+
+    test<std::tuple<int, int>, 2>();
+    test<std::pair<int, int>, 2>();
+    test<std::array<int, 2>, 2>();
+
+    test<std::tuple<int, int, int>, 3>();
+    test<std::array<int, 3>, 3>();
+}

test/std/experimental/utilities/tuple/tuple_size_v_2.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+// Test with non tuple type
+
+#include <experimental/tuple>
+
+namespace ex = std::experimental;
+
+int main()
+{
+    auto x = ex::tuple_size_v<int>;
+}

test/std/experimental/utilities/tuple/tuple_size_v_3.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/tuple>
+
+// template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
+
+// Test with pointer
+
+#include <experimental/tuple>
+
+namespace ex = std::experimental;
+
+int main()
+{
+    auto x = ex::tuple_size_v<std::tuple<>*>;
+}

www/ts1z_status.html

   <tr><td>Additions to std::packaged_task</td><td>Not started</td></tr>
   <tr><td></td><td></td></tr>
   <tr><td>Class erased_type</td><td>Complete</td></tr>
-  <tr><td>Calling a function with a tuple of arguments</td><td>Implementation in progress</td></tr>
+  <tr><td>Calling a function with a tuple of arguments</td><td>Complete</td></tr>
   <tr><td>Other type transformations</td><td>Not started</td></tr>
   <tr><td>Compile-time Rational Arithmetic</td><td>Implementation in progress</td></tr>
   <tr><td>Time Utilities</td><td>Complete</td></tr>