From 3a7be39be91f643b5ae1cb64e4f1b86eba7bdc38 Mon Sep 17 00:00:00 2001
From: LIU Hao <lh_mouse@126.com>
Date: Wed, 7 Feb 2024 15:59:47 +0800
Subject: [PATCH] *: Rename template parameters

---
 asteria/compiler/expression_unit.hpp   |  20 ++---
 asteria/compiler/infix_element.hpp     |  20 ++---
 asteria/compiler/statement.hpp         |  20 ++---
 asteria/compiler/token.hpp             |   8 +-
 asteria/compiler/token_stream.cpp      |   6 +-
 asteria/details/value.ipp              | 106 ++++++++++++-------------
 asteria/fwd.hpp                        |  12 +--
 asteria/runtime/air_node.cpp           |   6 +-
 asteria/runtime/air_node.hpp           |  20 ++---
 asteria/runtime/reference.hpp          |  16 ++--
 asteria/runtime/reference_modifier.hpp |  20 ++---
 asteria/runtime/runtime_error.hpp      |   6 +-
 asteria/runtime/variable.hpp           |   8 +-
 asteria/value.hpp                      |  30 +++----
 14 files changed, 149 insertions(+), 149 deletions(-)

diff --git a/asteria/compiler/expression_unit.hpp b/asteria/compiler/expression_unit.hpp
index 6d43bd38f..fe9bcf814 100644
--- a/asteria/compiler/expression_unit.hpp
+++ b/asteria/compiler/expression_unit.hpp
@@ -147,22 +147,22 @@ class Expression_Unit
 
   public:
     // Constructors and assignment operators
-    template<typename XUnitT,
-    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), XUnitT&&>::value)>
+    template<typename xUnitT,
+    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), xUnitT&&>::value)>
     constexpr
-    Expression_Unit(XUnitT&& xunit)
-      noexcept(::std::is_nothrow_constructible<decltype(m_stor), XUnitT&&>::value)
+    Expression_Unit(xUnitT&& xunit)
+      noexcept(::std::is_nothrow_constructible<decltype(m_stor), xUnitT&&>::value)
       :
-        m_stor(forward<XUnitT>(xunit))
+        m_stor(forward<xUnitT>(xunit))
       { }
 
-    template<typename XUnitT,
-    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, XUnitT&&>::value)>
+    template<typename xUnitT,
+    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, xUnitT&&>::value)>
     Expression_Unit&
-    operator=(XUnitT&& xunit) &
-      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, XUnitT&&>::value)
+    operator=(xUnitT&& xunit) &
+      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, xUnitT&&>::value)
       {
-        this->m_stor = forward<XUnitT>(xunit);
+        this->m_stor = forward<xUnitT>(xunit);
         return *this;
       }
 
diff --git a/asteria/compiler/infix_element.hpp b/asteria/compiler/infix_element.hpp
index 26386320d..20657e7fb 100644
--- a/asteria/compiler/infix_element.hpp
+++ b/asteria/compiler/infix_element.hpp
@@ -76,22 +76,22 @@ class Infix_Element
 
   public:
     // Constructors and assignment operators
-    template<typename XElemT,
-    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), XElemT&&>::value)>
+    template<typename xElementT,
+    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), xElementT&&>::value)>
     constexpr
-    Infix_Element(XElemT&& xelem)
-      noexcept(::std::is_nothrow_constructible<decltype(m_stor), XElemT&&>::value)
+    Infix_Element(xElementT&& xelem)
+      noexcept(::std::is_nothrow_constructible<decltype(m_stor), xElementT&&>::value)
       :
-        m_stor(forward<XElemT>(xelem))
+        m_stor(forward<xElementT>(xelem))
       { }
 
-    template<typename XElemT,
-    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, XElemT&&>::value)>
+    template<typename xElementT,
+    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, xElementT&&>::value)>
     Infix_Element&
-    operator=(XElemT&& xelem) &
-      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, XElemT&&>::value)
+    operator=(xElementT&& xelem) &
+      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, xElementT&&>::value)
       {
-        this->m_stor = forward<XElemT>(xelem);
+        this->m_stor = forward<xElementT>(xelem);
         return *this;
       }
 
diff --git a/asteria/compiler/statement.hpp b/asteria/compiler/statement.hpp
index ca76bb94b..1ec389830 100644
--- a/asteria/compiler/statement.hpp
+++ b/asteria/compiler/statement.hpp
@@ -200,22 +200,22 @@ class Statement
 
   public:
     // Constructors and assignment operators
