✨ Add make_array

Problem:
- We sometimes need to make arrays from various things, e.g. templates or
  factory functions.

Solution:
- Add `make_array`.

Note:
- Although `std::experimental::make_array` was largely obviated by CTAD, similar
  behaviour is included here for consistency. viz. `stdx::make_array(1,2,3)`.

Author: elbeno

CMakeLists.txt

@@ -42,6 +42,7 @@ target_sources(
               include
               FILES
               include/stdx/algorithm.hpp
+              include/stdx/array.hpp
               include/stdx/atomic.hpp
               include/stdx/atomic_bitset.hpp
               include/stdx/bit.hpp

docs/intro.adoc

@@ -67,6 +67,7 @@ into headers whose names match the standard.
 The following headers are available:
 
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/algorithm.hpp[`algorithm.hpp`]
+* https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/array.hpp[`array.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/atomic.hpp[`atomic.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/atomic_bitset.hpp[`atomic_bitset.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/bit.hpp[`bit.hpp`]

include/stdx/array.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <array>
+#include <type_traits>
+#include <utility>
+
+namespace stdx {
+inline namespace v1 {
+
+template <typename D = void, typename... Ts>
+constexpr auto make_array(Ts &&...ts) {
+    if constexpr (not std::is_void_v<D>) {
+        return std::array<D, sizeof...(Ts)>{std::forward<Ts>(ts)...};
+    } else {
+        using A = std::common_type_t<Ts...>;
+        return std::array<A, sizeof...(Ts)>{std::forward<Ts>(ts)...};
+    }
+}
+
+template <template <auto> typename D, typename T, T... Is>
+constexpr auto make_array(std::integer_sequence<T, Is...>) {
+    using A = std::common_type_t<decltype(D<Is>::value)...>;
+    return std::array<A, sizeof...(Is)>{D<Is>::value...};
+}
+
+template <template <auto> typename D, auto N> constexpr auto make_array() {
+    return make_array<D>(std::make_integer_sequence<decltype(N), N>{});
+}
+
+template <typename T, T... Is, typename F>
+constexpr auto make_array(std::integer_sequence<T, Is...>, F &&f) {
+    using A = std::common_type_t<decltype(f.template operator()<Is>())...>;
+    return std::array<A, sizeof...(Is)>{f.template operator()<Is>()...};
+}
+
+template <auto N, typename F> constexpr auto make_array(F &&f) {
+    return make_array(std::make_integer_sequence<decltype(N), N>{},
+                      std::forward<F>(f));
+}
+
+} // namespace v1
+} // namespace stdx

test/CMakeLists.txt

@@ -21,6 +21,7 @@ add_tests(
     FILES
     algorithm
     always_false
+    array
     atomic
     atomic_override
     atomic_bitset

test/array.cpp

@@ -0,0 +1,45 @@
+#include <stdx/array.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <array>
+
+TEST_CASE("make_array (variadic arguments)", "[array]") {
+    auto arr = stdx::make_array(1, 2, 3, 4, 5);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
+    CHECK(arr == std::array{1, 2, 3, 4, 5});
+}
+
+namespace {
+template <auto I> using V = std::integral_constant<decltype(I), I + 1>;
+}
+
+TEST_CASE("make_array by sequence (template with ::value)", "[array]") {
+    auto arr = stdx::make_array<V>(std::make_integer_sequence<int, 5>{});
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
+    CHECK(arr == std::array{1, 2, 3, 4, 5});
+}
+
+TEST_CASE("make_array by extent (template with ::value)", "[array]") {
+    auto arr = stdx::make_array<V, 5>();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
+    CHECK(arr == std::array{1, 2, 3, 4, 5});
+}
+
+namespace {
+struct {
+    template <auto I> auto operator()() { return I + 1; }
+} f;
+} // namespace
+
+TEST_CASE("make_array by sequence (factory function template)", "[array]") {
+    auto arr = stdx::make_array(std::make_integer_sequence<int, 5>{}, f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
+    CHECK(arr == std::array{1, 2, 3, 4, 5});
+}
+
+TEST_CASE("make_array by extent (factory function template)", "[array]") {
+    auto arr = stdx::make_array<5>(f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
+    CHECK(arr == std::array{1, 2, 3, 4, 5});
+}