[libc++][ranges] Implement `ranges::generate{,_n}`.

[var-const]

Use the actual patch number.

[var-const]

Fix the CI and rebase.

[huixie90]

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/ranges_generate.pass.cpp

139

bit: would it be possible to pass in uninitialized array instead ?

[var-const]

Address feedback and rebase.

[ldionne]

libcxx/include/__algorithm/ranges_generate.h

47

This is a weird constraint, I would have expected _OutIter to be an output_iterator instead.

I don't think we are testing for this, and I'm not asking that you add tests for it. However, it looks like the Standard doesn't want implementations to assume that *it++ = expr is valid, and they want us to use *it = expr; ++it instead (which we do).

libcxx/include/__algorithm/ranges_generate_n.h

42

We should technically be using std::invoke here according to the concept requirements specified in the signature (all we have is invocable<_Func&>). However, I don't think there is any way to distinguish __gen() from invoke(gen) given that it's being called with no arguments. I tried finding a case but couldn't.

So, nothing to do.

[huixie90]

libcxx/include/__algorithm/ranges_generate.h

47

in fact, lots of algorithms are constrained with x_iterator and indirectly_writable. very few of them actually use output_iterator. I wonder what is the reason behind it.

libcxx/include/__algorithm/ranges_generate_n.h

42

I was about to say the same and actually tried very hard. but could not find an example where gen() does not work while invoke(gen) works.

Although nothing to do here, I'd like to share how far I went.
You can use gen() even if gen doesn't have operator() but convertible to a function pointer.
https://godbolt.org/z/b11erWhcc

[var-const]

Add comment and rebase.

[var-const]

libcxx/include/__algorithm/ranges_generate_n.h

42

Thank you! This idea is pretty ingenious, cool that calling it directly still works.

libcxx/docs/Status/RangesAlgorithms.csv

 Write,copy_if,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,copy_n,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,copy_backward,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,move,Nikolas Klauser,`D126616 <https://llvm.org/D126616>`_,✅
 Write,move_backward,Nikolas Klauser,`D126616 <https://llvm.org/D126616>`_,✅
 Write,fill,Nikolas Klauser,`D123462 <https://llvm.org/D123462>`_,✅
 Write,fill_n,Nikolas Klauser,`D123462 <https://llvm.org/D123462>`_,✅
 Write,transform,Nikolas Klauser,`D122173 <https://llvm.org/D122173>`_,✅
-Write,generate,Nikolas Klauser,n/a,Not started
-Write,generate_n,Nikolas Klauser,n/a,Not started
+Write,generate,Konstantin Varlamov,`D130552 <https://llvm.org/D130552>`_,✅
+Write,generate_n,Konstantin Varlamov,`D130552 <https://llvm.org/D130552>`_,✅
 Write,remove_copy,Nikolas Klauser,n/a,Not started
 Write,remove_copy_if,Nikolas Klauser,n/a,Not started
 Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_copy,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
 Write,replace_copy_if,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
 Write,swap_ranges,Nikolas Klauser,`D116303 <https://llvm.org/D116303>`_,✅
 Write,reverse_copy,Nikolas Klauser,`D127211 <https://llvm.org/D127211>`_,✅

libcxx/include/__algorithm/ranges_generate.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_RANGES_GENERATE_H
 #define _LIBCPP___ALGORITHM_RANGES_GENERATE_H
 
-#include <__algorithm/generate.h>
-#include <__algorithm/make_projected.h>
 #include <__concepts/constructible.h>
 #include <__concepts/invocable.h>
 #include <__config>
-#include <__functional/identity.h>
 #include <__functional/invoke.h>
