diff --git a/algorithms.tex b/algorithms.tex
index d709014a..1f88c886 100644
--- a/algorithms.tex
+++ b/algorithms.tex
@@ -480,15 +480,17 @@
   template <class T, OutputIterator<const T&> O>
     O fill_n(O first, difference_type_t<O> n, const T& value);
 
-  template <Invocable F, OutputIterator<result_of_t<F&()>> O,
-      Sentinel<O> S>
+  template <CopyConstructible F, Iterator O, Sentinel<O> S>
+      requires Callable<F&>() && Writable<O, result_of_t<F&()>>()
     O generate(O first, S last, F gen);
 
-  template <Invocable F, OutputRange<result_of_t<F&()>> Rng>
+  template <CopyConstructible F, class Rng>
+      requires Callable<F&>() && OutputRange<Rng, result_of_t<F&()>>()
     safe_iterator_t<Rng>
       generate(Rng&& rng, F gen);
 
-  template <Invocable F, OutputIterator<result_of_t<F&()>> O>
+  template <CopyConstructible F, Iterator O>
+      requires Callable<F&>() && Writable<O, result_of_t<F&()>>()
     O generate_n(O first, difference_type_t<O> n, F gen);
 
   template <ForwardIterator I, Sentinel<I> S, class T, class Proj = identity>
@@ -2415,15 +2417,17 @@
 \indexlibrary{\idxcode{generate}}%
 \indexlibrary{\idxcode{generate_n}}%
 \begin{itemdecl}
-template <Invocable F, OutputIterator<result_of_t<F&()>> O,
-    Sentinel<O> S>
+template <CopyConstructible F, Iterator O, Sentinel<O> S>
+    requires Callable<F&>() && Writable<O, result_of_t<F&()>>()
   O generate(O first, S last, F gen);
 
-template <Invocable F, OutputRange<result_of_t<F&()>> Rng>
+template <CopyConstructible F, class Rng>
+    requires Callable<F&>() && OutputRange<Rng, result_of_t<F&()>>()
   safe_iterator_t<Rng>
     generate(Rng&& rng, F gen);
 
-template <Invocable F, OutputIterator<result_of_t<F&()>> O>
+template <CopyConstructible F, Iterator O>
+    requires Callable<F&>() && Writable<O, result_of_t<F&()>>()
   O generate_n(O first, difference_type_t<O> n, F gen);
 \end{itemdecl}
 
