From 470146ea1486968bf837fd7eed3f57f999ce5965 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Fri, 30 Jan 2026 08:21:28 -0700
Subject: [PATCH] :sparkles: 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)`.
---
 CMakeLists.txt         |  1 +
 docs/intro.adoc        |  1 +
 include/stdx/array.hpp | 42 +++++++++++++++++++++++++++++++++++++++
 test/CMakeLists.txt    |  1 +
 test/array.cpp         | 45 ++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 90 insertions(+)
 create mode 100644 include/stdx/array.hpp
 create mode 100644 test/array.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b5dba32..0d7df84 100644
--- a/CMakeLists.txt
+++ b/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
diff --git a/docs/intro.adoc b/docs/intro.adoc
index 90f22ae..5a446cc 100644
--- a/docs/intro.adoc
+++ b/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`]
diff --git a/include/stdx/array.hpp b/include/stdx/array.hpp
new file mode 100644
index 0000000..b0952de
--- /dev/null
+++ b/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
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bcfa47d..da67474 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -21,6 +21,7 @@ add_tests(
     FILES
     algorithm
     always_false
+    array
     atomic
     atomic_override
     atomic_bitset
diff --git a/test/array.cpp b/test/array.cpp
new file mode 100644
index 0000000..c4a8014
--- /dev/null
+++ b/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});
+}