dont pass lambdas by const reference - following style in GCC

Author: lrvideckis

library/data_structures/dsu/range_parallel_dsu.hpp

@@ -8,14 +8,14 @@
 struct rp_dsu {
   vector<UF> ufs;
   rp_dsu(int n): ufs(bit_width(unsigned(n)), UF(n)) {}
-  void join(int l1, int l2, int len, const auto& f) {
+  void join(int l1, int l2, int len, auto f) {
     if (len == 0) return;
     int lg = __lg(len);
     join_impl(lg, l1, l2, f);
     join_impl(lg, l1 + len - (1 << lg),
       l2 + len - (1 << lg), f);
   }
-  void join_impl(int lvl, int u, int v, const auto& f) {
+  void join_impl(int lvl, int u, int v, auto f) {
     if (lvl == 0) {
       u = ufs[0].find(u);
       v = ufs[0].find(v);

library/data_structures/seg_tree_uncommon/find_first.hpp

@@ -25,21 +25,20 @@
 //! such element exists then `r` is returned
 //! @time O(log(n))
 //! @space O(log(n)) for recursion stack
-int find_first(int l, int r, const auto& f) {
+int find_first(int l, int r, auto f) {
   return find_first_in_range(l, r, f, 0, n, 1);
 }
 //! invariant: f(tree[v], tl, tr) is 1
-int find_first_in_subtree(const auto& f, int tl, int tr,
-  int v) {
+int find_first_in_subtree(auto f, int tl, int tr, int v) {
   if (v >= n) return tl;
   int tm = split(tl, tr);
   push(tl, tm, tr, v);
   if (f(tree[2 * v], tl, tm))
     return find_first_in_subtree(f, tl, tm, 2 * v);
   return find_first_in_subtree(f, tm, tr, 2 * v + 1);
 }
-int find_first_in_range(int l, int r, const auto& f,
-  int tl, int tr, int v) {
+int find_first_in_range(int l, int r, auto f, int tl,
+  int tr, int v) {
   if (r <= tl || tr <= l) return r;
   if (l <= tl && tr <= r)
     return f(tree[v], tl, tr)

library/data_structures/seg_tree_uncommon/find_last.hpp

@@ -25,20 +25,19 @@
 //! such element exists then (l - 1) is returned
 //! @time O(log(n))
 //! @space O(log(n)) for recursion stack
-int find_last(int l, int r, const auto& f) {
+int find_last(int l, int r, auto f) {
   return find_last_in_range(l, r, f, 0, n, 1);
 }
 //! invariant: f(tree[v], tl, tr) is 1
-int find_last_in_subtree(const auto& f, int tl, int tr,
-  int v) {
+int find_last_in_subtree(auto f, int tl, int tr, int v) {
   if (v >= n) return tl;
   int tm = split(tl, tr);
   push(tl, tm, tr, v);
   if (f(tree[2 * v + 1], tm, tr))
     return find_last_in_subtree(f, tm, tr, 2 * v + 1);
   return find_last_in_subtree(f, tl, tm, 2 * v);
 }
-int find_last_in_range(int l, int r, const auto& f, int tl,
+int find_last_in_range(int l, int r, auto f, int tl,
   int tr, int v) {
   if (r <= tl || tr <= l) return l - 1;
   if (l <= tl && tr <= r)

library/monotonic_stack/monotonic_stack.hpp

@@ -7,7 +7,7 @@
 //!   a[le[i]] < a[i]
 //! @time O(n)
 //! @space O(n)
-vi mono_st(const auto& a, const auto& cmp) {
+vi mono_st(const auto& a, auto cmp) {
   vi l(sz(a));
   rep(i, 0, sz(a)) for (l[i] = i - 1;
     l[i] >= 0 && !cmp(a[l[i]], a[i]);) l[i] = l[l[i]];