implement std::to_array (P0325R3)

[zoecarver]

Summary

This patch implements std::to_array based on P0325R3.

[mclow.lists]

libcxx/include/array

500

Why is_constructible<_Tp, _Tp&>? - this seems wrong.
At the very least, the second one should be const T&.
But even better would be is_copy_constructible<_Tp> - because that's what you're going to do.

510

You can use the _v versions here; this is C++20

libcxx/test/std/containers/sequences/array/array.creation/to_array.pass.cpp

21

We have a nice move-only type in "MoveOnly.h".
Is there some reason why you didn't want to use that?

[zoecarver]

• update tests
• add copy only support class
• fix based on review

[zoecarver]

Abandoning in favor of D69882.

Edit: I'll add CopyOnly.h in a different patch.

libcxx/include/array

 get(const array<_Tp, _Size>&& __a) _NOEXCEPT
 {
     static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
     return _VSTD::move(__a.__elems_[_Ip]);
 }
 
 #endif  // !_LIBCPP_CXX03_LANG
 
+#if _LIBCPP_VERSION > 17
+
+template <class _Tp, _VSTD::size_t __n, size_t... __i>
+_LIBCPP_CONSTEXPR array<remove_cv_t<_Tp>, __n>
+__to_array_impl(_Tp (&__arr)[__n], index_sequence<__i...>)
+{
+    return {{ __arr[__i]... }};
+}
+
+template <class _Tp, _VSTD::size_t __n, size_t... __i>
+_LIBCPP_CONSTEXPR array<remove_cv_t<_Tp>, __n>
+__to_array_impl(_Tp (&&__arr)[__n], index_sequence<__i...>)
+{
+    return {{ _VSTD::move(__arr[__i])... }};
+}
+
+template <class _Tp, _VSTD::size_t __n,
+          class = _EnableIf<!is_array_v<_Tp> && is_copy_constructible_v<_Tp>>>
+_LIBCPP_CONSTEXPR array<remove_cv_t<_Tp>, __n>
+to_array(_Tp (&__arr)[__n])
+{
+    return __to_array_impl(__arr, _VSTD::make_index_sequence<__n>());
+}
+
+template <class _Tp, _VSTD::size_t __n,
+          class = _EnableIf<!is_array_v<_Tp> && is_move_constructible_v<_Tp>>>
+_LIBCPP_CONSTEXPR array<remove_cv_t<_Tp>, __n>
+to_array(_Tp (&&__arr)[__n])
+{
+    return __to_array_impl(_VSTD::move(__arr), _VSTD::make_index_sequence<__n>());
+}
+
+#endif // _LIBCPP_VERSION > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ARRAY

libcxx/test/std/containers/sequences/array/array.creation/to_array.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <array>
+
+#include <array>
+#include <cassert>
+
+#include "test_macros.h"
+#include "CopyOnly.h"
+#include "MoveOnly.h"
+
+struct Foo { int a; double b; };
+
+int main(int, char**)
+{
+    int a[3] = {};
+
+    ASSERT_SAME_TYPE(decltype(std::to_array("foo")), std::array<char, 4>);
+    ASSERT_SAME_TYPE(decltype(std::to_array({1, 2, 3})), std::array<int, 3>);
+    ASSERT_SAME_TYPE(decltype(std::to_array<std::size_t>({1, 2, 3})), std::array<std::size_t, 3>);
+    ASSERT_SAME_TYPE(decltype(std::to_array(a)), std::array<int, 3>);
+    ASSERT_SAME_TYPE(decltype(std::to_array<Foo>({{3, .3}})), std::array<Foo, 1>);
+    ASSERT_SAME_TYPE(decltype(std::to_array((int[]){1, 2, 3})), std::array<int, 3>);
+
+    {
+        MoveOnly carr[] = {MoveOnly(1), MoveOnly(2), MoveOnly(3), MoveOnly(4)};
+        std::array<MoveOnly, 4> arr = std::to_array(std::move(carr));
+        for (int i = 1; i < 5; ++i)
+            assert(arr[i - 1].get() == i && carr[i - 1] == 0);
+    }
+
+    {
+        CopyOnly carr[] = {CopyOnly(1), CopyOnly(2), CopyOnly(3), CopyOnly(4)};
+        std::array<CopyOnly, 4> arr = std::to_array(carr);
+        for (std::size_t i = 0; i < 4; ++i)
+            assert(arr[i].get() == carr[i].get());
+    }
+
+    {
+        constexpr std::array<int, 3> arr = std::to_array({1, 2, 3});
+        static_assert(arr[0] == 1);
+        static_assert(arr[1] == 2);
+        static_assert(arr[2] == 3);
+    }
+
+  return 0;
+}

libcxx/test/support/CopyOnly.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef COPYONLY_H
+#define COPYONLY_H
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+
+#include <cstddef>
+#include <functional>
+
+class CopyOnly
+{
+    CopyOnly(CopyOnly&& x);
+    CopyOnly& operator=(CopyOnly&& x);
+
+    int data_;
+public:
+    CopyOnly(int data = 1) : data_(data) {}
+
+    CopyOnly(CopyOnly const& x)
+        : data_(x.data_) {}
+
+    CopyOnly& operator=(CopyOnly const& x)
+        { data_ = x.data_; return *this;}
+
+    int get() const {return data_;}
+
+    bool operator==(const CopyOnly& x) const {return data_ == x.data_;}
+    bool operator< (const CopyOnly& x) const {return data_ <  x.data_;}
+    CopyOnly operator+(const CopyOnly& x) const { return CopyOnly{data_ + x.data_}; }
+    CopyOnly operator*(const CopyOnly& x) const { return CopyOnly{data_ * x.data_}; }
+};
+
+namespace std {
+
+template <>
+struct hash<CopyOnly>
+{
+    typedef CopyOnly argument_type;
+    typedef size_t result_type;
+    std::size_t operator()(const CopyOnly& x) const {return x.get();}
+};
+
+}
+
+#endif  // TEST_STD_VER >= 11
+
+#endif  // COPYONLY_H