diff --git a/concepts.tex b/concepts.tex
index 4079bb4b..4ea86102 100644
--- a/concepts.tex
+++ b/concepts.tex
@@ -1087,9 +1087,8 @@
 \begin{itemdecl}
 template <class F, class... Args>
 concept bool Invocable() {
-  return CopyConstructible<F>() &&
-    requires(F f, Args&&... args) {
-      invoke(f, std::forward<Args>(args)...); // not required to be equality preserving
+  return requires(F&& f, Args&&... args) {
+      invoke(std::forward<F>(f), std::forward<Args>(args)...); // not required to be equality preserving
     };
 }
 \end{itemdecl}
@@ -1134,7 +1133,7 @@
 template <class F, class... Args>
 concept bool Predicate() {
   return RegularInvocable<F, Args...>() &&
-    Boolean<result_of_t<F&(Args...)>>();
+    Boolean<result_of_t<F&&(Args&&...)>>();
 }
 \end{itemdecl}
 
diff --git a/iterators.tex b/iterators.tex
index 49515456..72d215cf 100644
--- a/iterators.tex
+++ b/iterators.tex
@@ -1533,81 +1533,91 @@
 \begin{codeblock}
   template <class F>
   concept bool IndirectInvocable() {
-    return Invocable<F>();
+    return CopyConstructible<F>() &&
+      Invocable<F&>();
   }
   template <class F, class I>
   concept bool IndirectInvocable() {
     return Readable<I>() &&
-      Invocable<F, value_type_t<I>>() &&
-      Invocable<F, reference_t<I>>() &&
-      Invocable<F, iter_common_reference_t<I>>();
+      CopyConstructible<F>() &&
+      Invocable<F&, value_type_t<I>&>() &&
+      Invocable<F&, reference_t<I>>() &&
+      Invocable<F&, iter_common_reference_t<I>>();
   }
   template <class F, class I1, class I2>
   concept bool IndirectInvocable() {
     return Readable<I1>() && Readable<I2>() &&
-      Invocable<F, value_type_t<I1>, value_type_t<I2>>() &&
-      Invocable<F, value_type_t<I1>, reference_t<I2>>() &&
-      Invocable<F, reference_t<I1>, value_type_t<I2>>() &&
-      Invocable<F, reference_t<I1>, reference_t<I2>>() &&
-      Invocable<F, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
+      CopyConstructible<F>() &&
+      Invocable<F&, value_type_t<I1>&, value_type_t<I2>&>() &&
+      Invocable<F&, value_type_t<I1>&, reference_t<I2>>() &&
+      Invocable<F&, reference_t<I1>, value_type_t<I2>&>() &&
+      Invocable<F&, reference_t<I1>, reference_t<I2>>() &&
+      Invocable<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
   }
 
   template <class F>
   concept bool IndirectRegularInvocable() {
-    return RegularInvocable<F>();
+    return CopyConstructible<F>() &&
+      RegularInvocable<F&>();
   }
   template <class F, class I>
   concept bool IndirectRegularInvocable() {
     return Readable<I>() &&
-      RegularInvocable<F, value_type_t<I>>() &&
-      RegularInvocable<F, reference_t<I>>() &&
-      RegularInvocable<F, iter_common_reference_t<I>>();
+      CopyConstructible<F>() &&
+      RegularInvocable<F&, value_type_t<I>&>() &&
+      RegularInvocable<F&, reference_t<I>>() &&
+      RegularInvocable<F&, iter_common_reference_t<I>>();
   }
   template <class F, class I1, class I2>
   concept bool IndirectRegularInvocable() {
     return Readable<I1>() && Readable<I2>() &&
-      RegularInvocable<F, value_type_t<I1>, value_type_t<I2>>() &&
-      RegularInvocable<F, value_type_t<I1>, reference_t<I2>>() &&
-      RegularInvocable<F, reference_t<I1>, value_type_t<I2>>() &&
-      RegularInvocable<F, reference_t<I1>, reference_t<I2>>() &&
-      RegularInvocable<F, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
+      CopyConstructible<F>() &&
+      RegularInvocable<F&, value_type_t<I1>&, value_type_t<I2>&>() &&
+      RegularInvocable<F&, value_type_t<I1>&, reference_t<I2>>() &&
+      RegularInvocable<F&, reference_t<I1>, value_type_t<I2>&>() &&
+      RegularInvocable<F&, reference_t<I1>, reference_t<I2>>() &&
+      RegularInvocable<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
   }
 
   template <class F, class I>
   concept bool IndirectPredicate() {
     return Readable<I>() &&
-      Predicate<F, value_type_t<I>>() &&
-      Predicate<F, reference_t<I>>() &&
-      Predicate<F, iter_common_reference_t<I>>();
+      CopyConstructible<F>() &&
+      Predicate<F&, value_type_t<I>&>() &&
+      Predicate<F&, reference_t<I>>() &&
+      Predicate<F&, iter_common_reference_t<I>>();
   }
   template <class F, class I1, class I2>
   concept bool IndirectPredicate() {
     return Readable<I1>() && Readable<I2>() &&
-      Predicate<F, value_type_t<I1>, value_type_t<I2>>() &&
-      Predicate<F, value_type_t<I1>, reference_t<I2>>() &&
-      Predicate<F, reference_t<I1>, value_type_t<I2>>() &&
-      Predicate<F, reference_t<I1>, reference_t<I2>>() &&
-      Predicate<F, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
+      CopyConstructible<F>() &&
+      Predicate<F&, value_type_t<I1>&, value_type_t<I2>&>() &&
+      Predicate<F&, value_type_t<I1>&, reference_t<I2>>() &&
+      Predicate<F&, reference_t<I1>, value_type_t<I2>&>() &&
+      Predicate<F&, reference_t<I1>, reference_t<I2>>() &&
+      Predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
   }
 
   template <class F, class I1, class I2 = I1>
   concept bool IndirectRelation() {
     return Readable<I1>() && Readable<I2>() &&
-      Relation<F, value_type_t<I1>, value_type_t<I2>>() &&
-      Relation<F, value_type_t<I1>, reference_t<I2>>() &&
-      Relation<F, reference_t<I1>, value_type_t<I2>>() &&
-      Relation<F, reference_t<I1>, reference_t<I2>>() &&
-      Relation<F, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
+      CopyConstructible<F>() &&
+      Relation<F&, value_type_t<I1>&, value_type_t<I2>&>() &&
+      Relation<F&, value_type_t<I1>&, reference_t<I2>>() &&
+      Relation<F&, reference_t<I1>, value_type_t<I2>&>() &&
+      Relation<F&, reference_t<I1>, reference_t<I2>>() &&
+      Relation<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
   }
 
   template <class F, class I1, class I2 = I1>
   concept bool IndirectStrictWeakOrder() {
     return Readable<I1>() && Readable<I2>() &&
-      StrictWeakOrder<F, value_type_t<I1>, value_type_t<I2>>() &&
-      StrictWeakOrder<F, value_type_t<I1>, reference_t<I2>>() &&
-      StrictWeakOrder<F, reference_t<I1>, value_type_t<I2>>() &&
-      StrictWeakOrder<F, reference_t<I1>, reference_t<I2>>() &&
-      StrictWeakOrder<F, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
+      CopyConstructible<F>() &&
+      StrictWeakOrder<F&, value_type_t<I1>&, value_type_t<I2>&>() &&
+      StrictWeakOrder<F&, value_type_t<I1>&, reference_t<I2>>() &&
+      StrictWeakOrder<F&, reference_t<I1>, value_type_t<I2>&>() &&
+      StrictWeakOrder<F&, reference_t<I1>, reference_t<I2>>() &&
+      StrictWeakOrder<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>();
   }
 
   template <class> struct indirect_result_of { };