-    template<typename XStmtT,
-    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), XStmtT&&>::value)>
+    template<typename xStatementT,
+    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), xStatementT&&>::value)>
     constexpr
-    Statement(XStmtT&& xstmt)
-       noexcept(::std::is_nothrow_constructible<decltype(m_stor), XStmtT&&>::value)
+    Statement(xStatementT&& xstmt)
+       noexcept(::std::is_nothrow_constructible<decltype(m_stor), xStatementT&&>::value)
       :
-        m_stor(forward<XStmtT>(xstmt))
+        m_stor(forward<xStatementT>(xstmt))
       { }
 
-    template<typename XStmtT,
-    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, XStmtT&&>::value)>
+    template<typename xStatementT,
+    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, xStatementT&&>::value)>
     Statement&
-    operator=(XStmtT&& xstmt) &
-      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, XStmtT&&>::value)
+    operator=(xStatementT&& xstmt) &
+      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, xStatementT&&>::value)
       {
-        this->m_stor = forward<XStmtT>(xstmt);
+        this->m_stor = forward<xStatementT>(xstmt);
         return *this;
       }
 
diff --git a/asteria/compiler/token.hpp b/asteria/compiler/token.hpp
index c3135dfe6..5d862a303 100644
--- a/asteria/compiler/token.hpp
+++ b/asteria/compiler/token.hpp
@@ -67,12 +67,12 @@ class Token
       );
 
   public:
-    template<typename XTokT>
+    template<typename xTokenT>
     constexpr
-    Token(const Source_Location& xsloc, size_t xlen, XTokT&& xtok)
-      noexcept(::std::is_nothrow_constructible<decltype(m_stor), XTokT&&>::value)
+    Token(const Source_Location& xsloc, size_t xlen, xTokenT&& xtok)
+      noexcept(::std::is_nothrow_constructible<decltype(m_stor), xTokenT&&>::value)
       :
-        m_sloc(xsloc), m_length(xlen), m_stor(forward<XTokT>(xtok))
+        m_sloc(xsloc), m_length(xlen), m_stor(forward<xTokenT>(xtok))
       { }
 
     Token&
diff --git a/asteria/compiler/token_stream.cpp b/asteria/compiler/token_stream.cpp
index fe6d8097b..eb1e96951 100644
--- a/asteria/compiler/token_stream.cpp
+++ b/asteria/compiler/token_stream.cpp
@@ -109,11 +109,11 @@ class Text_Reader
       }
   };
 
-template<typename XTokenT>
+template<typename xTokenT>
 bool
-do_push_token(cow_vector<Token>& tokens, Text_Reader& reader, size_t tlen, XTokenT&& xtoken)
+do_push_token(cow_vector<Token>& tokens, Text_Reader& reader, size_t tlen, xTokenT&& xtoken)
   {
-    tokens.emplace_back(reader.tell(), tlen, forward<XTokenT>(xtoken));
+    tokens.emplace_back(reader.tell(), tlen, forward<xTokenT>(xtoken));
     reader.consume(tlen);
     return true;
   }
diff --git a/asteria/details/value.ipp b/asteria/details/value.ipp
index c02ad29ea..6218d1b78 100644
--- a/asteria/details/value.ipp
+++ b/asteria/details/value.ipp
@@ -35,10 +35,10 @@ struct Valuable_impl<bool>
     using direct_init  = ::std::true_type;
     using via_type     = V_boolean;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         stor = V_boolean(xval);
       }
@@ -53,10 +53,10 @@ struct Valuable_impl<IntegerT, typename ::std::enable_if<
     using direct_init  = ::std::true_type;
     using via_type     = V_integer;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         stor = V_integer(xval);
       }
@@ -71,10 +71,10 @@ struct Valuable_impl<FloatT, typename ::std::enable_if<
     using direct_init  = ::std::true_type;
     using via_type     = V_real;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         stor = V_real(xval);
       }
@@ -89,12 +89,12 @@ struct Valuable_impl<StringT, typename ::std::enable_if<
     using direct_init  = ::std::true_type;
     using via_type     = V_string;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
-        stor = V_string(forward<XValT>(xval));
+        stor = V_string(forward<xValueT>(xval));
       }
   };
 
