diff --git a/src/layout.cpp b/src/layout.cpp
index 2131deb..30577c4 100644
--- a/src/layout.cpp
+++ b/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));
             }
 
diff --git a/src/noad/math_char.cpp b/src/noad/math_char.cpp
index ff9b8e2..27ea3f2 100644
--- a/src/noad/math_char.cpp
+++ b/src/noad/math_char.cpp
@@ -18,11 +18,11 @@ namespace mfl
             if (variants.empty()) 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;
diff --git a/src/noad/noad.cpp b/src/noad/noad.cpp
index 4c8db93..ca4ac3d 100644
--- a/src/noad/noad.cpp
+++ b/src/noad/noad.cpp
@@ -183,21 +183,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);
diff --git a/src/noad/radical.cpp b/src/noad/radical.cpp
index dfce428..10be146 100644
--- a/src/noad/radical.cpp
+++ b/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 = make_hbox({.nodes = {kern{.size = radical_kern_before_degree(s)}, std::move(degree_box),
diff --git a/src/node/box.cpp b/src/node/box.cpp
index 095b239..3b62530 100644
--- a/src/node/box.cpp
+++ b/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)};
     }
diff --git a/src/node/glue.cpp b/src/node/glue.cpp
index 786dbff..a83a599 100644
--- a/src/node/glue.cpp
+++ b/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}
 //
@@ -20,8 +20,8 @@ namespace mfl
             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);
@@ -35,11 +35,11 @@ namespace mfl
             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,
diff --git a/src/node/hlist.cpp b/src/node/hlist.cpp
index 1e7a69b..7a1eea7 100644
--- a/src/node/hlist.cpp
+++ b/src/node/hlist.cpp
@@ -1,7 +1,6 @@
 #include "node/hlist.hpp"
 
 #include <algorithm>
-#include <numeric>
 #include <ranges>
 
 namespace mfl
@@ -16,14 +15,15 @@ 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)
diff --git a/src/node/node.cpp b/src/node/node.cpp
index ae0177c..5329ab6 100644
--- a/src/node/node.cpp
+++ b/src/node/node.cpp
@@ -9,16 +9,16 @@ 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);
     }
 
@@ -42,8 +42,8 @@ namespace mfl
     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);
     }
 
diff --git a/src/node/vlist.cpp b/src/node/vlist.cpp
index 4387953..30b98aa 100644
--- a/src/node/vlist.cpp
+++ b/src/node/vlist.cpp
@@ -1,12 +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({});
     }
 }
\ No newline at end of file
diff --git a/src/parser/big_op.cpp b/src/parser/big_op.cpp
index 6e4ca9d..8c02770 100644
--- a/src/parser/big_op.cpp
+++ b/src/parser/big_op.cpp
@@ -50,8 +50,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,
diff --git a/src/parser/command.cpp b/src/parser/command.cpp
index 8701bb6..4cdf7c4 100644
--- a/src/parser/command.cpp
+++ b/src/parser/command.cpp
@@ -6,12 +6,10 @@
 #include "parser/fraction.hpp"
 #include "parser/function.hpp"
 #include "parser/left_right.hpp"
-#include "parser/lexer.hpp"
 #include "parser/line.hpp"
 #include "parser/math_char.hpp"
 #include "parser/math_space.hpp"
 #include "parser/parser_state.hpp"
-#include "parser/parser_utilities.hpp"
 #include "parser/radical.hpp"
 
 namespace mfl::parser
