General code hygiene

Author: cpp-niel

src/layout.cpp

@@ -33,10 +33,10 @@ namespace mfl
         {
             if (std::holds_alternative<glue_spec>(n))
             {
-                const auto& glue = std::get<glue_spec>(n);
-                if (glue_scale == 0.0) return glue.size;
+                const auto& [size, stretch, shrink] = std::get<glue_spec>(n);
+                if (glue_scale == 0.0) return size;
 
-                const auto w = (glue_scale < 0.0) ? glue.shrink.value : glue.stretch.value;
+                const auto w = (glue_scale < 0.0) ? shrink.value : stretch.value;
                 return static_cast<dist_t>(glue_scale * static_cast<double>(w));
             }
 

src/noad/math_char.cpp

@@ -19,11 +19,11 @@ namespace mfl
                 return face.glyph_index_from_code_point(char_code, false);
 
             auto result = variants.front().glyph_index;
-            for (const auto v : variants)
+            for (const auto [glyph_index, size] : variants)
             {
-                if (v.size > requested_size) return result;
+                if (size > requested_size) return result;
 
-                result = v.glyph_index;
+                result = glyph_index;
             }
 
             return result;

src/noad/noad.cpp

@@ -186,20 +186,20 @@ namespace mfl
             if (!iterms.empty())
             {
                 const auto& term = iterms.front();
-                auto tail = iterms.subspan(1);
-                item_kind kind = item_kind::none;
+                const auto tail = iterms.subspan(1);
+                auto kind = item_kind::none;
                 if (std::holds_alternative<inoad>(term))
                 {
-                    const auto& n = std::get<inoad>(term);
-                    kind = change_kind(prev_kind, n.kind, tail);
-                    const auto space = make_space(s, math_spacing(prev_kind, n.kind));
-                    result.nodes.insert(result.nodes.end(), space.nodes.begin(), space.nodes.end());
-                    result.nodes.insert(result.nodes.end(), n.translated_noad.nodes.begin(), n.translated_noad.nodes.end());
+                    const auto& [translated_noad, inoad_kind] = std::get<inoad>(term);
+                    kind = change_kind(prev_kind, inoad_kind, tail);
+                    const auto [space_nodes] = make_space(s, math_spacing(prev_kind, inoad_kind));
+                    result.nodes.insert(result.nodes.end(), space_nodes.begin(), space_nodes.end());
+                    result.nodes.insert(result.nodes.end(), translated_noad.nodes.begin(), translated_noad.nodes.end());
                 }
                 else if (std::holds_alternative<ispace>(term))
                 {
-                    const auto space = make_space(s, std::get<ispace>(term));
-                    result.nodes.insert(result.nodes.end(), space.nodes.begin(), space.nodes.end());
+                    const auto [space_nodes] = make_space(s, std::get<ispace>(term));
+                    result.nodes.insert(result.nodes.end(), space_nodes.begin(), space_nodes.end());
                 }
 
                 intermediate_terms_to_hlist(s, has_penalties, kind, tail, result);

src/noad/radical.cpp

@@ -22,7 +22,7 @@ namespace mfl
         auto radical_symbol = make_auto_height_glyph(s, font_family::roman, radical_char_code, requested_height).first;
         const auto shift =
             height(radical_symbol) - (content_box.dims.height + vertical_gap + radical_rule_thickness(s));
-        constexpr auto percent_divisor = dist_t(100);
+        constexpr auto percent_divisor = dist_t{100};
         degree_box.shift = -degree_box.dims.depth
                            - (height(radical_symbol) * radical_degree_bottom_raise_percent(s)) / percent_divisor;
         auto radical_box =

src/node/box.cpp

@@ -17,9 +17,9 @@ namespace mfl
 
         hlist hlist_with_unit_glue(box&& box)
         {
-            const auto unit_glue_spec = glue_spec{.size = 0,
-                                                  .stretch = {.value = unit_distance, .order = infinity_order::fil},
-                                                  .shrink = {.value = unit_distance, .order = infinity_order::fil}};
+            constexpr auto unit_glue_spec = glue_spec{.size = 0,
+                                                      .stretch = {.value = unit_distance, .order = infinity_order::fil},
+                                                      .shrink = {.value = unit_distance, .order = infinity_order::fil}};
             return make_hlist(unit_glue_spec, std::move(box), unit_glue_spec);
         }
     }
@@ -60,7 +60,7 @@ namespace mfl
 
     box make_vbox(const dist_t width, node_variant&& ref_node, vlist&& up_list, vlist&& down_list)
     {
-        auto shift = dist_t(0);
+        auto shift = dist_t{0};
         if (std::holds_alternative<wrapped_box>(ref_node))
         {
             auto& b = static_cast<box&>(std::get<wrapped_box>(ref_node));
@@ -75,7 +75,7 @@ namespace mfl
         nodes.reserve(up_list.nodes.size() + 1 + down_list.nodes.size());
         std::move(up_list.nodes.rbegin(), up_list.nodes.rend(), std::back_inserter(nodes));
         nodes.emplace_back(std::move(ref_node));
-        std::move(down_list.nodes.begin(), down_list.nodes.end(), std::back_inserter(nodes));
+        std::ranges::move(down_list.nodes, std::back_inserter(nodes));
 
         return box{.kind = box_kind::vbox, .dims = dims, .shift = shift, .nodes = std::move(nodes)};
     }

src/node/glue.cpp

@@ -1,5 +1,5 @@
 // if the width_diff is positive
-//  find highest order for which the sum of all stretch glues in the node list is non-zero
+//  find the highest order for which the sum of all stretch glues in the node list is non-zero
 //   return the sum and the corresponding order
 //    result is glue_param{.scale = width_diff / sum, .order = order}
 //
@@ -13,15 +13,15 @@ namespace mfl
 {
     namespace
     {
-        dist_t sum_of_glue_by_order(const infinity_order order, glue_scale glue_spec::*scale,
+        dist_t sum_of_glue_by_order(const infinity_order order, glue_scale glue_spec::* scale,
                                     const std::vector<node_variant>& nodes)
         {
             dist_t glue_sum = 0;
             for (const auto& n : nodes)
             {
                 std::visit(overload{[&](const glue_spec& glue) {
-                                        const auto& s = glue.*scale;
-                                        if (s.order == order) glue_sum += s.value;
+                                        if (const auto& [value, scale_order] = glue.*scale; scale_order == order)
+                                            glue_sum += value;
                                     },
                                     [](const auto&) {}},
                            n);
@@ -30,20 +30,20 @@ namespace mfl
             return glue_sum;
         }
 
-        auto highest_order_total_glue(glue_scale glue_spec::*scale, const std::vector<node_variant>& nodes)
+        auto highest_order_total_glue(glue_scale glue_spec::* scale, const std::vector<node_variant>& nodes)
         {
             using enum infinity_order;
             for (const auto order : {filll, fill, fil, normal})
             {
-                const auto glue_sum = sum_of_glue_by_order(order, scale, nodes);
-                if (glue_sum != 0) return std::pair(order, glue_sum);
+                if (const auto glue_sum = sum_of_glue_by_order(order, scale, nodes); glue_sum != 0)
+                    return std::pair(order, glue_sum);
             }
 
-            return std::pair(infinity_order::normal, dist_t(0));
+            return std::pair(normal, dist_t{0});
         }
 
         glue_param calculate_glue_param(const dist_t width_diff, const std::vector<node_variant>& nodes,
-                                        glue_scale glue_spec::*scale_direction, const double sign)
+                                        glue_scale glue_spec::* scale_direction, const double sign)
         {
             const auto [order, sum] = highest_order_total_glue(scale_direction, nodes);
             if (sum == 0) return {};

src/node/hlist.cpp

@@ -1,7 +1,6 @@
 #include "node/hlist.hpp"
 
 #include <algorithm>
-#include <numeric>
 #include <ranges>
 
 namespace mfl
@@ -16,22 +15,28 @@ namespace mfl
     hlist concat(hlist&& l0, hlist&& l1)
     {
         auto result = std::move(l0);
-        std::move(l1.nodes.begin(), l1.nodes.end(), std::back_inserter(result.nodes));
+        std::ranges::move(l1.nodes, std::back_inserter(result.nodes));
         return result;
     }
 
     dist_t hlist_width(const hlist& l)
     {
-        return std::accumulate(l.nodes.begin(), l.nodes.end(), dist_t(0), [&](const dist_t acc, const node_variant& n) { return acc + width(n); });
+        return std::ranges::fold_left_first(
+                   l.nodes | std::views::transform([](const node_variant& n) { return width(n); }), std::plus{})
+            .value_or({});
     }
 
     dist_t hlist_depth(const hlist& l)
     {
-        return l.nodes.empty() ? 0 : std::ranges::max(l.nodes | std::views::transform([](const node_variant& n) { return depth(n); }));
+        return l.nodes.empty()
+                   ? 0
+                   : std::ranges::max(l.nodes | std::views::transform([](const node_variant& n) { return depth(n); }));
     }
 
     dist_t hlist_height(const hlist& l)
     {
-        return l.nodes.empty() ? 0 : std::ranges::max(l.nodes | std::views::transform([](const node_variant& n) { return height(n); }));
+        return l.nodes.empty()
+                   ? 0
+                   : std::ranges::max(l.nodes | std::views::transform([](const node_variant& n) { return height(n); }));
     }
 }

src/node/node.cpp

@@ -9,60 +9,49 @@ namespace mfl
     dist_t depth(const node_variant& n)
     {
         return std::visit(overload{[](const box& b) { return b.dims.depth + b.shift; },
-                                   [](const glue_spec&) { return dist_t(0); },
-                                   [](const glyph& g) { return g.depth; },
-                                   [](const kern&) { return dist_t(0); },
-                                   [](const rule& r) { return r.depth; }},
+                                   [](const glue_spec&) { return dist_t{0}; }, [](const glyph& g) { return g.depth; },
+                                   [](const kern&) { return dist_t{0}; }, [](const rule& r) { return r.depth; }},
                           n);
     }
 
     dist_t height(const node_variant& n)
     {
         return std::visit(overload{[](const box& b) { return b.dims.height - b.shift; },
-                                   [](const glue_spec&) { return dist_t(0); },
-                                   [](const glyph& g) { return g.height; },
-                                   [](const kern&) { return dist_t(0); },
-                                   [](const rule& r) { return r.height; }},
+                                   [](const glue_spec&) { return dist_t{0}; }, [](const glyph& g) { return g.height; },
+                                   [](const kern&) { return dist_t{0}; }, [](const rule& r) { return r.height; }},
                           n);
     }
 
     dist_t vsize(const node_variant& n)
     {
         return std::visit(overload{[](const box& b) { return b.dims.height + b.dims.depth; },
                                    [](const glyph& g) { return g.height + g.depth; },
-                                   [](const glue_spec& g) { return g.size; },
-                                   [](const kern& k) { return k.size; },
+                                   [](const glue_spec& g) { return g.size; }, [](const kern& k) { return k.size; },
                                    [](const rule& r) { return r.height + r.depth; }},
                           n);
     }
 
     dist_t width(const node_variant& n)
     {
-        return std::visit(overload{[](const box& b) { return b.dims.width; },
-                                   [](const glue_spec& g) { return g.size; },
-                                   [](const glyph& g) { return g.width; },
-                                   [](const kern& k) { return k.size; },
+        return std::visit(overload{[](const box& b) { return b.dims.width; }, [](const glue_spec& g) { return g.size; },
+                                   [](const glyph& g) { return g.width; }, [](const kern& k) { return k.size; },
                                    [](const rule& r) { return r.width; }},
                           n);
     }
 
     dist_t vwidth(const node_variant& n)
     {
         return std::visit(overload{[](const box& b) { return b.shift + b.dims.width; },
-                                   [](const glue_spec&) { return dist_t(0); },
-                                   [](const glyph& g) { return g.width; },
-                                   [](const kern&) { return dist_t(0); },
-                                   [](const rule& r) { return r.width; }},
+                                   [](const glue_spec&) { return dist_t{0}; }, [](const glyph& g) { return g.width; },
+                                   [](const kern&) { return dist_t{0}; }, [](const rule& r) { return r.width; }},
                           n);
     }
 
     dist_t vheight(const node_variant& n)
     {
         return std::visit(overload{[](const box& b) { return b.dims.height; },
-                                   [](const glue_spec& g) { return g.size; },
-                                   [](const glyph& g) { return g.height; },
-                                   [](const kern& k) { return k.size; },
-                                   [](const rule& r) { return r.height; }},
+                                   [](const glue_spec& g) { return g.size; }, [](const glyph& g) { return g.height; },
+                                   [](const kern& k) { return k.size; }, [](const rule& r) { return r.height; }},
                           n);
     }
 }

src/node/vlist.cpp

@@ -1,11 +1,14 @@
 #include "node/vlist.hpp"
 
-#include <numeric>
+#include <algorithm>
+#include <ranges>
 
 namespace mfl
 {
     dist_t vlist_size(const vlist& l)
     {
-        return std::accumulate(l.nodes.begin(), l.nodes.end(), dist_t(0), [&](const dist_t acc, const node_variant& n) { return acc + vsize(n); });
+        return std::ranges::fold_left_first(
+                   l.nodes | std::views::transform([](const node_variant& n) { return vsize(n); }), std::plus{})
+            .value_or({});
     }
 }

src/parser/big_op.cpp

@@ -49,8 +49,8 @@ namespace mfl::parser
 
         if (sup0 && sup1) state.set_error("multiple superscripts");
 
-        optional_noads sub = sub0 ? sub0 : sub1;
-        optional_noads sup = sup0 ? sup0 : sup1;
+        const optional_noads sub = sub0 ? sub0 : sub1;
+        const optional_noads sup = sup0 ? sup0 : sup1;
         return {.limits = limits,
                 .nucleus = {math_char{.kind = item_kind::op, .char_code = unicode_index("\\" + op_name, state)}},
                 .sub = sub,