@@ -104,12 +104,12 @@ struct Valuable_impl<const char (*)[N]>
     using direct_init  = ::std::true_type;
     using via_type     = V_string;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
-        stor = V_string(forward<XValT>(xval));
+        stor = V_string(forward<xValueT>(xval));
       }
   };
 
@@ -119,13 +119,13 @@ struct Valuable_impl<cow_opaque>
     using direct_init  = ::std::false_type;
     using via_type     = V_opaque;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         if(xval)
-          stor = V_opaque(forward<XValT>(xval));
+          stor = V_opaque(forward<xValueT>(xval));
         else
           stor = V_null();
       }
@@ -140,13 +140,13 @@ struct Valuable_impl<refcnt_ptr<OpaqueT>, typename ::std::enable_if<
     using direct_init  = ::std::false_type;
     using via_type     = V_opaque;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         if(xval)
-          stor = V_opaque(forward<XValT>(xval));
+          stor = V_opaque(forward<xValueT>(xval));
         else
           stor = V_null();
       }
@@ -158,13 +158,13 @@ struct Valuable_impl<cow_function>
     using direct_init  = ::std::false_type;
     using via_type     = V_function;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         if(xval)
-          stor = V_function(forward<XValT>(xval));
+          stor = V_function(forward<xValueT>(xval));
         else
           stor = V_null();
       }
@@ -179,13 +179,13 @@ struct Valuable_impl<refcnt_ptr<FunctionT>, typename ::std::enable_if<
     using direct_init  = ::std::false_type;
     using via_type     = V_function;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
         if(xval)
-          stor = V_function(forward<XValT>(xval));
+          stor = V_function(forward<xValueT>(xval));
         else
           stor = V_null();
       }
@@ -197,12 +197,12 @@ struct Valuable_impl<V_array>
     using direct_init  = ::std::true_type;
     using via_type     = V_array;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
-        stor = V_array(forward<XValT>(xval));
+        stor = V_array(forward<xValueT>(xval));
       }
   };
 
@@ -212,32 +212,32 @@ struct Valuable_impl<V_object>
     using direct_init  = ::std::true_type;
     using via_type     = V_object;
 
-    template<typename StorT, typename XValT>
+    template<typename StorT, typename xValueT>
     static
     void
-    assign(StorT& stor, XValT&& xval)
+    assign(StorT& stor, xValueT&& xval)
       {
-        stor = V_object(forward<XValT>(xval));
+        stor = V_object(forward<xValueT>(xval));
       }
   };
 
-template<typename XValT, size_t N>
-struct Valuable_impl<XValT [N]>
+template<typename xValueT, size_t N>
+struct Valuable_impl<xValueT [N]>
   {
     using direct_init  = ::std::false_type;
     using via_type     = V_array;
 
-    template<typename StorT, typename XArrT>
+    template<typename StorT, typename xArrT>
     static
     void
-    assign(StorT& stor, XArrT&& xarr)
+    assign(StorT& stor, xArrT&& xarr)
       {
         V_array arr;
         arr.reserve(N);
         for(size_t k = 0;  k != N;  ++k)
           arr.emplace_back(static_cast<typename ::std::conditional<
-                  ::std::is_lvalue_reference<XArrT&&>::value,
-                           const XValT&, XValT&&>::type>(xarr[k]));
+                  ::std::is_lvalue_reference<xArrT&&>::value,
+                           const xValueT&, xValueT&&>::type>(xarr[k]));
         stor = move(arr);
       }
   };
@@ -250,56 +250,56 @@ struct Valuable_impl<TupleT, typename ::std::conditional<
     using direct_init  = ::std::false_type;
     using via_type     = V_array;
 
-    template<size_t... N, typename XTupT>
+    template<size_t... N, typename xTupT>
     static
     void
     unpack_tuple_aux(V_array& arr, ::std::index_sequence<N...>,
-                     XTupT&& xtup)
+                     xTupT&& xtup)
       {
         int dummy[] = { (static_cast<void>(arr.emplace_back(
-               ::std::get<N>(forward<XTupT>(xtup)))), 1)...  };
+               ::std::get<N>(forward<xTupT>(xtup)))), 1)...  };
         (void)dummy;
       }
 
-    template<typename StorT, typename XTupT>
+    template<typename StorT, typename xTupT>
     static
     void