diff --git a/src/parser/font_group.cpp b/src/parser/font_group.cpp
index c905784..b35abf6 100644
--- a/src/parser/font_group.cpp
+++ b/src/parser/font_group.cpp
@@ -13,7 +13,7 @@ namespace mfl::parser
     {
         using namespace std::string_view_literals;
 
-        const auto font_commands = std::array<std::pair<std::string_view, font_choice>, 9>{{
+        constexpr auto font_commands = std::array<std::pair<std::string_view, font_choice>, 9>{{
             {"mathcal"sv, font_choice::calligraphic},
             {"mathnormal"sv, font_choice::normal},
             {"mathbf"sv, font_choice::bold},
diff --git a/src/parser/function.cpp b/src/parser/function.cpp
index 85e835f..ab76327 100644
--- a/src/parser/function.cpp
+++ b/src/parser/function.cpp
@@ -15,13 +15,13 @@ namespace mfl::parser
     {
         using namespace std::string_view_literals;
 
-        const auto function_names =
+        constexpr auto function_names =
             std::array{"arccos"sv, "csc"sv, "ker"sv,    "min"sv,  "arcsin"sv, "deg"sv, "lg"sv,     "Pr"sv,
                        "arctan"sv, "det"sv, "lim"sv,    "sec"sv,  "arg"sv,    "dim"sv, "liminf"sv, "sin"sv,
                        "cos"sv,    "exp"sv, "limsup"sv, "sinh"sv, "cosh"sv,   "gcd"sv, "ln"sv,     "sup"sv,
                        "cot"sv,    "hom"sv, "log"sv,    "tan"sv,  "coth"sv,   "inf"sv, "max"sv,    "tanh"sv};
 
-        const auto sub_function_names =
+        constexpr auto sub_function_names =
             std::array{"det"sv, "gcd"sv, "inf"sv, "lim"sv, "liminf"sv, "limsup"sv, "max"sv, "min"sv, "Pr"sv, "sup"sv};
 
         bool is_sub_function(const std::string& name) { return std::ranges::contains(sub_function_names, name); }
diff --git a/src/parser/left_right.cpp b/src/parser/left_right.cpp
index f6e855f..22be29e 100644
--- a/src/parser/left_right.cpp
+++ b/src/parser/left_right.cpp
@@ -22,7 +22,7 @@ namespace mfl::parser
             symbol
         };
 
-        const auto command_delimiter_names =
+        constexpr auto command_delimiter_names =
             std::array{"|"sv,         "lfloor"sv,      "rfloor"sv,      "lceil"sv,   "rceil"sv,
                        "langle"sv,    "rangle"sv,      "uparrow"sv,     "Uparrow"sv, "downarrow"sv,
                        "Downarrow"sv, "updownarrow"sv, "Updownarrow"sv, "vert"sv,    "Vert"sv};
@@ -49,20 +49,17 @@ namespace mfl::parser
             state.consume_token(tokens::open_brace);
         }
 
-        auto result = code_point(0);
+        auto result = code_point{0};
 
         const auto tok = state.lexer_token();
-        const auto is_empty_braces = (is_closing_brace_expected and (tok == tokens::close_brace));
 
-        if (!is_empty_braces)
+        if (const auto is_empty_braces = (is_closing_brace_expected and (tok == tokens::close_brace)); !is_empty_braces)
         {
-            const auto name = state.consume_lexer_value();
-            if (!((tok == tokens::symbol) and (name == ".")))
+            if (const auto name = state.consume_lexer_value(); !((tok == tokens::symbol) and (name == ".")))
             {
                 const auto is_valid_token = (tok == tokens::symbol) or (tok == tokens::command);
                 const auto full_name = ((tok == tokens::command) ? "\\"s : ""s) + name;
-                const auto type = get_delimiter_type(full_name);
-                if (!is_valid_token or (type == delimiter_type::none))
+                if (const auto type = get_delimiter_type(full_name); !is_valid_token or (type == delimiter_type::none))
                 {
                     state.set_error(fmt::format("'{}' is not a valid delimiter.", full_name));
                     return 0;
diff --git a/src/parser/lexer.cpp b/src/parser/lexer.cpp
index a7a89e8..1b210ab 100644
--- a/src/parser/lexer.cpp
+++ b/src/parser/lexer.cpp
@@ -2,7 +2,6 @@
 
 #include "parser/utf8.hpp"
 
-#include <array>
 #include <istream>
 #include <string_view>
 
diff --git a/src/parser/parse.cpp b/src/parser/parse.cpp
index aae7c1e..2aa0670 100644
--- a/src/parser/parse.cpp
+++ b/src/parser/parse.cpp
@@ -22,7 +22,7 @@ namespace mfl
             }
         };
 
-        struct istring_view_stream : virtual string_view_buf, std::istream
+        struct istring_view_stream final : virtual string_view_buf, std::istream
         {
             explicit istring_view_stream(const std::string_view s)
                 : string_view_buf(s), std::istream(static_cast<std::streambuf*>(this))
@@ -36,7 +36,7 @@ namespace mfl
         istring_view_stream is(input);
         parser::lexer lx(is);
         parser::parser_state state(lx);
-        const auto result = parser::parse_until_token(state, parser::tokens::eof);
-        return {result.noads, state.error()};
+        const auto [noads] = parser::parse_until_token(state, parser::tokens::eof);
+        return {noads, state.error()};
     }
 }
diff --git a/src/parser/parser_state.cpp b/src/parser/parser_state.cpp
index 37af26b..7ac4ab3 100644
--- a/src/parser/parser_state.cpp
+++ b/src/parser/parser_state.cpp
@@ -24,7 +24,7 @@ namespace mfl::parser
 
     std::string parser_state::lexer_value() const { return lexer_.value(); }
 
-    std::string parser_state::consume_lexer_value()
+    std::string parser_state::consume_lexer_value() const
     {
         auto movable_result = lexer_.value();
         lexer_.move_to_next_token();
diff --git a/src/parser/parser_state.hpp b/src/parser/parser_state.hpp
index 43338e1..d08e30c 100644
--- a/src/parser/parser_state.hpp
+++ b/src/parser/parser_state.hpp
@@ -23,7 +23,7 @@ namespace mfl::parser
         [[nodiscard]] tokens lexer_token() const;
         void consume_token(const tokens tok);
         [[nodiscard]] std::string lexer_value() const;
-        [[nodiscard]] std::string consume_lexer_value();
+        [[nodiscard]] std::string consume_lexer_value() const;
         [[nodiscard]] std::pair<tokens, std::string> lexer_state() const;
 
         void set_font_choice(const font_choice choice);
diff --git a/src/parser/parser_utilities.cpp b/src/parser/parser_utilities.cpp
index 46ab4d0..58edc87 100644
--- a/src/parser/parser_utilities.cpp
+++ b/src/parser/parser_utilities.cpp
@@ -45,8 +45,7 @@ namespace mfl::parser
                 return {};
             }
 
-            auto noads = create_script(state);
-            std::move(noads.begin(), noads.end(), std::back_inserter(result));
+            std::ranges::move(create_script(state), std::back_inserter(result));
         }
 
         state.consume_token(end_token);
@@ -58,11 +57,11 @@ namespace mfl::parser
         state.consume_token(tokens::open_brace);
         scoped_state s(state, {.font = state.get_font_choice()});
 
-        const auto noad_list = parse_until_token(state, tokens::close_brace);
+        const auto [noads] = parse_until_token(state, tokens::close_brace);
 
         state.consume_token(tokens::close_brace);
 
-        return noad_list.noads;
+        return noads;
     }
 
     std::pair<optional_noads, optional_noads> parse_sub_sup(parser_state& state)
@@ -85,14 +84,10 @@ namespace mfl::parser
     std::vector<noad> parse_item(parser_state& state)
     {
         std::vector<noad> result;
-        auto tok = state.lexer_token();
-        if (tok == tokens::symbol)
+        if (const auto tok = state.lexer_token(); tok == tokens::symbol)
             result.emplace_back(create_math_char(state));
         else if (tok == tokens::command)
-        {
-            auto noads = create_command(state);
-            std::move(noads.begin(), noads.end(), std::back_inserter(result));
-        }
+            std::ranges::move(create_command(state), std::back_inserter(result));
         else
             state.set_error("unexpected token.");
 
diff --git a/src/parser/script.cpp b/src/parser/script.cpp
index 44d4308..4690fe2 100644
--- a/src/parser/script.cpp
+++ b/src/parser/script.cpp
@@ -26,7 +26,7 @@ namespace mfl::parser
             const auto [num_triple_primes, final_num_primes] = std::div(num_primes, 3);
 
             std::vector<noad> result;
-            result.reserve(std::size_t(num_triple_primes) + ((final_num_primes > 0) ? 1U : 0U));
+            result.reserve(static_cast<std::size_t>(num_triple_primes) + ((final_num_primes > 0) ? 1U : 0U));
             for (auto i = 0; i < num_triple_primes; ++i)
             {
                 result.emplace_back(math_char{.kind = item_kind::ord, .char_code = prime_char_code + 2});
@@ -46,7 +46,7 @@ namespace mfl::parser
     {
         std::vector<noad> nucleus;
         auto noads = (state.lexer_token() == tokens::open_brace) ? parse_required_group(state) : parse_item(state);
-        std::move(noads.begin(), noads.end(), std::back_inserter(nucleus));
+        std::ranges::move(noads, std::back_inserter(nucleus));
 
         auto num_primes = parse_primes(state);
         auto [sub0, sup0] = parse_sub_sup(state);
@@ -59,16 +59,16 @@ namespace mfl::parser
         if (sup0 && sup1)
             state.set_error("Ambiguous superscripts. Use braces to group the superscripts unambiguously.");
 
-        optional_noads sub = sub0 ? sub0 : sub1;
+        const optional_noads sub = sub0 ? sub0 : sub1;
 
         optional_noads sup;
         if (num_primes > 0)
         {
             sup = get_nodes_for_primes(num_primes, state);
             if (sup0)
-                std::move(sup0->begin(), sup0->end(), std::back_inserter(*sup));
+                std::ranges::move(*sup0, std::back_inserter(*sup));
             else if (sup1)
-                std::move(sup1->begin(), sup1->end(), std::back_inserter(*sup));
+                std::ranges::move(*sup1, std::back_inserter(*sup));
         }
         else
         {
diff --git a/src/parser/tokens.cpp b/src/parser/tokens.cpp
index e1d48f3..058d289 100644
--- a/src/parser/tokens.cpp
+++ b/src/parser/tokens.cpp
@@ -2,7 +2,7 @@
 
 namespace mfl::parser
 {
-    std::string to_string(tokens t)
+    std::string to_string(const tokens t)
     {
         switch (t)
         {
diff --git a/src/parser/unicode_index.cpp b/src/parser/unicode_index.cpp
index 82926df..0422265 100644
--- a/src/parser/unicode_index.cpp
+++ b/src/parser/unicode_index.cpp
@@ -83,16 +83,16 @@ namespace mfl::parser
 
         [[nodiscard]] std::pair<script_case, std::uint32_t> alpha_info(const code_point code)
         {
-            constexpr auto upper_a = code_point(0x0041);
-            constexpr auto upper_z = code_point(0x005a);
-            constexpr auto upper_alpha = code_point(0x0391);
-            constexpr auto upper_omega = code_point(0x03a9);
-            constexpr auto lower_a = code_point(0x0061);
-            constexpr auto lower_z = code_point(0x007a);
-            constexpr auto lower_alpha = code_point(0x03b1);
-            constexpr auto lower_omega = code_point(0x03c9);
-            constexpr auto zero = code_point(0x0030);
-            constexpr auto nine = code_point(0x0039);
+            constexpr auto upper_a = code_point{0x0041};
+            constexpr auto upper_z = code_point{0x005a};
+            constexpr auto upper_alpha = code_point{0x0391};
+            constexpr auto upper_omega = code_point{0x03a9};
+            constexpr auto lower_a = code_point{0x0061};
+            constexpr auto lower_z = code_point{0x007a};
+            constexpr auto lower_alpha = code_point{0x03b1};
+            constexpr auto lower_omega = code_point{0x03c9};
+            constexpr auto zero = code_point{0x0030};
+            constexpr auto nine = code_point{0x0039};
 
             if ((code >= upper_a) && (code <= upper_z)) return {script_case::roman_upper, code - upper_a};
 
@@ -161,7 +161,7 @@ namespace mfl::parser
             return std::nullopt;
         }
 
-        const auto alpha_start_code_points = std::array<std::tuple<font_choice, script_case, code_point>, 21>{
+        constexpr auto alpha_start_code_points = std::array<std::tuple<font_choice, script_case, code_point>, 21>{
             std::tuple{font_choice::normal, script_case::roman_upper, 0x1d434},
             std::tuple{font_choice::normal, script_case::roman_lower, 0x1d44e},
             std::tuple{font_choice::normal, script_case::greek_upper, 0x0391},
@@ -204,7 +204,7 @@ namespace mfl::parser
 
     code_point unicode_index(const std::string_view name, parser_state& state)
     {
-        constexpr auto elongated_minus_sign = code_point(0x2212);
+        constexpr auto elongated_minus_sign = code_point{0x2212};
         if (name == "-") return elongated_minus_sign;
 
         if ((name.length() > 1) && (name[0] == '\\')) return tex_code_point(name.substr(1, name.length() - 1), state);
@@ -223,11 +223,9 @@ namespace mfl::parser
     {
         if (auto [script, offset] = alpha_info(code); script != script_case::none)
         {
-            const auto special_code = special_letter_code_point(code, font);
-            if (special_code) return *special_code;
+            if (const auto special_code = special_letter_code_point(code, font)) return *special_code;
 
-            const auto start = alpha_start_code_point(font, script);
-            if (start > 0) return start + offset;
+            if (const auto start = alpha_start_code_point(font, script); start > 0) return start + offset;
         }
 
         return code;
diff --git a/src/parser/utf8.cpp b/src/parser/utf8.cpp
index c042ae4..65f569b 100644
--- a/src/parser/utf8.cpp
+++ b/src/parser/utf8.cpp
@@ -52,7 +52,7 @@ namespace mfl::parser::utf8
         std::uint32_t state = 0;
         auto num_decoded = 0;
 
-        for (auto c : s)
+        for (const auto c : s)
         {
             if (decode(&state, &result, c) == accept_utf8_decoding) ++num_decoded;
         }