@@ -1,7 +1,13 @@
 #ifndef CPPUTILS_FUNCTIONAL_UTILS_HPP
 #define CPPUTILS_FUNCTIONAL_UTILS_HPP
 
+#include "../meta/traits.hpp"
+#include <algorithm>
+#include <array>
 #include <concepts>
+#include <functional>
+#include <iterator>
+#include <ranges>
 #include <utility>
 
 
@@ -32,6 +38,63 @@ namespace cpputils {
         return std::invoke(f, FWD(more_args)..., args_...);
     };
 }
+
+template <std::ranges::range Range, invocable_r<std::ranges::range_value_t<Range>> Generator>
+struct range_maker {
+    [[nodiscard]] constexpr auto operator()(Generator g, std::size_t num_items) const
+        requires std::default_initializable<Range>
+                 && (
+                     requires (Range r, Generator g_) { r.push_back(g_()); }
+                     || requires (Range r, Generator g_) { r.insert(g_()); })
+    {
+        Range rng{};
+        if constexpr (std::ranges::sized_range<Range> && requires { rng.reserve(); }) {
+            rng.reserve(num_items);
+        }
+        if constexpr (requires { rng.push_back(g()); }) {
+            std::ranges::generate_n(std::back_inserter(rng),
+                                    static_cast<std::iter_difference_t<decltype(std::back_inserter(rng))>>(num_items),
+                                    g);
+        } else {
+            for (std::size_t i = 0; i < num_items; ++i) {
+                rng.insert(g());
+            }
+        }
+
+        return rng;
+    }
+};
+
+namespace detail {
+    template <typename T>
+    struct is_cstyle_array : std::false_type {};
+
+    template <typename T, std::size_t N>
+    struct is_cstyle_array<T[N]> : std::true_type {};  // NOLINT
+}  // namespace detail
+
+template <typename T, std::size_t N, invocable_r<T> Generator>
+struct range_maker<std::array<T, N>, Generator> {
+    [[nodiscard]] constexpr auto operator()(Generator g) const {
+        return generator_function(std::move(g), std::make_index_sequence<N>{});
+    }
+
+private:
+    template <auto... Is>
+    [[nodiscard]] static constexpr auto generator_function(Generator g, std::index_sequence<Is...>) {
+        return std::array<T, N>{[&](auto) { return g(); }(Is)...};
+    }
+};
+
+template <typename Range>
+inline constexpr auto make_range = []<typename Generator, typename... Args>(Generator g, Args... args)
+    requires std::invocable<range_maker<Range, Generator>, Generator, Args...>
+{
+    static_assert(!detail::is_cstyle_array<Range>::value, "C-style arrays cannot be returned from functions, use std::array");
+    auto const factory = range_maker<Range, Generator>{};
+    return factory(std::move(g), args...);
+};
+
 }  // namespace cpputils
 
 #undef FWD
 
@@ -74,6 +74,9 @@ inline constexpr auto is_duration_v = is_duration<D>::value;
 template <typename D>
 concept duration = is_duration_v<D>;
 
+template <typename F, typename R, typename... Args>
+concept invocable_r = std::is_invocable_r_v<R, F, Args...>;
+
 template <typename T>
 concept pair_like =
     requires (T t) {
 
@@ -35,6 +35,7 @@ ${TEST_PATH}/operator_sections_test.cpp
 ${TEST_PATH}/container_views_test.cpp
 ${TEST_PATH}/lazy_test.cpp
 ${TEST_PATH}/benchmark_test.cpp
+${TEST_PATH}/range_maker_test.cpp
 )
 
 add_executable(cpputils_test ${TEST_FILES})
 
@@ -0,0 +1,44 @@
+#include "cpputils/functional/utils.hpp"
+#include <catch2/catch_all.hpp>
+
+#include <array>
+#include <list>
+#include <map>
+#include <vector>
+
+
+using namespace cpputils;
+
+TEST_CASE("make-vector", "[range-maker-test]") {
+    auto const v = make_range<std::vector<int>>([n = 0]() mutable { return n++; }, 3U);
+    REQUIRE(v.size() == 3);
+    REQUIRE(v[0] == 0);
+    REQUIRE(v[1] == 1);
+    REQUIRE(v[2] == 2);
+}
+
+TEST_CASE("make-list", "[range-maker-test]") {
+    auto const v = make_range<std::list<int>>([n = 0]() mutable { return n++; }, 3U);
+    REQUIRE(v.size() == 3);
+    int current{};
+    for (auto i : v) {
+        REQUIRE(i == current);
+        ++current;
+    }
+}
+
+TEST_CASE("make-map", "[range-maker-test]") {
+    using value_type = std::map<int, int>::value_type;
+    auto const v = make_range<std::map<int, int>>([n = 0]() mutable { return value_type{n++, n}; }, 3U);
+    REQUIRE(v.size() == 3);
+    REQUIRE(v.at(0) == 1);
+    REQUIRE(v.at(1) == 2);
+    REQUIRE(v.at(2) == 3);
+}
+
+TEST_CASE("make-array", "[range-maker-test]") {
+    constexpr auto v = make_range<std::array<int, 3>>([n = 0]() mutable { return n++; });
+    REQUIRE(v[0] == 0);
+    REQUIRE(v[1] == 1);
+    REQUIRE(v[2] == 2);
+}
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ ${TEST_PATH}/operator_sections_test.cpp`
`35`	`35`	`${TEST_PATH}/container_views_test.cpp`
`36`	`36`	`${TEST_PATH}/lazy_test.cpp`
`37`	`37`	`${TEST_PATH}/benchmark_test.cpp`
	`38`	`+${TEST_PATH}/range_maker_test.cpp`
`38`	`39`	`)`
`39`	`40`
`40`	`41`	`add_executable(cpputils_test ${TEST_FILES})`