tuple

namespace std {
 
    // class template tuple:
    template <class... Types> class tuple;
 
    // tuple creation functions:
    const /*unspecified*/ ignore;
    template <class... Types>
        tuple<VTypes...> make_tuple(Types&&...);
    template <class... Types>
        tuple<Types...> forward_as_tuple(Types&&...) noexcept;
    template<class... Types>
        tuple<Types&...> tie(Types&...) noexcept;
    template <class... Tuples>
        tuple<Ctypes...> tuple_cat(Tuples&&...);
 
    //  tuple helper classes:
    template <class T> class tuple_size; // undefined
    template <class T> class tuple_size<const T>;
    template <class T> class tuple_size<volatile T>;
    template <class T> class tuple_size<const volatile T>;
    template <class... Types> class tuple_size<tuple<Types...> >;
 
    template    <size_t I,  class   T>  class   tuple_element; // undefined
    template    <size_t I,  class   T>  class   tuple_element<I, const T>;
    template    <size_t I,  class   T>  class   tuple_element<I, volatile T>;
    template    <size_t I,  class   T>  class   tuple_element<I, const volatile T>;
    template <size_t I, class... Types> class tuple_element<I, tuple<Types...> >;
 
    //  element access:
    template <size_t I, class... Types>
        typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>&) noexcept;
    template <size_t I, class... types>
        typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&&) noexcept;
    template <size_t I, class... types>
        typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>&) noexcept;
 
    //relational operators:
    template<class... TTypes, class... UTypes>
        bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
 
    // allocator-related traits
    template <class... Types, class Alloc>
        struct uses_allocator<tuple<Types...>, Alloc>;
    // specialized algorithms:
    template <class... Types>
        void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(x.swap(y));
}

template <class... Types>
class tuple {
public:
    // tuple construction
    constexpr tuple();
    explicit tuple(const Types&...);
    template <class... UTypes>
        explicit tuple(UTypes&&...);
    tuple(const tuple&) = default;
    tuple(tuple&&) = default;
    template <class... UTypes>
        tuple(const tuple<UTypes...>&); 
    template <class... UTypes>
        tuple(tuple<UTypes...>&&);
    template <class U1, class U2>
        tuple(const pair<U1, U2>&);  // iff sizeof...(Types) == 2
    template <class U1, class U2>
        tuple(pair<U1, U2>&&);       // iff sizeof...(Types) == 2
 
    // allocator-extended constructors
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a);
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a, const Types&...);
    template <class Alloc, class... UTypes>
        tuple(allocator_arg_t, const Alloc& a, const UTypes&&...);
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a, const tuple&);
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a, tuple&&);
    template <class Alloc, class... UTypes>
        tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
    template <class Alloc, class... UTypes>
        tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
    template <class Alloc, class U1, class U2>
        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
    template <class Alloc, class U1, class U2>
        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 
    // tuple assignment
    tuple& operator=(const tuple&);
    tuple& operator=(tuple&&) noexcept(see below);
    template <class... UTypes>
        tuple& operator=(const tuple<UTypes...>&);
    template <class... UTypes>
        tuple& operator=(tuple<UTypes...>&&);
    template <class U1, class U2>
        tuple& operator=(const pair<U1, U2>&); // iff sizeof...(Types) == 2
    template <class U1, class U2>
        tuple& operator=(pair<U1, U2>&&) noexcept; // iff sizeof...(Types) == 2
 
    // tuple swap
    void swap(tuple&) noexcept(see below);
};