-    assign(StorT& stor, XTupT&& xtup)
+    assign(StorT& stor, xTupT&& xtup)
       {
         V_array arr;
         constexpr size_t N = ::std::tuple_size<TupleT>::value;
         arr.reserve(N);
         unpack_tuple_aux(arr, ::std::make_index_sequence<N>(),
-                        forward<XTupT>(xtup));
+                        forward<xTupT>(xtup));
         stor = move(arr);
       }
   };
 
-template<typename XValT>
-struct Valuable_impl<opt<XValT>, typename ::std::conditional<
-               true, void, typename Valuable_impl<XValT>::via_type
+template<typename xValueT>
+struct Valuable_impl<opt<xValueT>, typename ::std::conditional<
+               true, void, typename Valuable_impl<xValueT>::via_type
         >::type>
   {
     using direct_init  = ::std::false_type;
-    using via_type     = typename Valuable_impl<XValT>::via_type;
+    using via_type     = typename Valuable_impl<xValueT>::via_type;
 
-    template<typename StorT, typename XOptT>
+    template<typename StorT, typename xOptT>
     static
     void
-    assign(StorT& stor, XOptT&& xopt)
+    assign(StorT& stor, xOptT&& xopt)
       {
         if(xopt)
-          Valuable_impl<XValT>::assign(stor,
+          Valuable_impl<xValueT>::assign(stor,
               static_cast<typename ::std::conditional<
-                  ::std::is_lvalue_reference<XOptT&&>::value,
-                            const XValT&, XValT&&>::type>(*xopt));
+                  ::std::is_lvalue_reference<xOptT&&>::value,
+                            const xValueT&, xValueT&&>::type>(*xopt));
         else
           stor = V_null();
       }
   };
 
-template<typename XValT>
-using Valuable = Valuable_impl<typename ::rocket::remove_cvref<XValT>::type, void>;
+template<typename xValueT>
+using Valuable = Valuable_impl<typename ::rocket::remove_cvref<xValueT>::type, void>;
 
 inline
 void
diff --git a/asteria/fwd.hpp b/asteria/fwd.hpp
index 14ef77dbb..cd2c4d6b5 100644
--- a/asteria/fwd.hpp
+++ b/asteria/fwd.hpp
@@ -263,15 +263,15 @@ struct rcfwd : virtual Rcbase
     void
     vtable_key_function_GklPAslB() noexcept;
 
-    template<typename XRealT = RealT>
-    refcnt_ptr<const XRealT>
+    template<typename xRealT = RealT>
+    refcnt_ptr<const xRealT>
     share_this() const
-      { return this->Rcbase::template share_this<XRealT, rcfwd>();  }
+      { return this->Rcbase::template share_this<xRealT, rcfwd>();  }
 
-    template<typename XRealT = RealT>
-    refcnt_ptr<XRealT>
+    template<typename xRealT = RealT>
+    refcnt_ptr<xRealT>
     share_this()
-      { return this->Rcbase::template share_this<XRealT, rcfwd>();  }
+      { return this->Rcbase::template share_this<xRealT, rcfwd>();  }
   };
 
 template<typename RealT>
diff --git a/asteria/runtime/air_node.cpp b/asteria/runtime/air_node.cpp
index 279b57d6d..8444f4a88 100644
--- a/asteria/runtime/air_node.cpp
+++ b/asteria/runtime/air_node.cpp
@@ -66,11 +66,11 @@ do_solidify_nodes(AVM_Rod& rod, const cow_vector<AIR_Node>& code)
     rod.finalize();
   }
 
-template<typename XModT>
+template<typename xModifierT>
 void
-do_push_modifier_and_check(Reference& ref, XModT&& xmod)
+do_push_modifier_and_check(Reference& ref, xModifierT&& xmod)
   {
-    ref.push_modifier(forward<XModT>(xmod));
+    ref.push_modifier(forward<xModifierT>(xmod));
     ref.dereference_readonly();
   }
 
diff --git a/asteria/runtime/air_node.hpp b/asteria/runtime/air_node.hpp
index 7ab9d5dee..59e0de7de 100644
--- a/asteria/runtime/air_node.hpp
+++ b/asteria/runtime/air_node.hpp
@@ -382,22 +382,22 @@ class AIR_Node
 
   public:
     // Constructors and assignment operators
-    template<typename XNodeT,
-    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), XNodeT&&>::value)>
+    template<typename xNodeT,
+    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), xNodeT&&>::value)>
     constexpr
