diff --git a/README.md b/README.md
index da6d7f63..04d6f28d 100644
--- a/README.md
+++ b/README.md
@@ -98,12 +98,12 @@ From `rtl::Record`, registered member functions can be queried as `rtl::Method`.
 Callables are materialized by explicitly providing the argument types we intend to pass. If the signature is valid, the resulting callable can be invoked safely.
 For example, the overloaded constructor `Person(std::string, int)` –
 ```c++
-rtl::constructor<std::string, int> personCtor = classPerson->ctor<std::string, int>();
+rtl::constructor<std::string, int> personCtor = classPerson->ctorT<std::string, int>();
 if (!personCtor) { /* Constructor with expected signature not found. */ }
 ```
 Or the default constructor –
 ```c++
-rtl::constructor<> personCtor = classPerson->ctor();
+rtl::constructor<> personCtor = classPerson->ctorT<>();
 ```
 Instances can be created on the `Heap` or `Stack` with automatic lifetime management –
 ```c++
@@ -134,7 +134,7 @@ The above `getName` invocation is effectively a native function-pointer hop, sin
 If the concrete type `Person` is not accessible at the call site, its member functions can still be invoked by erasing the target type and using `rtl::RObject` instead. The previously constructed instance (`robj`) is passed as the target –
 ```c++
 rtl::method<rtl::RObject, std::string()> getName = oGetName->targetT()
