Use placement new instead of std::construct_at. This allows me to get rid of the superconstructing_super_elider and no_lazy_construction. In other words, it compiles faster with less code and no edge cases.

Author: davidstone

source/bounded/construct_at.cpp

@@ -17,53 +17,11 @@ import std_module;
 
 namespace bounded {
 
-// https://quuxplusone.github.io/blog/2018/05/17/super-elider-round-2/
-template<typename T, typename Function>
-struct superconstructing_super_elider {
-	static_assert(std::is_reference_v<Function>);
-
-	constexpr explicit superconstructing_super_elider(Function function) noexcept:
-		m_function(OPERATORS_FORWARD(function))
-	{
-	}
-
-	// Deleting the move constructor limits the cases where this will silently
-	// collide with an "accepts anything" constructor. For instance, this class
-	// can be used with std::any.
-	superconstructing_super_elider(superconstructing_super_elider &&) = delete;
-
-	constexpr operator T() && noexcept(noexcept(static_cast<T>(declval<Function>()()))) {
-		return static_cast<T>(OPERATORS_FORWARD(m_function)());
-	}
-
-private:
-	Function m_function;
-};
-
-template<typename T>
-constexpr auto is_no_lazy_construction = false;
-
-template<typename T>
-constexpr auto is_no_lazy_construction<no_lazy_construction<T>> = true;
-
-template<typename T, typename Function>
-constexpr auto is_noexcept_construct_at = noexcept(static_cast<T>(declval<Function>()()));
-
-template<typename T, typename Function> requires is_no_lazy_construction<std::invoke_result_t<Function>>
-constexpr auto is_noexcept_construct_at<T, Function> = noexcept(static_cast<T>(declval<Function>()().value));
-
 // https://github.com/llvm/llvm-project/issues/59513
 struct construct_at_t {
 	template<non_const T, construct_function_for<T> Function>
-	static constexpr auto operator()(T & ref, Function && function) noexcept(is_noexcept_construct_at<T, Function>) -> T & {
-		auto make = [&] {
-			if constexpr (is_no_lazy_construction<std::invoke_result_t<Function>>) {
-				return OPERATORS_FORWARD(function)().value;
-			} else {
-				return superconstructing_super_elider<T, Function &&>(OPERATORS_FORWARD(function));
-			}
-		};
-		return *std::construct_at(std::addressof(ref), make());
+	static constexpr auto operator()(T & ref, Function && function) noexcept(noexcept(static_cast<T>(declval<Function>()()))) -> T & {
+		return *::new(static_cast<void *>(std::addressof(ref))) T(std::invoke(OPERATORS_FORWARD(function)));
 	}
 };
 export constexpr auto construct_at = construct_at_t();
@@ -92,7 +50,7 @@ union u {
 
 static_assert([]{
 	auto x = u();
-	bounded::construct_at(x.a, [] { return bounded::no_lazy_construction(accepts_anything(5)); });
+	bounded::construct_at(x.a, [] { return accepts_anything(5); });
 	return true;
 }());
 
@@ -108,13 +66,4 @@ struct convert_to_int_throws {
 auto make_convert_to_int_throws() noexcept -> convert_to_int_throws;
 static_assert(!noexcept(bounded::construct_at(bounded::declval<int &>(), make_convert_to_int_throws)));
 
-auto make_no_lazy_construction_int_noexcept() noexcept -> bounded::no_lazy_construction<int>;
-static_assert(noexcept(bounded::construct_at(bounded::declval<int &>(), make_no_lazy_construction_int_noexcept)));
-
-auto make_no_lazy_construction_int_throws() -> bounded::no_lazy_construction<int>;
-static_assert(!noexcept(bounded::construct_at(bounded::declval<int &>(), make_no_lazy_construction_int_throws)));
-
-auto make_no_lazy_construction_convert_to_int_throws() noexcept -> bounded::no_lazy_construction<convert_to_int_throws>;
-static_assert(!noexcept(bounded::construct_at(bounded::declval<int &>(), make_no_lazy_construction_convert_to_int_throws)));
-
 } // namespace

source/bounded/lazy_init.cpp

@@ -15,33 +15,9 @@ export struct lazy_init_t {
 };
 export constexpr auto lazy_init = lazy_init_t();
 
-// If your function returns this type, the value will be unwrapped and then
-// copied / moved instead of constructed in place. This is necessary for types
-// like `std::jthread` that have constructors with unconstrained reference
-// parameters where the conversion would not work inside the constructor.
-export template<typename T>
-struct no_lazy_construction {
-	T value;
-	constexpr operator T() && {
-		return OPERATORS_FORWARD(value);
-	}
-};
-template<typename T>
-no_lazy_construction(T) -> no_lazy_construction<T>;
-
-template<typename T>
-struct unwrapped_function_result_type {
-	using type = T;
-};
-
-template<typename T>
-struct unwrapped_function_result_type<no_lazy_construction<T>> {
-	using type = T;
-};
-
 export template<typename Function, typename T>
 concept construct_function_for = convertible_to<
-	typename unwrapped_function_result_type<std::invoke_result_t<Function>>::type,
+	std::invoke_result_t<Function>,
 	T
 >;
 

source/containers/test/test_set_size.cpp

@@ -12,6 +12,7 @@ export module containers.test.test_set_size;
 
 import containers.begin_end;
 import containers.data;
+import containers.range_value_t;
 
 import bounded;
 
@@ -48,7 +49,7 @@ constexpr auto test_add_one() -> void {
 	auto v = Container({1});
 	bounded::destroy(*containers::begin(v));
 	v.set_size(0_bi);
-	bounded::construct_at(*containers::data(v), [] { return 5; });
+	bounded::construct_at(*containers::data(v), [] { return static_cast<containers::range_value_t<Container>>(5); });
 	v.set_size(1_bi);
 	BOUNDED_ASSERT(v == Container({5}));
 }

source/containers/test/vector_benchmark.cpp

@@ -17,7 +17,7 @@ auto DoNotOptimize(auto && value) -> void {
 }
 
 template<typename T>
-auto default_value() {
+auto default_value() -> T {
 	if constexpr (std::integral<T>) {
 		return 0;
 	} else {