-    AIR_Node(XNodeT&& xnode)
-      noexcept(::std::is_nothrow_constructible<decltype(m_stor), XNodeT&&>::value)
+    AIR_Node(xNodeT&& xnode)
+      noexcept(::std::is_nothrow_constructible<decltype(m_stor), xNodeT&&>::value)
       :
-        m_stor(forward<XNodeT>(xnode))
+        m_stor(forward<xNodeT>(xnode))
       { }
 
-    template<typename XNodeT,
-    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, XNodeT&&>::value)>
+    template<typename xNodeT,
+    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, xNodeT&&>::value)>
     AIR_Node&
-    operator=(XNodeT&& xnode) &
-      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, XNodeT&&>::value)
+    operator=(xNodeT&& xnode) &
+      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, xNodeT&&>::value)
       {
-        this->m_stor = forward<XNodeT>(xnode);
+        this->m_stor = forward<xNodeT>(xnode);
         return *this;
       }
 
diff --git a/asteria/runtime/reference.hpp b/asteria/runtime/reference.hpp
index 35ec4b257..1f94755c7 100644
--- a/asteria/runtime/reference.hpp
+++ b/asteria/runtime/reference.hpp
@@ -134,12 +134,12 @@ class Reference
     is_temporary() const noexcept
       { return this->m_xref == xref_temporary;  }
 
-    template<typename XValT,
-    ROCKET_ENABLE_IF(::std::is_assignable<Value&, XValT&&>::value)>
+    template<typename xValueT,
+    ROCKET_ENABLE_IF(::std::is_assignable<Value&, xValueT&&>::value)>
     Reference&
-    set_temporary(XValT&& xval)
+    set_temporary(xValueT&& xval)
       {
-        this->m_value = forward<XValT>(xval);
+        this->m_value = forward<xValueT>(xval);
         this->m_mods.clear();
         this->m_xref = xref_temporary;
         return *this;
@@ -183,15 +183,15 @@ class Reference
     clear_modifiers() noexcept
       { this->m_mods.clear();  }
 
-    template<typename XModT,
-    ROCKET_ENABLE_IF(::std::is_constructible<Reference_Modifier, XModT&&>::value)>
+    template<typename xModifierT,
+    ROCKET_ENABLE_IF(::std::is_constructible<Reference_Modifier, xModifierT&&>::value)>
     Reference&
-    push_modifier(XModT&& xmod)
+    push_modifier(xModifierT&& xmod)
       {
         if((this->m_xref != xref_temporary) && (this->m_xref != xref_variable))
           this->do_throw_not_dereferenceable();
 
-        this->m_mods.emplace_back(forward<XModT>(xmod));
+        this->m_mods.emplace_back(forward<xModifierT>(xmod));
         return *this;
       }
 
diff --git a/asteria/runtime/reference_modifier.hpp b/asteria/runtime/reference_modifier.hpp
index 536383947..2172074d6 100644
--- a/asteria/runtime/reference_modifier.hpp
+++ b/asteria/runtime/reference_modifier.hpp
@@ -54,22 +54,22 @@ class Reference_Modifier
 
   public:
     // Constructors and assignment operators
-    template<typename XModT,
-    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), XModT&&>::value)>
+    template<typename xModifierT,
+    ROCKET_ENABLE_IF(::std::is_constructible<decltype(m_stor), xModifierT&&>::value)>
     constexpr
-    Reference_Modifier(XModT&& xmod)
-      noexcept(::std::is_nothrow_constructible<decltype(m_stor), XModT&&>::value)
+    Reference_Modifier(xModifierT&& xmod)
+      noexcept(::std::is_nothrow_constructible<decltype(m_stor), xModifierT&&>::value)
       :
-        m_stor(forward<XModT>(xmod))
+        m_stor(forward<xModifierT>(xmod))
       { }
 
-    template<typename XModT,
-    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, XModT&&>::value)>
+    template<typename xModifierT,
+    ROCKET_ENABLE_IF(::std::is_assignable<decltype(m_stor)&, xModifierT&&>::value)>
     Reference_Modifier&
-    operator=(XModT&& xmod) &
-      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, XModT&&>::value)
+    operator=(xModifierT&& xmod) &
+      noexcept(::std::is_nothrow_assignable<decltype(m_stor)&, xModifierT&&>::value)
       {
-        this->m_stor = forward<XModT>(xmod);
+        this->m_stor = forward<xModifierT>(xmod);
         return *this;
       }
 