-                                                            .argsT().returnT<std::string>();
+                                                           .argsT().returnT<std::string>();
 auto [err, ret] = getName(robj)();	// Invoke and receive return as std::optional<std::string>.
 if (err == rtl::error::None && ret.has_value()) {
     std::cout << ret.value();
@@ -143,7 +143,7 @@ if (err == rtl::error::None && ret.has_value()) {
 If the return type is also not known at compile time,`rtl::Return` can be used –
 ```c++
 rtl::method<rtl::RObject, rtl::Return()> getName = oGetName->targetT()
-                                                            .argsT().returnT();
+                                                           .argsT().returnT();
 auto [err, ret] = getName(robj)();	// Invoke and receive rtl::RObject as return, wrapping std::string underneath.
 if (err == rtl::error::None && ret.canViewAs<std::string>()) {
     const std::string& name = ret.view<std::string>()->get();
diff --git a/RTLBenchmarkApp/src/ReflectedCallUnknownReturn.cpp b/RTLBenchmarkApp/src/ReflectedCallUnknownReturn.cpp
index 35172a54..b6204f79 100644
--- a/RTLBenchmarkApp/src/ReflectedCallUnknownReturn.cpp
+++ b/RTLBenchmarkApp/src/ReflectedCallUnknownReturn.cpp
@@ -30,7 +30,7 @@ namespace
 
     static rtl::RObject nodeObj = []()
     {
-        auto [err, robj] = class_Node.ctor()(rtl::alloc::Stack);
+        auto [err, robj] = class_Node.ctorT()(rtl::alloc::Stack);
         if (robj.isEmpty()) {
             std::cerr << "[x] error: " << rtl::to_string(err) << "\n";
         }
diff --git a/RTLTestRunApp/src/CxxMirrorTests/CxxMirrorObjectTest.cpp b/RTLTestRunApp/src/CxxMirrorTests/CxxMirrorObjectTest.cpp
index 9646d4af..6e7b5dbc 100644
--- a/RTLTestRunApp/src/CxxMirrorTests/CxxMirrorObjectTest.cpp
+++ b/RTLTestRunApp/src/CxxMirrorTests/CxxMirrorObjectTest.cpp
@@ -63,7 +63,7 @@ namespace rtl_tests
 
         // Create an instance of std::vector<int> on the stack via RTL.
         // Uses RObject with stack lifetime.
-        auto [err, robj] = classVectorInt->ctor()(rtl::alloc::Stack);
+        auto [err, robj] = classVectorInt->ctorT()(rtl::alloc::Stack);
         EXPECT_TRUE(err == rtl::error::None);
         ASSERT_FALSE(robj.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/ClassMethodsTests.cpp b/RTLTestRunApp/src/FunctionalityTests/ClassMethodsTests.cpp
index 19ab9d6d..6b087bba 100644
--- a/RTLTestRunApp/src/FunctionalityTests/ClassMethodsTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/ClassMethodsTests.cpp
@@ -44,7 +44,7 @@ namespace rtl_tests
 
 				const rtl::Record& reflectedClass = itr->second;
 
-				auto [err, robj] = reflectedClass.ctor()(rtl::alloc::Stack);
+				auto [err, robj] = reflectedClass.ctorT<>()(rtl::alloc::Stack);
 
 				if (recordName == event::struct_) {
 					//Event's default constructor is private or deleted.
@@ -82,7 +82,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -111,7 +111,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -140,7 +140,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -172,7 +172,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -204,7 +204,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -233,7 +233,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -262,7 +262,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -291,7 +291,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -320,7 +320,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -351,7 +351,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -382,7 +382,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -413,7 +413,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -444,7 +444,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -477,7 +477,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -510,7 +510,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Stack);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Stack);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -547,7 +547,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err0, book] = classBook->ctor()(alloc::Heap);
+			auto [err0, book] = classBook->ctorT<>()(alloc::Heap);
 
 			EXPECT_TRUE(err0 == error::None);
 			ASSERT_FALSE(book.isEmpty());
diff --git a/RTLTestRunApp/src/FunctionalityTests/ConstMethodOverloadTests.cpp b/RTLTestRunApp/src/FunctionalityTests/ConstMethodOverloadTests.cpp
index 713d1e68..2bb1e8b5 100644
--- a/RTLTestRunApp/src/FunctionalityTests/ConstMethodOverloadTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/ConstMethodOverloadTests.cpp
@@ -20,7 +20,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, book] = classBook->ctor()(alloc::Stack);
+            auto [err0, book] = classBook->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book.isEmpty());
 
@@ -90,7 +90,7 @@ namespace rtl_tests
             optional<Method> oUpdateLastName = classPerson->getMethod(person::str_updateLastName);
             ASSERT_TRUE(oUpdateLastName);
 
-            auto [err0, person] = classPerson->ctor<std::string>()(alloc, person::FIRST_NAME);
+            auto [err0, person] = classPerson->ctorT<std::string>()(alloc, person::FIRST_NAME);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(person.isEmpty());
@@ -130,7 +130,7 @@ namespace rtl_tests
             optional<Record> classPerson = cxx::mirror().getRecord(person::class_);
             ASSERT_TRUE(classPerson);
 
-            auto [err0, person] = classPerson->ctor<std::string>()(alloc, person::FIRST_NAME);
+            auto [err0, person] = classPerson->ctorT<std::string>()(alloc, person::FIRST_NAME);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(person.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/ConstructorTests.cpp b/RTLTestRunApp/src/FunctionalityTests/ConstructorTests.cpp
index fb98c81b..d7a1e24f 100644
--- a/RTLTestRunApp/src/FunctionalityTests/ConstructorTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/ConstructorTests.cpp
@@ -30,8 +30,8 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			rtl::constructor<std::string, int> ctor = classDate->ctor<std::string, int>();
-			auto [err, date] = ctor(alloc::Heap, "wrong", 10);
+			rtl::constructor<std::string, int> ctorT = classDate->ctorT<std::string, int>();
+			auto [err, date] = ctorT(alloc::Heap, "wrong", 10);
 
 			EXPECT_TRUE(err == error::SignatureMismatch);
 			ASSERT_TRUE(date.isEmpty());
@@ -47,8 +47,8 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			rtl::constructor<std::string, int> ctor = classDate->ctor<std::string, int>();
-			auto [err, date] = ctor(alloc::Stack, "wrong", 10);
+			rtl::constructor<std::string, int> ctorT = classDate->ctorT<std::string, int>();
+			auto [err, date] = ctorT(alloc::Stack, "wrong", 10);
 
 			EXPECT_TRUE(err == error::SignatureMismatch);
 			ASSERT_TRUE(date.isEmpty());
@@ -64,7 +64,7 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			auto [err, date] = classDate->ctor()(alloc::Heap);
+			auto [err, date] = classDate->ctorT()(alloc::Heap);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -81,7 +81,7 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			auto [err, date] = classDate->ctor()(alloc::Stack);
+			auto [err, date] = classDate->ctorT()(alloc::Stack);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -98,8 +98,8 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			rtl::constructor<std::string> ctor = classDate->ctor<std::string>();
-			auto [err, date] = ctor(alloc::Heap, date::DATE_STR0);
+			rtl::constructor<std::string> ctorT = classDate->ctorT<std::string>();
+			auto [err, date] = ctorT(alloc::Heap, date::DATE_STR0);
 			
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -116,8 +116,8 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			rtl::constructor<std::string> ctor = classDate->ctor<std::string>();
-			auto [err, date] = ctor(alloc::Stack, date::DATE_STR0);
+			rtl::constructor<std::string> ctorT = classDate->ctorT<std::string>();
+			auto [err, date] = ctorT(alloc::Stack, date::DATE_STR0);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -134,8 +134,8 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			auto ctor = classDate->ctor<unsigned, unsigned, unsigned>();
-			auto [err, date] = ctor(alloc::Heap, date::DAY, date::MONTH, date::YEAR);
+			auto ctorT = classDate->ctorT<unsigned, unsigned, unsigned>();
+			auto [err, date] = ctorT(alloc::Heap, date::DAY, date::MONTH, date::YEAR);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -158,8 +158,8 @@ namespace rtl_tests
 			unsigned month = date::MONTH;
 			unsigned year = date::YEAR;
 
-			auto ctor = classDate->ctor<unsigned, unsigned, unsigned>();
-			auto [err, date] = ctor(alloc::Stack, day, month, year);
+			auto ctorT = classDate->ctorT<unsigned, unsigned, unsigned>();
+			auto [err, date] = ctorT(alloc::Stack, day, month, year);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -178,7 +178,7 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			auto [err, date] = classDate->ctor()(alloc::Heap);
+			auto [err, date] = classDate->ctorT()(alloc::Heap);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -195,7 +195,7 @@ namespace rtl_tests
 			optional<Record> classDate = cxx::mirror().getRecord(date::ns, date::struct_);
 			ASSERT_TRUE(classDate);
 
-			auto [err, date] = classDate->ctor()(alloc::Stack);
+			auto [err, date] = classDate->ctorT()(alloc::Stack);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(date.isEmpty());
@@ -212,7 +212,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor<float, int>()(alloc::Heap, 19.0, 87.5);
+			auto [err, book] = classBook->ctorT<float, int>()(alloc::Heap, 19.0, 87.5);
 
 			EXPECT_TRUE(err == error::SignatureMismatch);
 			ASSERT_TRUE(book.isEmpty());
@@ -228,7 +228,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor<float, int>()(alloc::Stack, 19.0, 87.5);
+			auto [err, book] = classBook->ctorT<float, int>()(alloc::Stack, 19.0, 87.5);
 
 			EXPECT_TRUE(err == error::SignatureMismatch);
 			ASSERT_TRUE(book.isEmpty());
@@ -244,7 +244,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor()(alloc::Heap);
+			auto [err, book] = classBook->ctorT()(alloc::Heap);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -261,7 +261,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor()(alloc::Stack);
+			auto [err, book] = classBook->ctorT()(alloc::Stack);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -278,8 +278,8 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
-			auto [err, book] = ctor(alloc::Heap, book::PRICE, book::TITLE);
+			rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
+			auto [err, book] = ctorT(alloc::Heap, book::PRICE, book::TITLE);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -298,8 +298,8 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
-			auto [err, book] = ctor(alloc::Stack, book::PRICE, book::TITLE);
+			rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
+			auto [err, book] = ctorT(alloc::Stack, book::PRICE, book::TITLE);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -318,7 +318,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor()(alloc::Heap);
+			auto [err, book] = classBook->ctorT()(alloc::Heap);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
@@ -335,7 +335,7 @@ namespace rtl_tests
 			optional<Record> classBook = cxx::mirror().getRecord(book::class_);
 			ASSERT_TRUE(classBook);
 
-			auto [err, book] = classBook->ctor()(alloc::Stack);
+			auto [err, book] = classBook->ctorT()(alloc::Stack);
 
 			EXPECT_TRUE(err == error::None);
 			ASSERT_FALSE(book.isEmpty());
diff --git a/RTLTestRunApp/src/FunctionalityTests/CopyConstructorTests.cpp b/RTLTestRunApp/src/FunctionalityTests/CopyConstructorTests.cpp
index 550f16e3..8367af42 100644
--- a/RTLTestRunApp/src/FunctionalityTests/CopyConstructorTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/CopyConstructorTests.cpp
@@ -20,7 +20,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, book0] = classBook->ctor()(alloc::Heap);
+            auto [err0, book0] = classBook->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book0.isEmpty());
 
@@ -45,7 +45,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, book0] = classBook->ctor()(alloc::Stack);
+            auto [err0, book0] = classBook->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book0.isEmpty());
 
@@ -68,7 +68,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, book0] = classBook->ctor()(alloc::Stack);
+            auto [err0, book0] = classBook->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book0.isEmpty());
 
@@ -91,7 +91,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, book0] = classBook->ctor()(alloc::Heap);
+            auto [err0, book0] = classBook->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book0.isEmpty());
 
@@ -114,9 +114,9 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
+            rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
 
-            auto [err0, book] = ctor(alloc::Heap, book::PRICE, book::TITLE);
+            auto [err0, book] = ctorT(alloc::Heap, book::PRICE, book::TITLE);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book.isEmpty());
             {
@@ -159,9 +159,9 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
+            rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
             
-            auto [err0, book] = ctor(alloc::Stack, book::PRICE, book::TITLE);
+            auto [err0, book] = ctorT(alloc::Stack, book::PRICE, book::TITLE);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book.isEmpty());
             {
@@ -204,9 +204,9 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
             
-            rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
+            rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
 
-            auto [err0, book] = ctor(alloc::Stack, book::PRICE, book::TITLE);
+            auto [err0, book] = ctorT(alloc::Stack, book::PRICE, book::TITLE);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book.isEmpty());
             {
@@ -249,9 +249,9 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
             
-            rtl::constructor<double, std::string> ctor = classBook->ctor<double, std::string>();
+            rtl::constructor<double, std::string> ctorT = classBook->ctorT<double, std::string>();
 
-            auto [err0, book] = ctor(alloc::Heap, book::PRICE, book::TITLE);
+            auto [err0, book] = ctorT(alloc::Heap, book::PRICE, book::TITLE);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(book.isEmpty());
             {
@@ -296,7 +296,7 @@ namespace rtl_tests
             ASSERT_TRUE(typeCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = typeCalender->ctor()(alloc::Stack);
+            auto [err0, calender0] = typeCalender->ctorT()(alloc::Stack);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
@@ -377,7 +377,7 @@ namespace rtl_tests
             ASSERT_TRUE(typeCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = typeCalender->ctor()(alloc::Stack);
+            auto [err0, calender0] = typeCalender->ctorT()(alloc::Stack);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
@@ -458,7 +458,7 @@ namespace rtl_tests
             ASSERT_TRUE(typeCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = typeCalender->ctor()(alloc::Heap);
+            auto [err0, calender0] = typeCalender->ctorT()(alloc::Heap);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
@@ -539,7 +539,7 @@ namespace rtl_tests
             ASSERT_TRUE(typeCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = typeCalender->ctor()(alloc::Heap);
+            auto [err0, calender0] = typeCalender->ctorT()(alloc::Heap);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
diff --git a/RTLTestRunApp/src/FunctionalityTests/MoveConstructorTests.cpp b/RTLTestRunApp/src/FunctionalityTests/MoveConstructorTests.cpp
index 7c86998d..5e4ad0ca 100644
--- a/RTLTestRunApp/src/FunctionalityTests/MoveConstructorTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/MoveConstructorTests.cpp
@@ -21,7 +21,7 @@ namespace rtl_tests
             ASSERT_TRUE(classCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = classCalender->ctor()(alloc::Stack);
+            auto [err0, calender0] = classCalender->ctorT()(alloc::Stack);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
@@ -84,7 +84,7 @@ namespace rtl_tests
             ASSERT_TRUE(classCalender);
 
             // Create a stack-allocated object via reflection
-            auto [err0, calender0] = classCalender->ctor()(alloc::Heap);
+            auto [err0, calender0] = classCalender->ctorT()(alloc::Heap);
 
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender0.isEmpty());
@@ -139,7 +139,7 @@ namespace rtl_tests
             ASSERT_TRUE(oGetTheEvent);
 
             // Create a stack-allocated object via reflection
-            auto [err, calender] = classCalender->ctor()(alloc::Stack);
+            auto [err, calender] = classCalender->ctorT()(alloc::Stack);
             EXPECT_TRUE(err == error::None);
             ASSERT_FALSE(calender.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/NameSpaceGlobalsTests.cpp b/RTLTestRunApp/src/FunctionalityTests/NameSpaceGlobalsTests.cpp
index a905e30f..bc15c10c 100644
--- a/RTLTestRunApp/src/FunctionalityTests/NameSpaceGlobalsTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/NameSpaceGlobalsTests.cpp
@@ -38,17 +38,17 @@ namespace rtl_tests
                 into an RObject in a type-erased manner. (demonstrated in next test case.)
             Therefore, this call yields 'SignatureMismatch' by design.
     */      
-            auto [err, rchar] = charType->ctor<char>()(rtl::alloc::Stack, 'Q');
+            auto [err, rchar] = charType->ctorT<char>()(rtl::alloc::Stack, 'Q');
             EXPECT_TRUE(err == rtl::error::SignatureMismatch);
             ASSERT_TRUE(rchar.isEmpty());
         } {
-            auto [err, rchar] = charType->ctor()(rtl::alloc::Stack);
+            auto [err, rchar] = charType->ctorT()(rtl::alloc::Stack);
             EXPECT_TRUE(err == rtl::error::None);
             ASSERT_FALSE(rchar.isEmpty());
         }
         ASSERT_TRUE(rtl::getRtlManagedHeapInstanceCount() == 0);
         {
-            auto [err, rchar] = charType->ctor()(rtl::alloc::Heap);
+            auto [err, rchar] = charType->ctorT()(rtl::alloc::Heap);
             EXPECT_TRUE(err == rtl::error::None);
             ASSERT_FALSE(rchar.isEmpty());
             ASSERT_TRUE(rtl::getRtlManagedHeapInstanceCount() == 1);
diff --git a/RTLTestRunApp/src/FunctionalityTests/PerfectForwardingTests.cpp b/RTLTestRunApp/src/FunctionalityTests/PerfectForwardingTests.cpp
index 14be11cd..bb743143 100644
--- a/RTLTestRunApp/src/FunctionalityTests/PerfectForwardingTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/PerfectForwardingTests.cpp
@@ -45,7 +45,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Heap);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
@@ -87,7 +87,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Heap);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
@@ -129,7 +129,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Heap);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
@@ -173,7 +173,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Stack);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
@@ -215,7 +215,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Stack);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
@@ -257,7 +257,7 @@ namespace rtl_tests
             ASSERT_TRUE(classAnimal);
 
             // Create an instance of the "Animal" class.
-            auto [err0, animal] = classAnimal->ctor()(alloc::Stack);
+            auto [err0, animal] = classAnimal->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(animal.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/ReflectionOpErrorCodeTests.cpp b/RTLTestRunApp/src/FunctionalityTests/ReflectionOpErrorCodeTests.cpp
index b292c651..395b7c1e 100644
--- a/RTLTestRunApp/src/FunctionalityTests/ReflectionOpErrorCodeTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/ReflectionOpErrorCodeTests.cpp
@@ -79,12 +79,12 @@ namespace rtl_tests
         optional<Record> classEvent = cxx::mirror().getRecord(event::ns, event::struct_);
         ASSERT_TRUE(classEvent);
 
-        auto [err0, robj0] = classEvent->ctor()(alloc::Stack);
+        auto [err0, robj0] = classEvent->ctorT()(alloc::Stack);
 
         EXPECT_TRUE(err0 == error::TypeNotDefaultConstructible);
         ASSERT_TRUE(robj0.isEmpty());
 
-        auto [err1, robj1] = classEvent->ctor()(alloc::Heap);
+        auto [err1, robj1] = classEvent->ctorT()(alloc::Heap);
 
         EXPECT_TRUE(err1 == error::TypeNotDefaultConstructible);
         ASSERT_TRUE(robj1.isEmpty());
@@ -207,7 +207,7 @@ namespace rtl_tests
             ASSERT_TRUE(getEvent);
 
             // Create Calender, which will create a Event's instance.
-            auto [err0, calender] = classCalender->ctor()(alloc::Stack);
+            auto [err0, calender] = classCalender->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(calender.isEmpty());
 
@@ -238,7 +238,7 @@ namespace rtl_tests
             ASSERT_TRUE(classLibrary);
             {
                 // Attempt to create a reflected instance allocated on the heap.
-                auto [err, robj] = classLibrary->ctor()(alloc::Heap);
+                auto [err, robj] = classLibrary->ctorT()(alloc::Heap);
             /*  Heap allocation succeeds:
             *   Even though Library's copy constructor is deleted, RObject internally stores
             *   the pointer directly inside std::any (type-erased), without requiring the type T
@@ -250,7 +250,7 @@ namespace rtl_tests
             EXPECT_TRUE(library::assert_zero_instance_count());
             {
                 // Attempt to create a reflected instance allocated on the stack.
-                auto [err, robj] = classLibrary->ctor()(alloc::Stack);
+                auto [err, robj] = classLibrary->ctorT()(alloc::Stack);
             /*  Stack allocation fails:
             *   Creating a stack instance requires storing the actual object inside std::any.
             *   Since std::any requires the contained type T to be copy-constructible for emplacement,
@@ -309,7 +309,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, person] = classPerson->ctor()(alloc::Heap);
+            auto [err0, person] = classPerson->ctorT()(alloc::Heap);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(person.isEmpty());
 
@@ -337,7 +337,7 @@ namespace rtl_tests
             optional<Record> classBook = cxx::mirror().getRecord(book::class_);
             ASSERT_TRUE(classBook);
 
-            auto [err0, person] = classPerson->ctor()(alloc::Stack);
+            auto [err0, person] = classPerson->ctorT()(alloc::Stack);
             EXPECT_TRUE(err0 == error::None);
             ASSERT_FALSE(person.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/ReturnValueReflectionTest.cpp b/RTLTestRunApp/src/FunctionalityTests/ReturnValueReflectionTest.cpp
index 4ee10b6a..1f594f0c 100644
--- a/RTLTestRunApp/src/FunctionalityTests/ReturnValueReflectionTest.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/ReturnValueReflectionTest.cpp
@@ -16,7 +16,7 @@ namespace rtl_tests
         auto classEvent = cxx::mirror().getRecord(cxx::reflected_id(event::struct_));
         ASSERT_TRUE(classEvent);
 
-        auto [err0, robj0] = classEvent->ctor()(rtl::alloc::Stack);
+        auto [err0, robj0] = classEvent->ctorT()(rtl::alloc::Stack);
 
         //Event's constructor is private, not accessible, Hence the error.
         EXPECT_TRUE(err0 == rtl::error::TypeNotDefaultConstructible);
@@ -25,7 +25,7 @@ namespace rtl_tests
             auto classCalender = cxx::mirror().getRecord(cxx::reflected_id(calender::struct_));
             ASSERT_TRUE(classCalender);
 
-            auto [err1, calender] = classCalender->ctor()(rtl::alloc::Stack);
+            auto [err1, calender] = classCalender->ctorT()(rtl::alloc::Stack);
 
             EXPECT_TRUE(err1 == rtl::error::None);
             ASSERT_FALSE(calender.isEmpty());
diff --git a/RTLTestRunApp/src/FunctionalityTests/StaticMethodTests.cpp b/RTLTestRunApp/src/FunctionalityTests/StaticMethodTests.cpp
index 3d59ac95..a9e80956 100644
--- a/RTLTestRunApp/src/FunctionalityTests/StaticMethodTests.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/StaticMethodTests.cpp
@@ -136,7 +136,7 @@ namespace rtl_tests
 			EXPECT_FALSE(getDefaultsFn);
 			EXPECT_EQ(getDefaultsFn.get_init_error(), error::SignatureMismatch);
 
-			auto [err0, person] = classPerson->ctor()(alloc::Heap);
+			auto [err0, person] = classPerson->ctorT<>()(alloc::Heap);
 
 			EXPECT_EQ(err0, error::None);
 			ASSERT_FALSE(person.isEmpty());
@@ -177,7 +177,7 @@ namespace rtl_tests
 			EXPECT_FALSE(optGetProfile);
 			EXPECT_EQ(optGetProfile.get_init_error(), error::SignatureMismatch);
 
-			auto [err0, person] = classPerson->ctor()(alloc::Heap);
+			auto [err0, person] = classPerson->ctorT()(alloc::Heap);
 
 			EXPECT_EQ(err0, error::None);
 			ASSERT_FALSE(person.isEmpty());
diff --git a/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnAndTargetErased_ConstMethod.cpp b/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnAndTargetErased_ConstMethod.cpp
index de891065..a68000d9 100644
--- a/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnAndTargetErased_ConstMethod.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnAndTargetErased_ConstMethod.cpp
@@ -18,7 +18,7 @@ namespace rtl_tests
 
         auto testWithAlloc = [&](rtl::alloc pAlloc) 
         {
-            auto [err, robj] = recStrConstOverload->ctor()(pAlloc);
+            auto [err, robj] = recStrConstOverload->ctorT()(pAlloc);
             EXPECT_EQ(err, rtl::error::None);
             EXPECT_TRUE(!robj.isEmpty());
 
diff --git a/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnErased_Constructor.cpp b/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnErased_Constructor.cpp
index bad6ca57..b8897362 100644
--- a/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnErased_Constructor.cpp
+++ b/RTLTestRunApp/src/FunctionalityTests/TypeErasedInvocationTests/ReturnErased_Constructor.cpp
@@ -14,10 +14,10 @@ namespace rtl_tests
     TEST(ReturnErased_Constructor, std_string_constructor_call)
     {
         {
-            rtl::constructor<int> ctor;
-            EXPECT_FALSE(ctor);
+            rtl::constructor<int> ctorT;
+            EXPECT_FALSE(ctorT);
 
-            auto [err, robj] = ctor(rtl::alloc::Stack, 0);
+            auto [err, robj] = ctorT(rtl::alloc::Stack, 0);
             EXPECT_EQ(err, rtl::error::InvalidCaller);
             EXPECT_TRUE(robj.isEmpty());
         }
@@ -26,10 +26,10 @@ namespace rtl_tests
         {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto ctor = classStdString->ctor<>();
-                EXPECT_TRUE(ctor);
+                auto ctorT = classStdString->ctorT<>();
+                EXPECT_TRUE(ctorT);
 
-                auto [err, robj] = ctor(alloc_on);
+                auto [err, robj] = ctorT(alloc_on);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -46,10 +46,10 @@ namespace rtl_tests
         {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto ctor = classStdString->ctor<const char*>();
-                EXPECT_TRUE(ctor);
+                auto ctorT = classStdString->ctorT<const char*>();
+                EXPECT_TRUE(ctorT);
 
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -72,10 +72,10 @@ namespace rtl_tests
         {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto ctor = classStrWrap->ctor<>();
-                EXPECT_TRUE(ctor);
+                auto ctorT = classStrWrap->ctorT<>();
+                EXPECT_TRUE(ctorT);
 
-                auto [err, robj] = ctor(alloc_on);
+                auto [err, robj] = ctorT(alloc_on);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -93,10 +93,10 @@ namespace rtl_tests
         {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto ctor = classStrWrap->ctor<std::string_view>();
-                EXPECT_TRUE(ctor);
+                auto ctorT = classStrWrap->ctorT<std::string_view>();
+                EXPECT_TRUE(ctorT);
 
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -113,10 +113,10 @@ namespace rtl_tests
         } {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto ctor = classStrWrap->ctor<const char*>();
-                EXPECT_TRUE(ctor);
+                auto ctorT = classStrWrap->ctorT<const char*>();
+                EXPECT_TRUE(ctorT);
 
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -140,12 +140,12 @@ namespace rtl_tests
         std::optional<rtl::Record> classStrWrap = cxx::mirror().getRecord(StrWrapA::struct_);
         ASSERT_TRUE(classStrWrap);
 
-        auto ctor = classStrWrap->ctor<std::string>();
-        EXPECT_TRUE(ctor);
+        auto ctorT = classStrWrap->ctorT<std::string>();
+        EXPECT_TRUE(ctorT);
         {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor.bind<std::string&>()(alloc_on, SPARTA);
+                auto [err, robj] = ctorT.bind<std::string&>()(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -162,7 +162,7 @@ namespace rtl_tests
         } {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor.bind<std::string&&>()(alloc_on, SPARTA);
+                auto [err, robj] = ctorT.bind<std::string&&>()(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -179,7 +179,7 @@ namespace rtl_tests
         } {
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor.bind<const std::string&>()(alloc_on, SPARTA);
+                auto [err, robj] = ctorT.bind<const std::string&>()(alloc_on, SPARTA);
                 EXPECT_EQ(err, rtl::error::None);
                 EXPECT_FALSE(robj.isEmpty());
 
@@ -204,12 +204,12 @@ namespace rtl_tests
             std::optional<rtl::Record> classStrWrap = cxx::mirror().getRecord(StrWrapA::struct_);
             ASSERT_TRUE(classStrWrap);
 
-            auto ctor = classStrWrap->ctor<std::string>();
-            EXPECT_TRUE(ctor);
+            auto ctorT = classStrWrap->ctorT<std::string>();
+            EXPECT_TRUE(ctorT);
 
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 // More than one reference-based overloads exists.
                 EXPECT_EQ(err, rtl::error::ExplicitRefBindingRequired);
                 EXPECT_TRUE(robj.isEmpty());
@@ -220,12 +220,12 @@ namespace rtl_tests
             std::optional<rtl::Record> classStrWrap = cxx::mirror().getRecord(StrWrapB::struct_);
             ASSERT_TRUE(classStrWrap);
 
-            auto ctor = classStrWrap->ctor<std::string>();
-            EXPECT_TRUE(ctor);
+            auto ctorT = classStrWrap->ctorT<std::string>();
+            EXPECT_TRUE(ctorT);
 
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 // More than one reference-based overloads exists.
                 EXPECT_EQ(err, rtl::error::ExplicitRefBindingRequired);
                 EXPECT_TRUE(robj.isEmpty());
@@ -236,12 +236,12 @@ namespace rtl_tests
             std::optional<rtl::Record> classStrWrap = cxx::mirror().getRecord(StrWrapC::struct_);
             ASSERT_TRUE(classStrWrap);
 
-            auto ctor = classStrWrap->ctor<std::string>();
-            EXPECT_TRUE(ctor);
+            auto ctorT = classStrWrap->ctorT<std::string>();
+            EXPECT_TRUE(ctorT);
 
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 // only non-const-reference-based ctor exists.
                 // mutating call should be explicit.
                 EXPECT_EQ(err, rtl::error::ExplicitRefBindingRequired);
@@ -253,12 +253,12 @@ namespace rtl_tests
             std::optional<rtl::Record> classStrWrap = cxx::mirror().getRecord(StrWrapD::struct_);
             ASSERT_TRUE(classStrWrap);
 
-            auto ctor = classStrWrap->ctor<std::string>();
-            EXPECT_TRUE(ctor);
+            auto ctorT = classStrWrap->ctorT<std::string>();
+            EXPECT_TRUE(ctorT);
 
             auto testCreateOn = [&](rtl::alloc alloc_on)
             {
-                auto [err, robj] = ctor(alloc_on, SPARTA);
+                auto [err, robj] = ctorT(alloc_on, SPARTA);
                 // only const-reference-based ctor exists.
                 // non-mutating call chosen by default.
                 EXPECT_EQ(err, rtl::error::None);
diff --git a/RTLTestRunApp/src/MyReflectionTests/MyReflectionTests.cpp b/RTLTestRunApp/src/MyReflectionTests/MyReflectionTests.cpp
index edc73719..108d6c76 100644
--- a/RTLTestRunApp/src/MyReflectionTests/MyReflectionTests.cpp
+++ b/RTLTestRunApp/src/MyReflectionTests/MyReflectionTests.cpp
@@ -231,7 +231,7 @@ namespace
         //  are forwarded as universal references (&&), which bind only to 
         //  'const std::string&'. This resolution is handled by the compiler,
         //  not by RTL.
-        auto [err, robj] = classPerson->ctor<std::string>()(rtl::alloc::Stack, name);
+        auto [err, robj] = classPerson->ctorT<std::string>()(rtl::alloc::Stack, name);
 
         EXPECT_TRUE(err == rtl::error::None);
         ASSERT_TRUE(!robj.isEmpty());
diff --git a/ReflectionTemplateLib/rtl/inc/Record.h b/ReflectionTemplateLib/rtl/inc/Record.h
index 60c5206c..40db8f88 100644
--- a/ReflectionTemplateLib/rtl/inc/Record.h
+++ b/ReflectionTemplateLib/rtl/inc/Record.h
@@ -55,7 +55,7 @@ namespace rtl
         GETTER_CREF(std::string, RecordName, m_recordName)
         
         template<class ...args_t>
-        constructor<args_t...> ctor() const;
+        constructor<args_t...> ctorT() const;
 
 /*      @method: getMethod
         @param: const std::string& (name of the method)
diff --git a/ReflectionTemplateLib/rtl/inc/Record.hpp b/ReflectionTemplateLib/rtl/inc/Record.hpp
index 740c42dd..2e73f09c 100644
--- a/ReflectionTemplateLib/rtl/inc/Record.hpp
+++ b/ReflectionTemplateLib/rtl/inc/Record.hpp
@@ -18,7 +18,7 @@
 namespace rtl
 {
     template<>
-    inline constructor<> Record::ctor() const
+    inline constructor<> Record::ctorT() const
     {
         constructor<> fnCtor;
         auto strictId = traits::uid<traits::strict_sign_id_t<alloc>>::value;
@@ -41,7 +41,7 @@ namespace rtl
 
 
     template<class ...args_t>
-    inline constructor<args_t...> Record::ctor() const
+    inline constructor<args_t...> Record::ctorT() const
     {
         std::vector<rtl::type_meta> fnTyMetas(detail::call_by::ncref);
         auto normalId = traits::uid<traits::normal_sign_id_t<args_t...>>::value;