From f63b6c07ca3e14758df1a815d71e90b971c8f6f5 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 12 Mar 2026 19:08:16 -0600
Subject: [PATCH] :bug: Fix `make_array` for zero-length cases

Problem:
- `make_array` doesn't work when given length zero.

Solution:
- Fix that.
---
 include/stdx/array.hpp |  6 ++++--
 test/array.cpp         | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/include/stdx/array.hpp b/include/stdx/array.hpp
index b0952de..15d358e 100644
--- a/include/stdx/array.hpp
+++ b/include/stdx/array.hpp
@@ -11,6 +11,8 @@ 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 if constexpr (sizeof...(Ts) == 0) {
+        return std::array<int, 0>{};
     } else {
         using A = std::common_type_t<Ts...>;
         return std::array<A, sizeof...(Ts)>{std::forward<Ts>(ts)...};
@@ -19,7 +21,7 @@ constexpr auto make_array(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)...>;
+    using A = std::remove_const_t<decltype(D<T{}>::value)>;
     return std::array<A, sizeof...(Is)>{D<Is>::value...};
 }
 
@@ -29,7 +31,7 @@ template <template <auto> typename D, auto N> constexpr auto make_array() {
 
 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>())...>;
+    using A = std::remove_const_t<decltype(f.template operator()<T{}>())>;
     return std::array<A, sizeof...(Is)>{f.template operator()<Is>()...};
 }
 
diff --git a/test/array.cpp b/test/array.cpp
index c4a8014..41e34f6 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -10,6 +10,16 @@ TEST_CASE("make_array (variadic arguments)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array (zero case)", "[array]") {
+    auto arr = stdx::make_array<float>();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<float, 0>>);
+}
+
+TEST_CASE("make_array (zero case default)", "[array]") {
+    auto arr = stdx::make_array();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 namespace {
 template <auto I> using V = std::integral_constant<decltype(I), I + 1>;
 }
@@ -20,12 +30,24 @@ TEST_CASE("make_array by sequence (template with ::value)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array by sequence - zero case (template with ::value)",
+          "[array]") {
+    auto arr = stdx::make_array<V>(std::make_integer_sequence<int, 0>{});
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 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});
 }
 
+TEST_CASE("make_array by extent - zero case (template with ::value)",
+          "[array]") {
+    auto arr = stdx::make_array<V, 0>();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 namespace {
 struct {
     template <auto I> auto operator()() { return I + 1; }
@@ -38,8 +60,20 @@ TEST_CASE("make_array by sequence (factory function template)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array by sequence - zero case (factory function template)",
+          "[array]") {
+    auto arr = stdx::make_array(std::make_integer_sequence<int, 0>{}, f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 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});
 }
+
+TEST_CASE("make_array by extent - zero case (factory function template)",
+          "[array]") {
+    auto arr = stdx::make_array<0>(f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}