convert single-call recursive lambdas to unnamed IIFEs

library/convolution/min_plus_convolution_convex_and_arbitrary.hpp

@@ -9,8 +9,8 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
   int n = sz(convex);
   int m = sz(arbitrary);
   vi res(n + m - 1, INT_MAX);
-  auto dnc = [&](this auto&& dnc, int res_le, int res_ri,
-               int arb_le, int arb_ri) {
+  [&](this auto&& self, int res_le, int res_ri, int arb_le,
+    int arb_ri) {
     if (res_le >= res_ri) return;
     int mid_res = (res_le + res_ri) / 2;
     int op_arb = arb_le;
@@ -22,10 +22,9 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
         op_arb = i;
       }
     }
-    dnc(res_le, mid_res, arb_le, min(arb_ri, op_arb + 1));
+    self(res_le, mid_res, arb_le, min(arb_ri, op_arb + 1));
     // NOLINTNEXTLINE(readability-suspicious-call-argument)
-    dnc(mid_res + 1, res_ri, op_arb, arb_ri);
-  };
-  dnc(0, n + m - 1, 0, m);
+    self(mid_res + 1, res_ri, op_arb, arb_ri);
+  }(0, n + m - 1, 0, m);
   return res;
 }

library/graphs/euler_path.hpp

@@ -17,15 +17,14 @@
 vector<pii> euler_path(auto& g, int m, int s) {
   vi vis(m);
   vector<pii> path;
-  auto dfs = [&](this auto&& dfs, int u, int eu) -> void {
+  [&](this auto&& self, int u, int eu) -> void {
     while (!empty(g[u])) {
       auto [v, ev] = g[u].back();
       g[u].pop_back();
-      if (!vis[ev]) vis[ev] = 1, dfs(v, ev);
+      if (!vis[ev]) vis[ev] = 1, self(v, ev);
     }
     path.emplace_back(u, eu);
-  };
-  dfs(s, -1);
+  }(s, -1);
   ranges::reverse(path);
   return path;
 }

library/graphs/strongly_connected_components/offline_incremental_scc.hpp

@@ -16,8 +16,9 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
   vi ids(n, -1), joins(m, m), idx(m), vs(n), scc_id;
   ranges::iota(idx, 0);
   vector<vi> g;
-  auto dnc = [&](this auto&& dnc, auto el, auto er, int tl,
-               int tr) {
+  // uses -1 as the lower bound to correctly handle
+  // self-edges
+  [&](this auto&& self, auto el, auto er, int tl, int tr) {
     g.clear();
     int mid = midpoint(tl, tr);
     for (auto it = el; it != er; it++) {
@@ -42,11 +43,8 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
       auto& [u, v] = eds[*it];
       u = scc_id[u], v = scc_id[v];
     }
-    dnc(el, split, tl, mid);
-    dnc(split, er, mid, tr);
-  };
-  // uses -1 as the lower bound to correctly handle
-  // self-edges
-  dnc(all(idx), -1, m);
+    self(el, split, tl, mid);
+    self(split, er, mid, tr);
+  }(all(idx), -1, m);
   return joins;
 }

library/trees/centroid_decomp.hpp

@@ -19,10 +19,10 @@ vi cd(auto& g, auto f) {
       }
     return 2 * s[u] >= n ? s[p] = n - s[u], u : -1;
   };
-  auto dfs = [&](this auto&& dfs, int u) -> int {
+  [&](this auto&& self, int u) -> int {
     f(u = ctd(u, u, s[u]));
-    for (int v : g[u]) erase(g[v], u), p[dfs(v)] = u;
+    for (int v : g[u]) erase(g[v], u), p[self(v)] = u;
     return u;
-  };
-  return dfs(0), p;
+  }(0);
+  return p;
 }

library/trees/edge_cd.hpp

@@ -26,7 +26,7 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
       }
     return 2 * s[u] > m ? s[p] = m + 1 - s[u], u : -1;
   };
-  auto dfs = [&](this auto&& dfs, int u, int m) {
+  [&](this auto&& self, int u, int m) {
     if (m < 2) return;
     u = ctd(u, u, m);
     int sum = 0;
@@ -37,9 +37,8 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
     f(u, it - begin(g[u]));
     G oth(it, end(g[u]));
     g[u].erase(it, end(g[u]));
-    dfs(u, sum);
+    self(u, sum);
     swap(g[u], oth);
-    dfs(u, m - sum);
-  };
-  dfs(0, sz(g) - 1);
+    self(u, m - sum);
+  }(0, sz(g) - 1);
 };

library/trees/shallowest_decomp_tree.hpp

@@ -9,18 +9,17 @@
 //! @space O(n)
 void shallowest(auto& g, auto f) {
   vector<vi> order(bit_width(size(g)));
-  auto dfs = [&](this auto&& dfs, int u, int p) -> int {
+  [&](this auto&& self, int u, int p) -> int {
     int once = 0, twice = 0;
     for (int v : g[u])
       if (v != p) {
-        int dp = dfs(v, u);
+        int dp = self(v, u);
         twice |= once & dp, once |= dp;
       }
     auto dp = (once | (bit_ceil(twice + 1u) - 1)) + 1;
     order[countr_zero(dp)].push_back(u);
     return dp;
-  };
-  dfs(0, 0);
+  }(0, 0);
   for (const vi& vec : order | views::reverse)
     for (int u : vec) {
       f(u);

library/trees/uncommon/subtree_isomorphism.hpp

@@ -12,15 +12,14 @@
 auto subtree_iso(const auto& g) {
   vi iso_id(sz(g), -1);
   map<vi, int> hashes;
-  auto dfs = [&](this auto&& dfs, int u, int p) -> int {
+  [&](this auto&& self, int u, int p) -> int {
     vi ch_ids;
     for (int v : g[u])
-      if (v != p) ch_ids.push_back(dfs(v, u));
+      if (v != p) ch_ids.push_back(self(v, u));
     ranges::sort(ch_ids);
     return iso_id[u] =
              hashes.try_emplace(ch_ids, sz(hashes))
                .first->second;
-  };
-  dfs(0, 0);
+  }(0, 0);
   return pair{sz(hashes), iso_id};
 }

tests/.config/.cppcheck_suppression_list

@@ -60,6 +60,7 @@ unusedFunction:../kactl/content/data-structures/UnionFind.h:14
 unusedFunction:../kactl/content/number-theory/ModPow.h:13
 unusedFunction:../kactl/stress-tests/utilities/genTree.h:49
 containerOutOfBounds:../library/data_structures_[l,r)/uncommon/permutation_tree.hpp:85
+containerOutOfBounds:../library/trees/edge_cd.hpp
 ctuOneDefinitionRuleViolation:../library/data_structures_[l,r)/bit.hpp:12
 ctuOneDefinitionRuleViolation:../library/data_structures_[l,r)/lazy_seg_tree.hpp:4
 mismatchingContainerExpression:../library/trees/extra_members/virtual_tree.hpp:19