diff --git a/asteria/runtime/runtime_error.hpp b/asteria/runtime/runtime_error.hpp
index 77885ffcf..9f051db6a 100644
--- a/asteria/runtime/runtime_error.hpp
+++ b/asteria/runtime/runtime_error.hpp
@@ -32,10 +32,10 @@ class Runtime_Error
     ::rocket::tinyfmt_str m_fmt;  // human-readable message
 
   public:
-    template<typename XValT>
-    Runtime_Error(Uxtc_throw, XValT&& xval, const Source_Location& xsloc)
+    template<typename xValueT>
+    Runtime_Error(Uxtc_throw, xValueT&& xval, const Source_Location& xsloc)
       :
-        m_value(forward<XValT>(xval))
+        m_value(forward<xValueT>(xval))
       {
         this->do_backtrace();
         this->do_insert_frame(frame_type_throw, &xsloc, this->m_value);
diff --git a/asteria/runtime/variable.hpp b/asteria/runtime/variable.hpp
index b9f26ae4e..203eb249c 100644
--- a/asteria/runtime/variable.hpp
+++ b/asteria/runtime/variable.hpp
@@ -40,12 +40,12 @@ class Variable
     mut_value()
       { return this->m_value;  }
 
-    template<typename XValT,
-    ROCKET_ENABLE_IF(::std::is_assignable<Value&, XValT&&>::value)>
+    template<typename xValueT,
+    ROCKET_ENABLE_IF(::std::is_assignable<Value&, xValueT&&>::value)>
     void
-    initialize(XValT&& xval)
+    initialize(xValueT&& xval)
       {
-        this->m_value = forward<XValT>(xval);
+        this->m_value = forward<xValueT>(xval);
         this->m_init = true;
       }
 
diff --git a/asteria/value.hpp b/asteria/value.hpp
index 906633978..f2ead9638 100644
--- a/asteria/value.hpp
+++ b/asteria/value.hpp
@@ -32,34 +32,34 @@ class Value
         m_bytes()
       { }
 
-    template<typename XValT,
-    ROCKET_ENABLE_IF(details_value::Valuable<XValT>::direct_init::value)>
-    Value(XValT&& xval)
+    template<typename xValueT,
+    ROCKET_ENABLE_IF(details_value::Valuable<xValueT>::direct_init::value)>
+    Value(xValueT&& xval)
       noexcept(::std::is_nothrow_constructible<decltype(m_stor),
-                   typename details_value::Valuable<XValT>::via_type&&>::value)
+                   typename details_value::Valuable<xValueT>::via_type&&>::value)
       :
-        m_stor(typename details_value::Valuable<XValT>::via_type(forward<XValT>(xval)))
+        m_stor(typename details_value::Valuable<xValueT>::via_type(forward<xValueT>(xval)))
       { }
 
-    template<typename XValT,
-    ROCKET_DISABLE_IF(details_value::Valuable<XValT>::direct_init::value)>
-    Value(XValT&& xval)
+    template<typename xValueT,
+    ROCKET_DISABLE_IF(details_value::Valuable<xValueT>::direct_init::value)>
+    Value(xValueT&& xval)
       noexcept(::std::is_nothrow_assignable<decltype(m_stor)&,
-                   typename details_value::Valuable<XValT>::via_type&&>::value)
+                   typename details_value::Valuable<xValueT>::via_type&&>::value)
       :
         m_bytes()
       {
-        details_value::Valuable<XValT>::assign(this->m_stor, forward<XValT>(xval));
+        details_value::Valuable<xValueT>::assign(this->m_stor, forward<xValueT>(xval));
       }
 
-    template<typename XValT,
-    ROCKET_ENABLE_IF_HAS_TYPE(typename details_value::Valuable<XValT>::via_type)>
+    template<typename xValueT,
+    ROCKET_ENABLE_IF_HAS_TYPE(typename details_value::Valuable<xValueT>::via_type)>
     Value&
-    operator=(XValT&& xval) &
+    operator=(xValueT&& xval) &
       noexcept(::std::is_nothrow_assignable<decltype(m_stor)&,
-                   typename details_value::Valuable<XValT>::via_type&&>::value)
+                   typename details_value::Valuable<xValueT>::via_type&&>::value)
       {
-        details_value::Valuable<XValT>::assign(this->m_stor, forward<XValT>(xval));
+        details_value::Valuable<xValueT>::assign(this->m_stor, forward<xValueT>(xval));
         return *this;
       }