-#include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
-#include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __generate {
 
 struct __fn {
 
+  template <class _OutIter, class _Sent, class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  static _OutIter __generate_fn_impl(_OutIter __first, _Sent __last, _Func& __gen) {
+    for (; __first != __last; ++__first) {
+      *__first = __gen();
+    }
+
+    return __first;
+  }
+
   template <input_or_output_iterator _OutIter, sentinel_for<_OutIter> _Sent, copy_constructible _Func>
   requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
   _LIBCPP_HIDE_FROM_ABI constexpr
   _OutIter operator()(_OutIter __first, _Sent __last, _Func __gen) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__gen;
-    return {};
+    return __generate_fn_impl(std::move(__first), std::move(__last), __gen);
   }
 
   template <class _Range, copy_constructible _Func>
   requires invocable<_Func&> && output_range<_Range, invoke_result_t<_Func&>>
   _LIBCPP_HIDE_FROM_ABI constexpr
   borrowed_iterator_t<_Range> operator()(_Range&& __range, _Func __gen) const {
-    // TODO: implement
-    (void)__range; (void)__gen;
-    return {};
+    return __generate_fn_impl(ranges::begin(__range), ranges::end(__range), __gen);
   }
 
 };
 
 } // namespace __generate
 
 inline namespace __cpo {
   inline constexpr auto generate = __generate::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_H

libcxx/include/__algorithm/ranges_generate_n.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H
 #define _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H
 
-#include <__algorithm/generate_n.h>
-#include <__algorithm/make_projected.h>
 #include <__concepts/constructible.h>
 #include <__concepts/invocable.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
-#include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
-#include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __generate_n {
 
 struct __fn {
 
   template <input_or_output_iterator _OutIter, copy_constructible _Func>
   requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
   _LIBCPP_HIDE_FROM_ABI constexpr
   _OutIter operator()(_OutIter __first, iter_difference_t<_OutIter> __n, _Func __gen) const {
-    // TODO: implement
-    (void)__first; (void)__n; (void)__gen;
-    return {};
+    for (; __n > 0; --__n) {
+      *__first = __gen();
+      ++__first;
+    }
+
+    return __first;
   }
 
 };
 
 } // namespace __generate_n
 
 inline namespace __cpo {
   inline constexpr auto generate_n = __generate_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H

libcxx/include/algorithm

template<class T, output_iterator<const T&> O, sentinel_for<O> S>
     constexpr O ranges::fill(O first, S last, const T& value);                              // since C++20
 
   template<class T, output_range<const T&> R>
     constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value);                   // since C++20
 
   template<class T, output_iterator<const T&> O>
     constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value);            // since C++20
 
+  template<input_or_output_iterator O, sentinel_for<O> S, copy_constructible F>
+    requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+    constexpr O generate(O first, S last, F gen);                                           // Since C++20
+
+  template<class R, copy_constructible F>
+    requires invocable<F&> && output_range<R, invoke_result_t<F&>>
+    constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                // Since C++20
+
+  template<input_or_output_iterator O, copy_constructible F>
+    requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
+    constexpr O generate_n(O first, iter_difference_t<O> n, F gen);                         // Since C++20
+
  template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
    requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
    constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
                                 Pred pred = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 
  template<input_range R1, input_range R2, class Pred = ranges::equal_to,

 #include <__algorithm/ranges_fill_n.h>
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_end.h>
 #include <__algorithm/ranges_find_first_of.h>
 #include <__algorithm/ranges_find_if.h>
 #include <__algorithm/ranges_find_if_not.h>
 #include <__algorithm/ranges_for_each.h>
 #include <__algorithm/ranges_for_each_n.h>
+#include <__algorithm/ranges_generate.h>
+#include <__algorithm/ranges_generate_n.h>
 #include <__algorithm/ranges_includes.h>
 #include <__algorithm/ranges_is_partitioned.h>
 #include <__algorithm/ranges_is_sorted.h>
 #include <__algorithm/ranges_is_sorted_until.h>
 #include <__algorithm/ranges_lexicographical_compare.h>
 #include <__algorithm/ranges_lower_bound.h>
 #include <__algorithm/ranges_make_heap.h>
 #include <__algorithm/ranges_max.h>

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/ranges_generate.pass.cpp

 //   requires invocable<F&> && output_range<R, invoke_result_t<F&>>
 //   constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                       // Since C++20
 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
+#include <utility>
 
 #include "almost_satisfies_types.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+struct IntGen {
