diff --git a/src/Gui/Dialogs/DlgThemeEditor.cpp b/src/Gui/Dialogs/DlgThemeEditor.cpp
index 03d614d588..e12180a8ed 100644
--- a/src/Gui/Dialogs/DlgThemeEditor.cpp
+++ b/src/Gui/Dialogs/DlgThemeEditor.cpp
@@ -65,8 +65,8 @@ QString typeOfTokenValue(const Gui::StyleParameters::Value& value)
             [](const std::string&) {
                 return QWidget::tr("Generic");
             },
-            [](const Gui::StyleParameters::Length&) {
-                return QWidget::tr("Length");
+            [](const Gui::StyleParameters::Numeric&) {
+                return QWidget::tr("Numeric");
             },
             [](const Base::Color&) {
                 return QWidget::tr("Color");
diff --git a/src/Gui/StyleParameters/ParameterManager.cpp b/src/Gui/StyleParameters/ParameterManager.cpp
index 5347634ca2..54efe995a0 100644
--- a/src/Gui/StyleParameters/ParameterManager.cpp
+++ b/src/Gui/StyleParameters/ParameterManager.cpp
@@ -31,30 +31,31 @@
 #include <QRegularExpression>
 #include <QString>
 #include <ranges>
+#include <utility>
 #include <variant>
 #endif
 
 namespace Gui::StyleParameters
 {
 
-Length Length::operator+(const Length& rhs) const
+Numeric Numeric::operator+(const Numeric& rhs) const
 {
     ensureEqualUnits(rhs);
     return {value + rhs.value, unit};
 }
 
-Length Length::operator-(const Length& rhs) const
+Numeric Numeric::operator-(const Numeric& rhs) const
 {
     ensureEqualUnits(rhs);
     return {value - rhs.value, unit};
 }
 
-Length Length::operator-() const
+Numeric Numeric::operator-() const
 {
     return {-value, unit};
 }
 
-Length Length::operator/(const Length& rhs) const
+Numeric Numeric::operator/(const Numeric& rhs) const
 {
     if (rhs.value == 0) {
         THROWM(Base::RuntimeError, "Division by zero");
@@ -68,7 +69,7 @@ Length Length::operator/(const Length& rhs) const
     return {value / rhs.value, unit};
 }
 
-Length Length::operator*(const Length& rhs) const
+Numeric Numeric::operator*(const Numeric& rhs) const
 {
     if (rhs.unit.empty() || unit.empty()) {
         return {value * rhs.value, unit};
@@ -78,7 +79,7 @@ Length Length::operator*(const Length& rhs) const
     return {value * rhs.value, unit};
 }
 
-void Length::ensureEqualUnits(const Length& rhs) const
+void Numeric::ensureEqualUnits(const Numeric& rhs) const
 {
     if (unit != rhs.unit) {
         THROWM(Base::RuntimeError,
@@ -90,8 +91,8 @@ void Length::ensureEqualUnits(const Length& rhs) const
 
 std::string Value::toString() const
 {
-    if (std::holds_alternative<Length>(*this)) {
-        auto [value, unit] = std::get<Length>(*this);
+    if (std::holds_alternative<Numeric>(*this)) {
+        auto [value, unit] = std::get<Numeric>(*this);
         return fmt::format("{}{}", value, unit);
     }
 
diff --git a/src/Gui/StyleParameters/ParameterManager.h b/src/Gui/StyleParameters/ParameterManager.h
index 8e53747c09..50902db46e 100644
--- a/src/Gui/StyleParameters/ParameterManager.h
+++ b/src/Gui/StyleParameters/ParameterManager.h
@@ -51,7 +51,7 @@ class Parser;
  * represents a dimensionless length that can be used as a scalar. This struct does not care about
  * unit conversions as its uses do not require it.
  */
-struct Length
+struct Numeric
 {
     /// Numeric value of the length.
     double value;
@@ -66,11 +66,11 @@ struct Length
      * and hence act as a scalar.
      *
      * @code{c++}
-     * Length a { 10, "px" };
-     * Length b { 5, "px" };
+     * Numeric a { 10, "px" };
+     * Numeric b { 5, "px" };
      *
-     * Length differentUnit { 3, "rem" }
-     * Length scalar { 2, "" };
+     * Numeric differentUnit { 3, "rem" }
+     * Numeric scalar { 2, "" };
      *
      * // basic operations with the same unit are allowed
      * auto sum = a + b; // 15 px
@@ -85,16 +85,16 @@ struct Length
      * @endcode
      * @{
      */
-    Length operator+(const Length& rhs) const;
-    Length operator-(const Length& rhs) const;
-    Length operator-() const;
+    Numeric operator+(const Numeric& rhs) const;
+    Numeric operator-(const Numeric& rhs) const;
+    Numeric operator-() const;
 
-    Length operator/(const Length& rhs) const;
-    Length operator*(const Length& rhs) const;
+    Numeric operator/(const Numeric& rhs) const;
+    Numeric operator*(const Numeric& rhs) const;
     /// @}
 
 private:
-    void ensureEqualUnits(const Length& rhs) const;
+    void ensureEqualUnits(const Numeric& rhs) const;
 };
 
 /**
diff --git a/src/Gui/StyleParameters/Parser.cpp b/src/Gui/StyleParameters/Parser.cpp
index 3cd22bc226..6e68e57a31 100644
--- a/src/Gui/StyleParameters/Parser.cpp
+++ b/src/Gui/StyleParameters/Parser.cpp
@@ -80,7 +80,7 @@ Value FunctionCall::evaluate(const EvaluationContext& context) const
         // 100 required by Qt.
         //
         // NOLINTNEXTLINE(*-magic-numbers)
-        auto amount = 100 + static_cast<int>(std::get<Length>(amountArg).value);
+        auto amount = 100 + static_cast<int>(std::get<Numeric>(amountArg).value);
 
         if (functionName == "lighten") {
             return Base::Color::fromValue(color.lighter(amount));
@@ -118,7 +118,7 @@ Value FunctionCall::evaluate(const EvaluationContext& context) const
         auto firstColor = std::get<Base::Color>(firstColorArg);
         auto secondColor = std::get<Base::Color>(secondColorArg);
 
-        auto amount = Base::fromPercent(static_cast<long>(std::get<Length>(amountArg).value));
+        auto amount = Base::fromPercent(static_cast<long>(std::get<Numeric>(amountArg).value));
 
         return Base::Color(
             (1 - amount) * firstColor.r + amount * secondColor.r,
@@ -146,12 +146,12 @@ Value BinaryOp::evaluate(const EvaluationContext& context) const
     Value lval = left->evaluate(context);
     Value rval = right->evaluate(context);
 
-    if (!std::holds_alternative<Length>(lval) || !std::holds_alternative<Length>(rval)) {
+    if (!std::holds_alternative<Numeric>(lval) || !std::holds_alternative<Numeric>(rval)) {
         THROWM(Base::ExpressionError, "Math operations are supported only on lengths");
     }
 
-    auto lhs = std::get<Length>(lval);
-    auto rhs = std::get<Length>(rval);
+    auto lhs = std::get<Numeric>(lval);
+    auto rhs = std::get<Numeric>(rval);
 
     switch (op) {
         case Operator::Add:
@@ -174,7 +174,7 @@ Value UnaryOp::evaluate(const EvaluationContext& context) const
         THROWM(Base::ExpressionError, "Unary operations on colors are not supported");
     }
 
-    auto v = std::get<Length>(val);
+    auto v = std::get<Numeric>(val);
     switch (op) {
         case Operator::Add:
             return v;
diff --git a/src/Gui/StyleParameters/Parser.h b/src/Gui/StyleParameters/Parser.h
index 34ff09ce6d..8d2ad27ecc 100644
--- a/src/Gui/StyleParameters/Parser.h
+++ b/src/Gui/StyleParameters/Parser.h
@@ -72,7 +72,7 @@ struct GuiExport ParameterReference: public Expr
 
 struct GuiExport Number: public Expr
 {
-    Length value;
+    Numeric value;
 
     Number(double value, std::string unit)
         : value({value, std::move(unit)})
diff --git a/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp b/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp
index fd5e98cc6f..e3c53326f2 100644
--- a/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp
+++ b/tests/src/Gui/StyleParameters/ParameterManagerTest.cpp
@@ -66,8 +66,8 @@ TEST_F(ParameterManagerTest, BasicParameterResolution)
 {
     {
         auto result = manager.resolve("BaseSize");
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 16.0);  // Should get value from source2 (later source)
         EXPECT_EQ(length.unit, "px");
     }
@@ -96,16 +96,16 @@ TEST_F(ParameterManagerTest, ParameterReferences)
 {
     {
         auto result = manager.resolve("Margin");
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 32.0);  // @BaseSize * 2 = 16 * 2 = 32
         EXPECT_EQ(length.unit, "px");
     }
 
     {
         auto result = manager.resolve("Padding");
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 8.0);  // @BaseSize / 2 = 16 / 2 = 8
         EXPECT_EQ(length.unit, "px");
     }
@@ -116,15 +116,15 @@ TEST_F(ParameterManagerTest, Caching)
 {
     // First resolution should cache the result
     auto result1 = manager.resolve("BaseSize");
-    EXPECT_TRUE(std::holds_alternative<Length>(result1));
+    EXPECT_TRUE(std::holds_alternative<Numeric>(result1));
 
     // Second resolution should use cached value
     auto result2 = manager.resolve("BaseSize");
-    EXPECT_TRUE(std::holds_alternative<Length>(result2));
+    EXPECT_TRUE(std::holds_alternative<Numeric>(result2));
 
     // Results should be identical
-    auto length1 = std::get<Length>(result1);
-    auto length2 = std::get<Length>(result2);
+    auto length1 = std::get<Numeric>(result1);
+    auto length2 = std::get<Numeric>(result2);
     EXPECT_DOUBLE_EQ(length1.value, length2.value);
     EXPECT_EQ(length1.unit, length2.unit);
 }
@@ -134,8 +134,8 @@ TEST_F(ParameterManagerTest, CacheInvalidation)
 {
     // Initial resolution
     auto result1 = manager.resolve("BaseSize");
-    EXPECT_TRUE(std::holds_alternative<Length>(result1));
-    auto length1 = std::get<Length>(result1);
+    EXPECT_TRUE(std::holds_alternative<Numeric>(result1));
+    auto length1 = std::get<Numeric>(result1);
     EXPECT_DOUBLE_EQ(length1.value, 16.0);
 
     // Reload should clear cache
@@ -143,8 +143,8 @@ TEST_F(ParameterManagerTest, CacheInvalidation)
 
     // Resolution after reload should work the same
     auto result2 = manager.resolve("BaseSize");
-    EXPECT_TRUE(std::holds_alternative<Length>(result2));
-    auto length2 = std::get<Length>(result2);
+    EXPECT_TRUE(std::holds_alternative<Numeric>(result2));
+    auto length2 = std::get<Numeric>(result2);
     EXPECT_DOUBLE_EQ(length2.value, 16.0);
     EXPECT_EQ(length1.unit, length2.unit);
 }
@@ -164,8 +164,8 @@ TEST_F(ParameterManagerTest, SourcePriority)
 
     // Should get value from the latest source (highest priority)
     auto result = manager.resolve("BaseSize");
-    EXPECT_TRUE(std::holds_alternative<Length>(result));
-    auto length = std::get<Length>(result);
+    EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+    auto length = std::get<Numeric>(result);
     EXPECT_DOUBLE_EQ(length.value, 24.0);
     EXPECT_EQ(length.unit, "px");
 }
@@ -279,16 +279,16 @@ TEST_F(ParameterManagerTest, ComplexExpressions)
 
     {
         auto result = manager.resolve("ComplexMargin");
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 40.0);  // (16 + 4) * 2 = 20 * 2 = 40
         EXPECT_EQ(length.unit, "px");
     }
 
     {
         auto result = manager.resolve("ComplexPadding");
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 7.0);  // (16 - 2) / 2 = 14 / 2 = 7
         EXPECT_EQ(length.unit, "px");
     }
diff --git a/tests/src/Gui/StyleParameters/ParserTest.cpp b/tests/src/Gui/StyleParameters/ParserTest.cpp
index 563c1265e7..a2b550f34c 100644
--- a/tests/src/Gui/StyleParameters/ParserTest.cpp
+++ b/tests/src/Gui/StyleParameters/ParserTest.cpp
@@ -59,8 +59,8 @@ TEST_F(ParserTest, ParseNumbers)
         Parser parser("42");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 42.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -69,8 +69,8 @@ TEST_F(ParserTest, ParseNumbers)
         Parser parser("10.5px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 10.5);
         EXPECT_EQ(length.unit, "px");
     }
@@ -79,8 +79,8 @@ TEST_F(ParserTest, ParseNumbers)
         Parser parser("2.5em");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 2.5);
         EXPECT_EQ(length.unit, "em");
     }
@@ -89,8 +89,8 @@ TEST_F(ParserTest, ParseNumbers)
         Parser parser("100%");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 100.0);
         EXPECT_EQ(length.unit, "%");
     }
@@ -163,8 +163,8 @@ TEST_F(ParserTest, ParseParameterReferences)
         Parser parser("@TestParam");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 10.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -184,8 +184,8 @@ TEST_F(ParserTest, ParseParameterReferences)
         Parser parser("@TestNumber");
         auto expr = parser.parse();
         auto result = expr->evaluate({.manager = &manager, .context = {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 5.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -198,8 +198,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10 + 5");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 15.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -208,8 +208,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10px + 5px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 15.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -218,8 +218,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10 - 5");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 5.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -228,8 +228,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10px - 5px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 5.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -238,8 +238,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10 * 5");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 50.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -248,8 +248,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10px * 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 20.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -258,8 +258,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10 / 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 5.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -268,8 +268,8 @@ TEST_F(ParserTest, ParseArithmeticOperations)
         Parser parser("10px / 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 5.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -282,8 +282,8 @@ TEST_F(ParserTest, ParseComplexExpressions)
         Parser parser("(10 + 5) * 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 30.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -292,8 +292,8 @@ TEST_F(ParserTest, ParseComplexExpressions)
         Parser parser("(10px + 5px) * 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 30.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -302,8 +302,8 @@ TEST_F(ParserTest, ParseComplexExpressions)
         Parser parser("@TestParam + 5px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 15.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -312,8 +312,8 @@ TEST_F(ParserTest, ParseComplexExpressions)
         Parser parser("@TestParam * @TestNumber");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 50.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -326,8 +326,8 @@ TEST_F(ParserTest, ParseUnaryOperations)
         Parser parser("+10");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 10.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -336,8 +336,8 @@ TEST_F(ParserTest, ParseUnaryOperations)
         Parser parser("-10");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, -10.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -346,8 +346,8 @@ TEST_F(ParserTest, ParseUnaryOperations)
         Parser parser("-10px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, -10.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -476,8 +476,8 @@ TEST_F(ParserTest, ParseWhitespace)
         Parser parser("  10  +  5  ");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 15.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -486,8 +486,8 @@ TEST_F(ParserTest, ParseWhitespace)
         Parser parser("10px+5px");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 15.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -528,8 +528,8 @@ TEST_F(ParserTest, ParseEdgeCases)
         Parser parser("42");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 42.0);
         EXPECT_EQ(length.unit, "");
     }
@@ -551,8 +551,8 @@ TEST_F(ParserTest, ParseEdgeCases)
         Parser parser("@TestParam");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 10.0);
         EXPECT_EQ(length.unit, "px");
     }
@@ -565,8 +565,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence)
         Parser parser("2 + 3 * 4");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 14.0);  // 2 + (3 * 4) = 2 + 12 = 14
         EXPECT_EQ(length.unit, "");
     }
@@ -575,8 +575,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence)
         Parser parser("10 - 3 * 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 4.0);  // 10 - (3 * 2) = 10 - 6 = 4
         EXPECT_EQ(length.unit, "");
     }
@@ -585,8 +585,8 @@ TEST_F(ParserTest, ParseOperatorPrecedence)
         Parser parser("20 / 4 + 3");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 8.0);  // (20 / 4) + 3 = 5 + 3 = 8
         EXPECT_EQ(length.unit, "");
     }
@@ -599,8 +599,8 @@ TEST_F(ParserTest, ParseNestedParentheses)
         Parser parser("((2 + 3) * 4)");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 20.0);  // (5) * 4 = 20
         EXPECT_EQ(length.unit, "");
     }
@@ -609,8 +609,8 @@ TEST_F(ParserTest, ParseNestedParentheses)
         Parser parser("(10 - (3 + 2)) * 2");
         auto expr = parser.parse();
         auto result = expr->evaluate({&manager, {}});
-        EXPECT_TRUE(std::holds_alternative<Length>(result));
-        auto length = std::get<Length>(result);
+        EXPECT_TRUE(std::holds_alternative<Numeric>(result));
+        auto length = std::get<Numeric>(result);
         EXPECT_DOUBLE_EQ(length.value, 10.0);  // (10 - 5) * 2 = 5 * 2 = 10
         EXPECT_EQ(length.unit, "");
     }