pass lambdas not by const reference

Author: lrvideckis

library/data_structures_[l,r)/bit_uncommon/walk_lambda.hpp

@@ -1,4 +1,4 @@
-void walk(const auto& f) {
+void walk(auto f) {
   ll sum = 0;
   for (int i = bit_floor(size(s)), r = 0; i; i /= 2)
     if (r + i <= sz(s) && f(r + i, sum + s[r + i - 1]))

library/data_structures_[l,r)/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_[l,r)/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/data_structures_[l,r)/seg_tree_uncommon/min_left.hpp

@@ -1,4 +1,4 @@
-void min_left(int l, int r, const auto& f) {
+void min_left(int l, int r, auto f) {
   for (T x = unit; l < r;) {
     int u = r + n, v = __lg(min(u & -u, r - l)),
         m = r - (1 << v);

library/data_structures_[l,r]/bit_uncommon/walk_lambda.hpp

@@ -1,4 +1,4 @@
-void walk(const auto& f) {
+void walk(auto f) {
   ll sum = 0;
   for (int i = bit_floor(size(s)), r = 0; i; i /= 2)
     if (r + i <= sz(s) && f(r + i - 1, sum + s[r + i - 1]))

library/data_structures_[l,r]/seg_tree_uncommon/max_right.hpp

@@ -1,4 +1,4 @@
-void max_right(int l, int r, const auto& f) {
+void max_right(int l, int r, auto f) {
   if (T x = s[l + n]; f(l, x))
     for (l++; l <= r;) {
       int u = l + n, v = __lg(min(u & -u, r - l + 1)),

library/data_structures_[l,r]/seg_tree_uncommon/min_left.hpp

@@ -1,4 +1,4 @@
-int min_left(int l, int r, const auto& f) {
+int min_left(int l, int r, auto f) {
   if (T x = s[r + n]; f(r, x))
     for (r--; l <= r;) {
       int u = r + 1 + n, v = __lg(min(u & -u, r - l + 1)),

library/dsu/range_parallel_dsu.hpp

@@ -8,12 +8,12 @@
 struct rp_dsu {
   vector<DSU> dsus;
   rp_dsu(int n): dsus(bit_width(n + 0u), DSU(n)) {}
-  void join(int u, int v, int len, const auto& f) {
+  void join(int u, int v, int len, auto f) {
     int i = __lg(len);
     join(u, v, f, i);
     join(u + len - (1 << i), v + len - (1 << i), f, i);
   }
-  void join(int u, int v, const auto& f, int i) {
+  void join(int u, int v, auto f, int i) {
     if (!dsus[i].join(u, v)) return;
     if (i == 0) return f(u, v);
     i--;

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]];

library/trees/centroid_decomp.hpp

@@ -5,7 +5,7 @@
 //! @endcode
 //! @time O(n log n)
 //! @space O(n)
-void centroid(auto& adj, const auto& f) {
+void centroid(auto& adj, auto f) {
   vi siz(sz(adj));
   auto calc_sz = [&](auto&& self, int u, int p) -> void {
     siz[u] = 1;