+  int operator()() const;
+};
+
+struct UncopyableGen {
+  UncopyableGen(const UncopyableGen&) = delete;
+  int operator()() const;
+};
+static_assert(!std::copy_constructible<UncopyableGen>);
+static_assert(std::invocable<UncopyableGen>);
+
+struct UninvocableGen {
+};
+static_assert(std::copy_constructible<UninvocableGen>);
+static_assert(!std::invocable<UninvocableGen>);
+
+struct IntPtrGen {
+  int* operator()() const;
+};
+
+// Test constraints of the (iterator, sentinel) overload.
+// ======================================================
+
+template <class Iter = int*, class Sent = int*, class Gen = IntGen>
+concept HasGenerateIter =
+    requires(Iter&& iter, Sent&& sent, Gen&& gen) {
+      std::ranges::generate(std::forward<Iter>(iter), std::forward<Sent>(sent), std::forward<Gen>(gen));
+    };
+
+static_assert(HasGenerateIter<int*, int*, IntGen>);
+
+// !input_or_output_iterator<O>
+static_assert(!HasGenerateIter<InputIteratorNotInputOrOutputIterator>);
+
+// !sentinel_for<S, O>
+static_assert(!HasGenerateIter<int*, SentinelForNotSemiregular>);
+static_assert(!HasGenerateIter<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+// !copy_constructible<F>
+static_assert(!HasGenerateIter<int*, int*, UncopyableGen>);
+
+// !invocable<F&>
+static_assert(!HasGenerateIter<int*, int*, UninvocableGen>);
+
+// !indirectly_writable<O, invoke_result_t<F&>>
+static_assert(!HasGenerateIter<int*, int*, IntPtrGen>);
+
+// Test constraints of the (range) overload.
+// =========================================
+
+template <class Range, class Gen = IntGen>
+concept HasGenerateRange =
+    requires(Range&& range, Gen&& gen) {
+      std::ranges::generate(std::forward<Range>(range), std::forward<Gen>(gen));
+    };
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasGenerateRange<R<int*>, IntGen>);
+
+// !copy_constructible<F>
+static_assert(!HasGenerateRange<R<int*>, UncopyableGen>);
+
+// !invocable<F&>
+static_assert(!HasGenerateRange<R<int*>, UninvocableGen>);
+
+// !output_range<R, invoke_result_t<F&>>
+static_assert(!HasGenerateRange<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasGenerateRange<R<int*>, IntPtrGen>);
+
+template <class Iter, class Sent, size_t N, class Gen>
+constexpr void test_one(const std::array<int, N> input, Gen gen, std::array<int, N> expected) {
+  { // (iterator, sentinel) overload.
+    auto in = input;
+    auto begin = Iter(in.data());
+    auto end = Sent(Iter(in.data() + in.size()));
+
+    std::same_as<Iter> decltype(auto) result = std::ranges::generate(std::move(begin), std::move(end), gen);
+    assert(base(result) == in.data() + in.size());
+    assert(in == expected);
+  }
+
+  { // (range) overload.
+    auto in = input;
+    auto begin = Iter(in.data());
+    auto end = Sent(Iter(in.data() + in.size()));
+    auto range = std::ranges::subrange(std::move(begin), std::move(end));
+
+    // For some reason `ranges::generate` accepts both input and output iterators but only output (not input) ranges.
+    if constexpr (std::ranges::output_range<decltype(range), std::invoke_result_t<Gen&>>) {
+      std::same_as<Iter> decltype(auto) result = std::ranges::generate(std::move(range), gen);
+      assert(base(result) == in.data() + in.size());
+      assert(in == expected);
+    }
+  }
+}
+
+template <class Iter, class Sent>
+constexpr void test_iter_sent() {
+  auto gen = [ctr = 1] () mutable { return ctr++; };
+
+  // Empty sequence.
+  test_one<Iter, Sent, 0>({}, gen, {});
+  // 1-element sequence.
+  test_one<Iter, Sent>(std::array{-10}, gen, {1});
+  // Longer sequence.
+  test_one<Iter, Sent>(std::array<int, 5>{}, gen, {1, 2, 3, 4, 5});
+}
+
+template <class Iter>
+constexpr void test_iter() {
+  if constexpr (std::sentinel_for<Iter, Iter>) {
+    test_iter_sent<Iter, Iter>();
+  }
+  test_iter_sent<Iter, sentinel_wrapper<Iter>>();
+}
+
+constexpr void test_iterators() {
+  test_iter<cpp17_input_iterator<int*>>();
+  test_iter<cpp20_input_iterator<int*>>();
+  test_iter<cpp17_output_iterator<int*>>();
+  test_iter<cpp20_output_iterator<int*>>();
+  test_iter<forward_iterator<int*>>();
+  test_iter<bidirectional_iterator<int*>>();
+  test_iter<random_access_iterator<int*>>();
+  test_iter<contiguous_iterator<int*>>();
+  test_iter<int*>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_iterators();
+
+  { // Complexity: exactly N evaluations of `gen()` and assignments.
+    struct AssignedOnce {
+      bool assigned = false;
+      constexpr AssignedOnce& operator=(const AssignedOnce&) {
+        assert(!assigned);
+        assigned = true;
+        return *this;
+      }
+    };
+
+    { // (iterator, sentinel) overload.
+      int gen_invocations = 0;
+      auto gen = [&gen_invocations] { ++gen_invocations; return AssignedOnce(); };
+      constexpr size_t N = 10;
+      std::array<AssignedOnce, N> in;
+
+      std::ranges::generate(in.begin(), in.end(), gen);
+      assert(std::ranges::all_of(in, &AssignedOnce::assigned));
+      assert(gen_invocations == N);
+    }
+
+    { // (range) overload.
+      int gen_invocations = 0;
+      auto gen = [&gen_invocations] { ++gen_invocations; return AssignedOnce(); };
+      constexpr size_t N = 10;
+      std::array<AssignedOnce, N> in;
+
+      std::ranges::generate(in, gen);
+      assert(std::ranges::all_of(in, &AssignedOnce::assigned));
+      assert(gen_invocations == N);
+    }
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/ranges_generate_n.pass.cpp

 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
 
 #include "almost_satisfies_types.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+struct IntGen {
+  int operator()() const;
+};
+
+struct UncopyableGen {
+  UncopyableGen(const UncopyableGen&) = delete;
+  int operator()() const;
+};
+static_assert(!std::copy_constructible<UncopyableGen>);
+static_assert(std::invocable<UncopyableGen>);
+
+struct UninvocableGen {
+};
+static_assert(std::copy_constructible<UninvocableGen>);
+static_assert(!std::invocable<UninvocableGen>);
+
+struct IntPtrGen {
+  int* operator()() const;
+};
+
+// Test type constraints.
+// ======================================================
+
+template <class Iter = int*, class Gen = IntGen>
+concept HasGenerateNIter =
+    requires(Iter&& iter, Gen&& gen) {
+      std::ranges::generate_n(std::forward<Iter>(iter), 0, std::forward<Gen>(gen));
+    };
+
+static_assert(HasGenerateNIter<int*, IntGen>);
+
+// !input_or_output_iterator<O>
+static_assert(!HasGenerateNIter<InputIteratorNotInputOrOutputIterator>);
+
+// !copy_constructible<F>
+static_assert(!HasGenerateNIter<int*, UncopyableGen>);
+
+// !invocable<F&>
+static_assert(!HasGenerateNIter<int*, UninvocableGen>);
+
+// !indirectly_writable<O, invoke_result_t<F&>>
+static_assert(!HasGenerateNIter<int*, IntPtrGen>);
+
+template <class Iter, size_t N, class Gen>
+constexpr void test_one(std::array<int, N> in, size_t n, Gen gen, std::array<int, N> expected) {
+  assert(n <= N);
+
+  auto begin = Iter(in.data());
+
+  std::same_as<Iter> decltype(auto) result = std::ranges::generate_n(std::move(begin), n, gen);
+  assert(base(result) == in.data() + n);
+  assert(in == expected);
+}
+
+template <class Iter>
+constexpr void test_iter() {
+  auto gen = [ctr = 1] () mutable { return ctr++; };
+
+  // Empty sequence.
+  test_one<Iter, 0>({}, 0, gen, {});
+  // 1-element sequence, n = 0.
+  test_one<Iter>(std::array{-10}, 0, gen, {-10});
+  // 1-element sequence, n = 1.
+  test_one<Iter>(std::array{-10}, 1, gen, {1});
+  // Longer sequence, n = 3.
+  test_one<Iter>(std::array{-10, -20, -30, -40, -50}, 3, gen, {1, 2, 3, -40, -50});
+  // Longer sequence, n = 5.
+  test_one<Iter>(std::array<int, 5>{}, 5, gen, {1, 2, 3, 4, 5});
+}
+
+constexpr void test_iterators() {
+  test_iter<cpp17_input_iterator<int*>>();
+  test_iter<cpp20_input_iterator<int*>>();
+  test_iter<cpp17_output_iterator<int*>>();
+  test_iter<cpp20_output_iterator<int*>>();
+  test_iter<forward_iterator<int*>>();
+  test_iter<bidirectional_iterator<int*>>();
+  test_iter<random_access_iterator<int*>>();
+  test_iter<contiguous_iterator<int*>>();
+  test_iter<int*>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_iterators();
+
+  { // Complexity: exactly N evaluations of `gen()` and assignments.
+    struct AssignedOnce {
+      bool assigned = false;
+      constexpr AssignedOnce& operator=(const AssignedOnce&) {
+        assert(!assigned);
+        assigned = true;
+        return *this;
+      }
+    };
+
+    int gen_invocations = 0;
+    auto gen = [&gen_invocations] { ++gen_invocations; return AssignedOnce(); };
+    constexpr size_t N1 = 10;
+    constexpr size_t N2 = N1 / 2;
+    std::array<AssignedOnce, N1> in;
+
+    auto result = std::ranges::generate_n(in.begin(), N2, gen);
+    assert(std::ranges::all_of(std::ranges::subrange(in.begin(), result), &AssignedOnce::assigned));
+    assert(std::ranges::none_of(std::ranges::subrange(result, in.end()), &AssignedOnce::assigned));
+    assert(gen_invocations == N2);
+  }
+
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

constexpr bool test_all() {
   using std::ranges::set_symmetric_difference_result;
   using std::ranges::set_union_result;
   using std::ranges::swap_ranges_result;
   using std::ranges::unary_transform_result;
   //using std::ranges::unique_copy_result;
 
   auto unary_pred = [](int i) { return i > 0; };
   auto binary_pred = [](int i, int j) { return i < j; };
-  //auto gen = [] { return 42; };
+  auto gen = [] { return 42; };
 
   std::array in = {1, 2, 3};
   std::array in2 = {4, 5, 6};
 
   auto mid = in.begin() + 1;
 
   std::array output = {7, 8, 9, 10, 11, 12};
   auto out = output.begin();
dangling_1st(std::ranges::fill, in, x);
     dangling_1st<unary_transform_result<dangling, bool*>>(std::ranges::transform, in, out_transform.begin(), unary_pred);
     dangling_1st<binary_transform_result<dangling, int*, bool*>>(
         std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
     dangling_2nd<binary_transform_result<int*, dangling, bool*>>(
         std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
     dangling_both<binary_transform_result<dangling, dangling, bool*>>(
         std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
   }
-  //dangling_1st(std::ranges::generate, in, gen);
+  dangling_1st(std::ranges::generate, in, gen);
   //dangling_1st<remove_copy_result<dangling, int*>>(std::ranges::remove_copy, in, out, x);
   //dangling_1st<remove_copy_if_result<dangling, int*>>(std::ranges::remove_copy_if, in, out, unary_pred);
   dangling_1st(std::ranges::replace, in, x, x);
   dangling_1st(std::ranges::replace_if, in, std::identity{}, x);
   //dangling_1st(std::ranges::replace_copy, in, out, x, x);
   //dangling_1st(std::ranges::replace_copy_if, in, out, x, x);
   dangling_1st<swap_ranges_result<dangling, int*>>(std::ranges::swap_ranges, in, in2);
   dangling_2nd<swap_ranges_result<int*, dangling>>(std::ranges::swap_ranges, in, in2);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp

constexpr bool test_all() {
   // `copy`, `copy_n` and `copy_backward` have neither a projection nor a predicate.
   test(std::ranges::copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `move` and `move_backward` have neither a projection nor a predicate.
   // `fill` and `fill_n` have neither a projection nor a predicate.
   {
     std::array out_transform = {false, true, true};
     test(std::ranges::transform, in, out_transform.begin(), &Foo::unary_pred, &Bar::val);
   }
-  //test(std::ranges::generate, in, &Bar::create);
-  //std::ranges::generate_n(in.begin(), count, &Bar::create);
+  // Whether `ranges::generate{,_n}` invokes `gen` via `std::invoke` is not observable.
   //test(std::ranges::remove_copy, in, out, x, &Bar::val);
   //test(std::ranges::remove_copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `replace*` algorithms only use the projection to compare the elements, not to write them.
   test(std::ranges::replace, in, x, a, &Bar::val);
   test(std::ranges::replace_if, in, &Foo::unary_pred, a, &Bar::val);
   //test(std::ranges::replace_copy, in, out, x, a, &Bar::val);
   //test(std::ranges::replace_copy_if, in, out, pred, a, &Bar::val);
   // `swap_ranges` has neither a projection nor a predicate.

libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp

constexpr void run_tests() {
 
   T num{2};
   Proxy<T&> x{num};
   int count = 1;
 
   auto unary_pred = [](const Proxy<T&>&) { return true; };
   //auto binary_pred = [](const Proxy<T>&, const Proxy<T>&) { return return false; };
   auto binary_func = [](const Proxy<T>&, const Proxy<T>&) -> Proxy<T> { return Proxy<T>(T()); };
-  //auto gen = [] { return Proxy<T>(T{42}); };
+  auto gen = [] { return Proxy<T>(T{42}); };
 
   test(std::ranges::any_of, in, unary_pred);
   test(std::ranges::all_of, in, unary_pred);
   test(std::ranges::none_of, in, unary_pred);
   test(std::ranges::find, in, x);
   test(std::ranges::find_if, in, unary_pred);
   test(std::ranges::find_if_not, in, unary_pred);
   test(std::ranges::find_first_of, in, in2);
constexpr void run_tests() {
   // TODO: uncomment `move_backward` once https://reviews.llvm.org/D128864 lands.
   // test(std::ranges::move_backward, in, out);
   if constexpr (std::copyable<T>) {
     test(std::ranges::fill, in, x);
     std::ranges::fill_n(in.begin(), count, x);
     test(std::ranges::transform, in, out, std::identity{});
     test(std::ranges::transform, in, in2, out, binary_func);
   }
-  //test(std::ranges::generate, in, gen);
-  //std::ranges::generate_n(in.begin(), count, gen);
+  test(std::ranges::generate, in, gen);
+  std::ranges::generate_n(in.begin(), count, gen);
   if constexpr (std::copyable<T>) {
   //test(std::ranges::remove_copy, in, out, x);
   //test(std::ranges::remove_copy_if, in, out, unary_pred);
     test(std::ranges::replace, in, x, x);
     test(std::ranges::replace_if, in, unary_pred, x);
     //test(std::ranges::replace_copy, in, out, x, x);
     //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   }

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

constexpr bool test(CPO& o, Args&&...) {
 
   return true;
 }
 
 int *p;
 int a[10];
 auto odd = [](int x) { return x % 2 != 0; };
 auto triple = [](int x) { return 3*x; };
-//auto gen = [] { return 42; };
+auto gen = [] { return 42; };
 //auto plus = [](int x, int y) { return x == y; };
 std::mt19937 g;
 
 // [algorithm.syn]
 
 static_assert(test(std::ranges::adjacent_find, a));
 static_assert(test(std::ranges::all_of, a, odd));
 static_assert(test(std::ranges::any_of, a, odd));

 static_assert(test(std::ranges::fill_n, a, 10, 42));
 static_assert(test(std::ranges::find, a, 42));
 static_assert(test(std::ranges::find_end, a, a));
 //static_assert(test(std::ranges::find_first_of, a, a));
 static_assert(test(std::ranges::find_if, a, odd));
 static_assert(test(std::ranges::find_if_not, a, odd));
 static_assert(test(std::ranges::for_each, a, odd));
 static_assert(test(std::ranges::for_each_n, a, 10, odd));
-//static_assert(test(std::ranges::generate, a, gen));
-//static_assert(test(std::ranges::generate_n, a, 10, gen));
+static_assert(test(std::ranges::generate, a, gen));
+static_assert(test(std::ranges::generate_n, a, 10, gen));
 static_assert(test(std::ranges::includes, a, a));
 //static_assert(test(std::ranges::inplace_merge, a, a+5));
 //static_assert(test(std::ranges::is_heap, a));
 //static_assert(test(std::ranges::is_heap_until, a));
 static_assert(test(std::ranges::is_partitioned, a, odd));
 //static_assert(test(std::ranges::is_permutation, a, a));
 static_assert(test(std::ranges::is_sorted, a));
 static_assert(test(std::ranges::is_sorted_until, a));