diff --git a/.github/workflows/linux-gcc.yml b/.github/workflows/linux-gcc.yml
index b29756ec..ea35b539 100644
--- a/.github/workflows/linux-gcc.yml
+++ b/.github/workflows/linux-gcc.yml
@@ -58,31 +58,31 @@ jobs:
       working-directory: ${{ github.workspace }}/build
       run: ctest -C ${{ matrix.mode }} -j 1 -V
 
-  ubuntu_gcc8:
-    strategy:
-      matrix:
-        mode: [ Debug, Release ]
-        cpp_version: [17]
-    runs-on: ubuntu-20.04
+  # ubuntu_gcc8:
+  #   strategy:
+  #     matrix:
+  #       mode: [ Debug, Release ]
+  #       cpp_version: [17]
+  #   runs-on: ubuntu-20.04
     
-    steps:
-    - name: check out
-      uses: actions/checkout@v3
+  #   steps:
+  #   - name: check out
+  #     uses: actions/checkout@v3
 
-    - name: Install GCC8
-      run: |
-        sudo apt update
-        sudo apt install gcc-8 g++-8
+  #   - name: Install GCC8
+  #     run: |
+  #       sudo apt update
+  #       sudo apt install gcc-8 g++-8
 
-    - name: checkout gcc version
-      run: gcc-8 --version
+  #   - name: checkout gcc version
+  #     run: gcc-8 --version
 
-    - name: configure cmake
-      run: CXX=g++-8 CC=gcc-8 cmake -B ${{ github.workspace }}/build -DCMAKE_BUILD_TYPE=${{ matrix.mode }} -DCMAKE_CXX_STANDARD=${{ matrix.cpp_version }}
+  #   - name: configure cmake
+  #     run: CXX=g++-8 CC=gcc-8 cmake -B ${{ github.workspace }}/build -DCMAKE_BUILD_TYPE=${{ matrix.mode }} -DCMAKE_CXX_STANDARD=${{ matrix.cpp_version }}
       
-    - name: build project
-      run: cmake --build ${{ github.workspace }}/build --config ${{ matrix.mode }}
+  #   - name: build project
+  #     run: cmake --build ${{ github.workspace }}/build --config ${{ matrix.mode }}
       
-    - name: test
-      working-directory: ${{ github.workspace }}/build
-      run: ctest -C ${{ matrix.mode }} -j 1 -V
\ No newline at end of file
+  #   - name: test
+  #     working-directory: ${{ github.workspace }}/build
+  #     run: ctest -C ${{ matrix.mode }} -j 1 -V
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ed7ad81b..cb0c82ac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,7 +75,7 @@ set(YAML_EXAMPLE
 	example/yaml_example.cpp
 )
 
-set(TEST_SOME test/test.cpp)
+set(TEST_SOME test/test_some.cpp)
 set(TEST_UT test/unit_test.cpp)
 set(TEST_JSON_FILES test/test_json_files.cpp)
 set(TEST_XML test/test_xml.cpp)
@@ -88,6 +88,7 @@ set(TEST_UTIL test/test_util.cpp)
 set(TEST_XMLNOTHROW test/test_xml_nothrow.cpp)
 set(TEST_PB test/test_pb.cpp)
 set(TEST_PROTO test/test_proto3.cpp)
+set(TEST_CPP20 test/test_cpp20.cpp)
 set(PB_BENCHMARK benchmark/pb_benchmark.cpp)
 
 add_executable(json_example 	${JSON_EXAMPLE})
@@ -105,6 +106,7 @@ add_executable(yaml_benchmark ${YAMLBENCH})
 add_executable(test_nothrow ${TEST_NOTHROW})
 add_executable(test_util ${TEST_UTIL})
 add_executable(test_pb ${TEST_PB})
+add_executable(test_cpp20 ${TEST_CPP20})
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9)
@@ -166,4 +168,5 @@ add_test(NAME test_yaml COMMAND test_yaml)
 add_test(NAME test_nothrow COMMAND test_nothrow)
 add_test(NAME test_util COMMAND test_util)
 add_test(NAME test_xml_nothrow COMMAND test_xml_nothrow)
-add_test(NAME test_pb COMMAND test_pb)
\ No newline at end of file
+add_test(NAME test_pb COMMAND test_pb)
+add_test(NAME test_cpp20 COMMAND test_cpp20)
diff --git a/benchmark/json_benchmark.cpp b/benchmark/json_benchmark.cpp
index 8aca099f..c9ac82e2 100644
--- a/benchmark/json_benchmark.cpp
+++ b/benchmark/json_benchmark.cpp
@@ -1,7 +1,7 @@
 #include "json_benchmark.h"
 
 class ScopedTimer {
-public:
+ public:
   ScopedTimer(const char *name)
       : m_name(name), m_beg(std::chrono::high_resolution_clock::now()) {}
   ScopedTimer(const char *name, uint64_t &ns) : ScopedTimer(name) {
@@ -18,7 +18,7 @@ class ScopedTimer {
                 << std::setw(12) << dur.count() << " ns\n";
   }
 
-private:
+ private:
   const char *m_name;
   std::chrono::time_point<std::chrono::high_resolution_clock> m_beg;
   uint64_t *m_ns = nullptr;
@@ -60,7 +60,8 @@ struct fixed_name_object_t {
   std::string name4{};
 
 #ifdef HAS_RAPIDJSON
-  template <typename Writer> void Serialize(Writer &writer) const {
+  template <typename Writer>
+  void Serialize(Writer &writer) const {
     writer.StartObject();
     writer.String("name0");
     writer.String(name0);
@@ -76,14 +77,15 @@ struct fixed_name_object_t {
   }
 #endif
 };
-REFLECTION(fixed_name_object_t, name0, name1, name2, name3, name4);
+YLT_REFL(fixed_name_object_t, name0, name1, name2, name3, name4);
 
 struct nested_object_t {
   std::vector<std::array<double, 3>> v3s{};
   std::string id{};
 
 #ifdef HAS_RAPIDJSON
-  template <typename Writer> void Serialize(Writer &writer) const {
+  template <typename Writer>
+  void Serialize(Writer &writer) const {
     writer.StartObject();
     writer.String("v3s");
     writer.StartArray();
@@ -103,7 +105,7 @@ struct nested_object_t {
   }
 #endif
 };
-REFLECTION(nested_object_t, v3s, id);
+YLT_REFL(nested_object_t, v3s, id);
 
 struct another_object_t {
   std::string string{};
@@ -112,7 +114,8 @@ struct another_object_t {
   nested_object_t nested_object{};
 
 #ifdef HAS_RAPIDJSON
-  template <typename Writer> void Serialize(Writer &writer) const {
+  template <typename Writer>
+  void Serialize(Writer &writer) const {
     writer.StartObject();
     writer.String("string");
     writer.String(string);
@@ -126,7 +129,7 @@ struct another_object_t {
   }
 #endif
 };
-REFLECTION(another_object_t, string, another_string, boolean, nested_object);
+YLT_REFL(another_object_t, string, another_string, boolean, nested_object);
 
 struct obj_t {
   //   fixed_object_t fixed_object{};
@@ -139,7 +142,8 @@ struct obj_t {
   bool another_bool{};
 
 #ifdef HAS_RAPIDJSON
-  template <typename Writer> void Serialize(Writer &writer) const {
+  template <typename Writer>
+  void Serialize(Writer &writer) const {
     writer.StartObject();
     writer.String("fixed_name_object");
     fixed_name_object.Serialize(writer);
@@ -167,8 +171,8 @@ struct obj_t {
   }
 #endif
 };
-REFLECTION(obj_t, fixed_name_object, another_object, string_array, string,
-           number, boolean, another_bool);
+YLT_REFL(obj_t, fixed_name_object, another_object, string_array, string, number,
+         boolean, another_bool);
 
 obj_t create_object() {
   fixed_name_object_t fix_obj = {"James", "Abraham", "Susan", "Frank",
@@ -283,7 +287,9 @@ void test_from_json_file() {
   for (auto &pair : test_map) {
     auto content = iguana::json_file_content(pair.first);
     std::visit(
-        [&](auto &&arg) { test_from_json(pair.first, arg, content, 10); },
+        [&](auto &&arg) {
+          test_from_json(pair.first, arg, content, 10);
+        },
         pair.second);
   }
 }
diff --git a/benchmark/json_benchmark.h b/benchmark/json_benchmark.h
index aaf67857..e623d423 100644
--- a/benchmark/json_benchmark.h
+++ b/benchmark/json_benchmark.h
@@ -1,13 +1,14 @@
 #pragma once
-#include "iguana/json_reader.hpp"
-#include "iguana/json_writer.hpp"
-#include "iguana/value.hpp"
 #include <chrono>
 #include <iostream>
 #include <map>
 #include <optional>
 #include <tuple>
 #include <vector>
+
+#include "iguana/json_reader.hpp"
+#include "iguana/json_writer.hpp"
+#include "iguana/value.hpp"
 #ifdef HAS_RAPIDJSON
 #include <rapidjson/document.h>
 #include <rapidjson/writer.h>
@@ -16,27 +17,27 @@
 // canada.json
 struct property_t {
   std::string_view name;
-}; // Property
-REFLECTION(property_t, name);
+};  // Property
+YLT_REFL(property_t, name);
 
 struct polygon_t {
   std::string_view type;
   std::vector<std::vector<std::array<iguana::numeric_str, 2>>> coordinates;
-}; // Polygon
-REFLECTION(polygon_t, type, coordinates);
+};  // Polygon
+YLT_REFL(polygon_t, type, coordinates);
 
 struct feature_t {
   std::string_view type;
   property_t properties;
   polygon_t geometry;
-}; // Feature
-REFLECTION(feature_t, type, properties, geometry);
+};  // Feature
+YLT_REFL(feature_t, type, properties, geometry);
 
 struct FeatureCollection {
   std::string_view type;
   std::vector<feature_t> features;
-}; // FeatureCollection
-REFLECTION(FeatureCollection, type, features);
+};  // FeatureCollection
+YLT_REFL(FeatureCollection, type, features);
 
 // apache_builds.json
 struct jobs_t {
@@ -44,16 +45,16 @@ struct jobs_t {
   std::string_view url;
   std::string_view color;
 };
-REFLECTION(jobs_t, name, url, color);
+YLT_REFL(jobs_t, name, url, color);
 
 struct views_t {
   std::string_view name;
   std::string_view url;
 };
-REFLECTION(views_t, name, url);
+YLT_REFL(views_t, name, url);
 
 struct apache_empty_t {};
-REFLECTION_EMPTY(apache_empty_t);
+YLT_REFL(apache_empty_t);
 
 struct apache_builds {
   std::vector<apache_empty_t> assignedLabels;
@@ -72,10 +73,10 @@ struct apache_builds {
   bool useSecurity;
   std::vector<views_t> views;
 };
-REFLECTION(apache_builds, assignedLabels, mode, nodeDescription, nodeName,
-           numExecutors, description, jobs, overallLoad, primaryView,
-           quietingDown, slaveAgentPort, unlabeledLoad, useCrumbs, useSecurity,
-           views);
+YLT_REFL(apache_builds, assignedLabels, mode, nodeDescription, nodeName,
+         numExecutors, description, jobs, overallLoad, primaryView,
+         quietingDown, slaveAgentPort, unlabeledLoad, useCrumbs, useSecurity,
+         views);
 
 // citm_catalog.json
 struct events_value_t {
@@ -87,28 +88,28 @@ struct events_value_t {
   std::optional<iguana::numeric_str> subjectCode;
   std::optional<std::string_view> subtitle;
   std::vector<iguana::numeric_str> topicIds;
-}; // events_value_t
-REFLECTION(events_value_t, description, id, logo, name, subTopicIds,
-           subjectCode, subtitle, topicIds);
+};  // events_value_t
+YLT_REFL(events_value_t, description, id, logo, name, subTopicIds, subjectCode,
+         subtitle, topicIds);
 
 struct prices_element_t {
   iguana::numeric_str amount;
   iguana::numeric_str audienceSubCategoryId;
   iguana::numeric_str seatCategoryId;
-}; // prices_element_t
-REFLECTION(prices_element_t, amount, audienceSubCategoryId, seatCategoryId);
+};  // prices_element_t
+YLT_REFL(prices_element_t, amount, audienceSubCategoryId, seatCategoryId);
 
 struct areas_element_t {
   iguana::numeric_str areaId;
   std::vector<iguana::numeric_str> blockIds;
-}; // areas_element_t
-REFLECTION(areas_element_t, areaId, blockIds);
+};  // areas_element_t
+YLT_REFL(areas_element_t, areaId, blockIds);
 
 struct seatCategories_element_t {
   std::vector<areas_element_t> areas;
   iguana::numeric_str seatCategoryId;
-}; // seatCategories_element_t
-REFLECTION(seatCategories_element_t, areas, seatCategoryId);
+};  // seatCategories_element_t
+YLT_REFL(seatCategories_element_t, areas, seatCategoryId);
 
 struct performances_element_t {
   iguana::numeric_str eventId;
@@ -120,14 +121,14 @@ struct performances_element_t {
   std::optional<std::string_view> seatMapImage;
   iguana::numeric_str start;
   std::string_view venueCode;
-}; // performances_element_t
-REFLECTION(performances_element_t, eventId, id, logo, name, prices,
-           seatCategories, seatMapImage, start, venueCode);
+};  // performances_element_t
+YLT_REFL(performances_element_t, eventId, id, logo, name, prices,
+         seatCategories, seatMapImage, start, venueCode);
 
 struct venueNames_t {
   std::string_view PLEYEL_PLEYEL;
-}; // venueNames_t
-REFLECTION(venueNames_t, PLEYEL_PLEYEL);
+};  // venueNames_t
+YLT_REFL(venueNames_t, PLEYEL_PLEYEL);
 
 struct citm_object_t {
   std::unordered_map<std::string_view, std::string_view> areaNames;
@@ -143,38 +144,38 @@ struct citm_object_t {
   std::unordered_map<std::string_view, std::vector<iguana::numeric_str>>
       topicSubTopics;
   std::optional<venueNames_t> venueNames;
-}; // citm_object_t
-REFLECTION(citm_object_t, areaNames, audienceSubCategoryNames, blockNames,
-           events, performances, seatCategoryNames, subTopicNames, subjectNames,
-           topicNames, topicSubTopics, venueNames);
+};  // citm_object_t
+YLT_REFL(citm_object_t, areaNames, audienceSubCategoryNames, blockNames, events,
+         performances, seatCategoryNames, subTopicNames, subjectNames,
+         topicNames, topicSubTopics, venueNames);
 
 // gsoc-2018.json
 struct sponsor_t {
-  std::string_view type; //@
+  std::string_view type;  //@
   std::string_view name;
   std::string_view disambiguatingDescription;
   std::string_view description;
   std::string_view url;
   std::string_view logo;
 };
-REFLECTION(sponsor_t, type, name, disambiguatingDescription, description, url,
-           logo);
+YLT_REFL(sponsor_t, type, name, disambiguatingDescription, description, url,
+         logo);
 
 struct author_t {
-  std::string_view type; //@
+  std::string_view type;  //@
   std::string_view name;
 };
-REFLECTION(author_t, type, name);
+YLT_REFL(author_t, type, name);
 
 struct gsoc_element_t {
-  std::string_view context; //@
-  std::string_view type;    //@
+  std::string_view context;  //@
+  std::string_view type;     //@
   std::string_view name;
   std::string_view description;
   sponsor_t sponsor;
   author_t author;
 };
-REFLECTION(gsoc_element_t, context, type, name, description, sponsor, author);
+YLT_REFL(gsoc_element_t, context, type, name, description, sponsor, author);
 
 using gsoc_object_t = std::map<std::string_view, gsoc_element_t>;
 
@@ -184,7 +185,7 @@ struct mesh_element_t {
   std::vector<iguana::numeric_str> usedBones;
   std::vector<iguana::numeric_str> vertexRange;
 };
-REFLECTION(mesh_element_t, indexRange, usedBones, vertexRange);
+YLT_REFL(mesh_element_t, indexRange, usedBones, vertexRange);
 
 struct mesh_t {
   std::vector<mesh_element_t> batches;
@@ -196,8 +197,8 @@ struct mesh_t {
   std::vector<iguana::numeric_str> positions;
   std::vector<iguana::numeric_str> tex0;
 };
-REFLECTION(mesh_t, batches, colors, indices, influences, morphTargets, normals,
-           positions, tex0);
+YLT_REFL(mesh_t, batches, colors, indices, influences, morphTargets, normals,
+         positions, tex0);
 
 // random.json
 struct friend_t {
@@ -205,7 +206,7 @@ struct friend_t {
   std::string_view name;
   std::string_view phone;
 };
-REFLECTION(friend_t, id, name, phone);
+YLT_REFL(friend_t, id, name, phone);
 
 struct random_element_t {
   iguana::numeric_str id;
@@ -220,8 +221,8 @@ struct random_element_t {
   std::vector<friend_t> friends;
   std::string_view field;
 };
-REFLECTION(random_element_t, id, avatar, age, admin, name, company, phone,
-           email, birthDate, friends, field);
+YLT_REFL(random_element_t, id, avatar, age, admin, name, company, phone, email,
+         birthDate, friends, field);
 
 struct random_t {
   iguana::numeric_str id;
@@ -229,7 +230,7 @@ struct random_t {
   iguana::numeric_str total;
   std::vector<random_element_t> result;
 };
-REFLECTION(random_t, id, jsonrpc, total, result);
+YLT_REFL(random_t, id, jsonrpc, total, result);
 
 // github_events.json
 namespace githubEvents {
@@ -250,9 +251,9 @@ struct user_t {
   std::string_view followers_url;
   std::string_view following_url;
 };
-REFLECTION(user_t, gists_url, gravatar_id, url, type, avatar_url,
-           subscriptions_url, organizations_url, received_events_url, repos_url,
-           login, starred_url, id, events_url, followers_url, following_url);
+YLT_REFL(user_t, gists_url, gravatar_id, url, type, avatar_url,
+         subscriptions_url, organizations_url, received_events_url, repos_url,
+         login, starred_url, id, events_url, followers_url, following_url);
 
 struct page_t {
   std::string_view page_name;
@@ -262,14 +263,14 @@ struct page_t {
   std::optional<std::string_view> summary;
   std::string_view action;
 };
-REFLECTION(page_t, page_name, html_url, title, sha, summary, action);
+YLT_REFL(page_t, page_name, html_url, title, sha, summary, action);
 
 struct pull_request_t {
   std::optional<std::string_view> html_url;
   std::optional<std::string_view> patch_url;
   std::optional<std::string_view> diff_url;
 };
-REFLECTION(pull_request_t, html_url, patch_url, diff_url);
+YLT_REFL(pull_request_t, html_url, patch_url, diff_url);
 
 struct forkee_t {
   std::string_view full_name;
@@ -337,18 +338,18 @@ struct forkee_t {
   iguana::numeric_str watchers;
   std::string_view git_url;
 };
-REFLECTION(forkee_t, full_name, stargazers_url, clone_url, fork, url, tags_url,
-           description, merges_url, forks, language, ___private, archive_url,
-           collaborators_url, languages_url, owner, git_refs_url, labels_url,
-           pushed_at, html_url, trees_url, forks_url, commits_url, branches_url,
-           notifications_url, created_at, has_issues, blobs_url, issues_url,
-           open_issues, contents_url, name, statuses_url, assignees_url,
-           forks_count, updated_at, issue_events_url, ssh_url, subscribers_url,
-           mirror_url, ___public, has_wiki, git_commits_url, downloads_url, id,
-           pulls_url, has_downloads, issue_comment_url, watchers_count,
-           homepage, hooks_url, subscription_url, milestones_url, events_url,
-           svn_url, git_tags_url, teams_url, comments_url, open_issues_count,
-           keys_url, contributors_url, size, watchers, git_url, compare_url);
+YLT_REFL(forkee_t, full_name, stargazers_url, clone_url, fork, url, tags_url,
+         description, merges_url, forks, language, ___private, archive_url,
+         collaborators_url, languages_url, owner, git_refs_url, labels_url,
+         pushed_at, html_url, trees_url, forks_url, commits_url, branches_url,
+         notifications_url, created_at, has_issues, blobs_url, issues_url,
+         open_issues, contents_url, name, statuses_url, assignees_url,
+         forks_count, updated_at, issue_events_url, ssh_url, subscribers_url,
+         mirror_url, ___public, has_wiki, git_commits_url, downloads_url, id,
+         pulls_url, has_downloads, issue_comment_url, watchers_count, homepage,
+         hooks_url, subscription_url, milestones_url, events_url, svn_url,
+         git_tags_url, teams_url, comments_url, open_issues_count, keys_url,
+         contributors_url, size, watchers, git_url, compare_url);
 
 struct issue_t {
   user_t user;
@@ -371,9 +372,9 @@ struct issue_t {
   std::string_view events_url;
   std::string_view comments_url;
 };
-REFLECTION(issue_t, user, url, labels, html_url, labels_url, pull_request,
-           created_at, closed_at, milestone, title, body, updated_at, number,
-           state, assignee, id, comments, events_url, comments_url);
+YLT_REFL(issue_t, user, url, labels, html_url, labels_url, pull_request,
+         created_at, closed_at, milestone, title, body, updated_at, number,
+         state, assignee, id, comments, events_url, comments_url);
 
 struct comment_t {
   user_t user;
@@ -384,7 +385,7 @@ struct comment_t {
   std::string_view updated_at;
   iguana::numeric_str id;
 };
-REFLECTION(comment_t, user, url, issue_url, created_at, body, updated_at, id);
+YLT_REFL(comment_t, user, url, issue_url, created_at, body, updated_at, id);
 
 struct actor_org_t {
   std::string_view gravatar_id;
@@ -393,20 +394,20 @@ struct actor_org_t {
   std::string_view url;
   iguana::numeric_str id;
 };
-REFLECTION(actor_org_t, gravatar_id, login, avatar_url, url, id);
+YLT_REFL(actor_org_t, gravatar_id, login, avatar_url, url, id);
 
 struct repo_t {
   std::string_view url;
   iguana::numeric_str id;
   std::string_view name;
 };
-REFLECTION(repo_t, url, id, name);
+YLT_REFL(repo_t, url, id, name);
 
 struct author_t {
   std::string_view email;
   std::string_view name;
 };
-REFLECTION(author_t, email, name);
+YLT_REFL(author_t, email, name);
 
 struct commit_t {
   std::string_view url;
@@ -415,7 +416,7 @@ struct commit_t {
   std::string_view sha;
   author_t author;
 };
-REFLECTION(commit_t, url, message, distinct, sha, author);
+YLT_REFL(commit_t, url, message, distinct, sha, author);
 
 struct payload_t {
   std::optional<std::vector<commit_t>> commits;
@@ -435,9 +436,9 @@ struct payload_t {
 
   std::optional<std::string_view> ref_type;
 };
-REFLECTION(payload_t, commits, distinct_size, ref, push_id, head, before, size,
-           forkee, pages, action, comment, issue, description, master_branch,
-           ref_type);
+YLT_REFL(payload_t, commits, distinct_size, ref, push_id, head, before, size,
+         forkee, pages, action, comment, issue, description, master_branch,
+         ref_type);
 
 struct event_t {
   std::string_view type;
@@ -449,10 +450,10 @@ struct event_t {
   payload_t payload;
   std::string_view id;
 };
-REFLECTION(event_t, type, created_at, actor, repo, ___public, org, payload, id);
+YLT_REFL(event_t, type, created_at, actor, repo, ___public, org, payload, id);
 
 using events_t = std::vector<event_t>;
-} // namespace githubEvents
+}  // namespace githubEvents
 
 namespace marine_ik {
 struct image_element_t {
@@ -460,14 +461,14 @@ struct image_element_t {
   std::string_view uuid;
   std::string_view name;
 };
-REFLECTION(image_element_t, url, uuid, name);
+YLT_REFL(image_element_t, url, uuid, name);
 
 struct item_t {
   std::string_view name;
   std::string_view type;
   std::string_view uuid;
 };
-REFLECTION(item_t, name, type, uuid);
+YLT_REFL(item_t, name, type, uuid);
 
 struct key_element_t {
   std::array<iguana::numeric_str, 4> rot;
@@ -475,13 +476,13 @@ struct key_element_t {
   std::array<iguana::numeric_str, 3> scl;
   std::array<iguana::numeric_str, 3> pos;
 };
-REFLECTION(key_element_t, rot, time, scl, pos);
+YLT_REFL(key_element_t, rot, time, scl, pos);
 
 struct hierarchy_element_t {
   iguana::numeric_str parent;
   std::vector<key_element_t> keys;
 };
-REFLECTION(hierarchy_element_t, parent, keys);
+YLT_REFL(hierarchy_element_t, parent, keys);
 
 struct geo_anim_element_t {
   std::vector<hierarchy_element_t> hierarchy;
@@ -489,7 +490,7 @@ struct geo_anim_element_t {
   iguana::numeric_str fps{};
   std::string_view name;
 };
-REFLECTION(geo_anim_element_t, hierarchy, length, fps, name);
+YLT_REFL(geo_anim_element_t, hierarchy, length, fps, name);
 
 struct bone_element_t {
   iguana::numeric_str parent;
@@ -498,7 +499,7 @@ struct bone_element_t {
   std::array<iguana::numeric_str, 3> scl;
   std::string_view name;
 };
-REFLECTION(bone_element_t, parent, pos, rotq, scl, name);
+YLT_REFL(bone_element_t, parent, pos, rotq, scl, name);
 
 struct geo_meta_data_t {
   iguana::numeric_str uvs;
@@ -509,8 +510,8 @@ struct geo_meta_data_t {
   iguana::numeric_str bones;
   iguana::numeric_str vertices;
 };
-REFLECTION(geo_meta_data_t, uvs, version, faces, generator, normals, bones,
-           vertices);
+YLT_REFL(geo_meta_data_t, uvs, version, faces, generator, normals, bones,
+         vertices);
 
 struct geo_data_t {
   std::vector<std::vector<iguana::numeric_str>> uvs;
@@ -525,15 +526,15 @@ struct geo_data_t {
   std::vector<bone_element_t> bones;
   std::vector<iguana::numeric_str> faces;
 };
-REFLECTION(geo_data_t, uvs, animations, vertices, metadata, name, skinWeights,
-           skinIndices, influencesPerVertex, normals, bones, faces);
+YLT_REFL(geo_data_t, uvs, animations, vertices, metadata, name, skinWeights,
+         skinIndices, influencesPerVertex, normals, bones, faces);
 
 struct geometry_element_t {
   std::string_view type;
   std::string_view uuid;
   geo_data_t data;
 };
-REFLECTION(geometry_element_t, type, uuid, data);
+YLT_REFL(geometry_element_t, type, uuid, data);
 
 struct texture_element_t {
   std::array<iguana::numeric_str, 2> repeat;
@@ -546,8 +547,8 @@ struct texture_element_t {
   std::string_view uuid;
   iguana::numeric_str magFilter{};
 };
-REFLECTION(texture_element_t, repeat, wrap, anisotropy, image, name, mapping,
-           minFilter, uuid, magFilter);
+YLT_REFL(texture_element_t, repeat, wrap, anisotropy, image, name, mapping,
+         minFilter, uuid, magFilter);
 
 struct meta_data_t {
   std::string_view sourceFile;
@@ -555,7 +556,7 @@ struct meta_data_t {
   std::string_view type;
   iguana::numeric_str version{};
 };
-REFLECTION(meta_data_t, sourceFile, generator, type, version);
+YLT_REFL(meta_data_t, sourceFile, generator, type, version);
 
 struct material_element_t : item_t {
   iguana::numeric_str vertexColors{};
@@ -569,9 +570,9 @@ struct material_element_t : item_t {
   bool depthWrite{};
   iguana::numeric_str specular{};
 };
-REFLECTION(material_element_t, vertexColors, name, type, uuid, blending, map,
-           transparent, depthTest, color, shininess, emissive, depthWrite,
-           specular);
+YLT_REFL(material_element_t, vertexColors, name, type, uuid, blending, map,
+         transparent, depthTest, color, shininess, emissive, depthWrite,
+         specular);
 
 struct obj_child_t : item_t {
   std::array<iguana::numeric_str, 16> matrix;
@@ -581,8 +582,8 @@ struct obj_child_t : item_t {
   bool receiveShadow{};
   std::string_view geometry;
 };
-REFLECTION(obj_child_t, name, uuid, matrix, visible, type, material, castShadow,
-           receiveShadow, geometry);
+YLT_REFL(obj_child_t, name, uuid, matrix, visible, type, material, castShadow,
+         receiveShadow, geometry);
 
 struct object_t {
   std::vector<obj_child_t> children;
@@ -590,14 +591,14 @@ struct object_t {
   std::array<iguana::numeric_str, 16> matrix;
   std::string_view uuid;
 };
-REFLECTION(object_t, children, type, matrix, uuid);
+YLT_REFL(object_t, children, type, matrix, uuid);
 
 struct animation_element_t {
   std::vector<iguana::numeric_str> tracks;
   iguana::numeric_str fps;
   std::string_view name;
 };
-REFLECTION(animation_element_t, tracks, fps, name);
+YLT_REFL(animation_element_t, tracks, fps, name);
 
 struct marine_ik_t {
   std::vector<image_element_t> images;
@@ -608,9 +609,9 @@ struct marine_ik_t {
   object_t object;
   std::vector<animation_element_t> animations;
 };
-REFLECTION(marine_ik_t, images, geometries, textures, metadata, materials,
-           object, animations);
-} // namespace marine_ik
+YLT_REFL(marine_ik_t, images, geometries, textures, metadata, materials, object,
+         animations);
+}  // namespace marine_ik
 
 // instruments.json
 struct sample_element {
@@ -630,9 +631,9 @@ struct sample_element {
   iguana::numeric_str vibrato_type;
   iguana::numeric_str volume;
 };
-REFLECTION(sample_element, c5_samplerate, global_volume, legacy_filename,
-           length, loop_end, loop_start, name, pan, sustain_end, sustain_start,
-           vibrato_depth, vibrato_rate, vibrato_sweep, vibrato_type, volume);
+YLT_REFL(sample_element, c5_samplerate, global_volume, legacy_filename, length,
+         loop_end, loop_start, name, pan, sustain_end, sustain_start,
+         vibrato_depth, vibrato_rate, vibrato_sweep, vibrato_type, volume);
 
 struct data_t {
   iguana::numeric_str channel;
@@ -644,7 +645,7 @@ struct data_t {
   iguana::numeric_str volcmd;
   iguana::numeric_str volval;
 };
-REFLECTION(data_t, channel, fxcmd, fxparam, instr, note, row, volcmd, volval);
+YLT_REFL(data_t, channel, fxcmd, fxparam, instr, note, row, volcmd, volval);
 
 struct pattern_element {
   std::optional<std::vector<data_t>> data;
@@ -653,13 +654,13 @@ struct pattern_element {
   iguana::numeric_str rows_per_beat;
   iguana::numeric_str rows_per_measure;
 };
-REFLECTION(pattern_element, data, name, rows, rows_per_beat, rows_per_measure);
+YLT_REFL(pattern_element, data, name, rows, rows_per_beat, rows_per_measure);
 
 struct node_t {
   iguana::numeric_str tick;
   iguana::numeric_str value;
 };
-REFLECTION(node_t, tick, value);
+YLT_REFL(node_t, tick, value);
 
 struct panning_envelope_t {
   iguana::numeric_str loop_end;
@@ -669,8 +670,8 @@ struct panning_envelope_t {
   iguana::numeric_str sustain_end;
   iguana::numeric_str sustain_start;
 };
-REFLECTION(panning_envelope_t, loop_end, loop_start, nodes, release_node,
-           sustain_end, sustain_start);
+YLT_REFL(panning_envelope_t, loop_end, loop_start, nodes, release_node,
+         sustain_end, sustain_start);
 
 struct instrument_element {
   iguana::numeric_str default_filter_cutoff;
@@ -709,17 +710,16 @@ struct instrument_element {
   iguana::numeric_str volume_ramp_down;
   iguana::numeric_str volume_ramp_up;
 };
-REFLECTION(instrument_element, default_filter_cutoff,
-           default_filter_cutoff_enabled, default_filter_mode,
-           default_filter_resonance, default_filter_resonance_enabled,
-           default_pan, duplicate_check_type, duplicate_note_action, fadeout,
-           global_volume, graph_insert, legacy_filename, midi_bank,
-           midi_channel, midi_drum_set, midi_program, name, new_note_action,
-           note_map, panning_envelope, pitch_envelope, pitch_pan_center,
-           pitch_pan_separation, pitch_to_tempo_lock, random_cutoff_weight,
-           random_pan_weight, random_resonance_weight, random_volume_weight,
-           sample_map, tuning, volume_envelope, volume_ramp_down,
-           volume_ramp_up);
+YLT_REFL(instrument_element, default_filter_cutoff,
+         default_filter_cutoff_enabled, default_filter_mode,
+         default_filter_resonance, default_filter_resonance_enabled,
+         default_pan, duplicate_check_type, duplicate_note_action, fadeout,
+         global_volume, graph_insert, legacy_filename, midi_bank, midi_channel,
+         midi_drum_set, midi_program, name, new_note_action, note_map,
+         panning_envelope, pitch_envelope, pitch_pan_center,
+         pitch_pan_separation, pitch_to_tempo_lock, random_cutoff_weight,
+         random_pan_weight, random_resonance_weight, random_volume_weight,
+         sample_map, tuning, volume_envelope, volume_ramp_down, volume_ramp_up);
 
 struct instruments_t {
   std::optional<iguana::numeric_str> graphstate;
@@ -732,5 +732,5 @@ struct instruments_t {
   std::vector<sample_element> samples;
   iguana::numeric_str version;
 };
-REFLECTION(instruments_t, graphstate, instruments, message, name, orderlist,
-           patterns, pluginstate, samples, version);
+YLT_REFL(instruments_t, graphstate, instruments, message, name, orderlist,
+         patterns, pluginstate, samples, version);
diff --git a/benchmark/xml_bench.hpp b/benchmark/xml_bench.hpp
index ca5352b2..77cc6cc2 100644
--- a/benchmark/xml_bench.hpp
+++ b/benchmark/xml_bench.hpp
@@ -9,7 +9,6 @@
 #include <unordered_map>
 #include <vector>
 
-#include "iguana/reflection.hpp"
 #include "iguana/xml_reader.hpp"
 #include "iguana/xml_writer.hpp"
 
@@ -19,18 +18,18 @@ struct package_t {
   std::optional<std::string_view> version;
   std::vector<std::string_view> file;
 };
-REFLECTION(package_t, version, file);
+YLT_REFL(package_t, version, file);
 
 struct filelists_t {
   std::vector<package_t> package;
 };
-REFLECTION(filelists_t, package);
+YLT_REFL(filelists_t, package);
 // ************ struct for sample_rss.xml ****************
 
 struct skip_t {
   std::string_view skip;
 };
-REFLECTION(skip_t, skip);
+YLT_REFL(skip_t, skip);
 struct item_t {
   std::string_view title;
   std::string_view link;
@@ -49,17 +48,17 @@ struct item_t {
   std::optional<std::string_view> media_content;
   std::string_view itunes_keywords;
 };
-REFLECTION(item_t, title, link, description, pubDate, enclosure, guid,
-           itunes_author, itunes_subtitle, itunes_summary, itunes_explicit,
-           itunes_duration, dc_creator, media_thumbnail, author, media_content,
-           itunes_keywords);
+YLT_REFL(item_t, title, link, description, pubDate, enclosure, guid,
+         itunes_author, itunes_subtitle, itunes_summary, itunes_explicit,
+         itunes_duration, dc_creator, media_thumbnail, author, media_content,
+         itunes_keywords);
 
 struct image_t {
   std::string_view link;
   std::string_view url;
   std::string_view title;
 };
-REFLECTION(image_t, link, url, title);
+YLT_REFL(image_t, link, url, title);
 
 struct channel_t {
   std::string_view title;
@@ -82,15 +81,15 @@ struct channel_t {
   std::string_view media_rating;
   std::string_view media_description;
 };
-REFLECTION(channel_t, title, link, description, generator, docs, language,
-           pubDate, lastBuildDate, image, itunes_author, itunes_subtitle,
-           itunes_keywords, itunes_image, itunes_explicit, itunes_block, item,
-           media_credit, media_rating, media_description);
+YLT_REFL(channel_t, title, link, description, generator, docs, language,
+         pubDate, lastBuildDate, image, itunes_author, itunes_subtitle,
+         itunes_keywords, itunes_image, itunes_explicit, itunes_block, item,
+         media_credit, media_rating, media_description);
 
 struct rss_t {
   channel_t channel;
 };
-REFLECTION(rss_t, channel);
+YLT_REFL(rss_t, channel);
 
 // ************ struct for bench_num.xml ****************
 
@@ -103,16 +102,16 @@ struct goods_t {
   std::string_view rating;
   std::string_view discount;
 };
-REFLECTION(goods_t, id, sales, inventory, weight, price, rating, discount);
+YLT_REFL(goods_t, id, sales, inventory, weight, price, rating, discount);
 struct storeowner_t {
   std::string_view name;
   std::string_view telephone;
 };
-REFLECTION(storeowner_t, name, telephone);
+YLT_REFL(storeowner_t, name, telephone);
 struct store_t {
   std::string_view name;
   std::string_view address;
   storeowner_t owner;
   std::vector<goods_t> goods;
 };
-REFLECTION(store_t, name, address, owner, goods);
+YLT_REFL(store_t, name, address, owner, goods);
diff --git a/benchmark/yaml_benchmark.hpp b/benchmark/yaml_benchmark.hpp
index c913128f..2f30d4f4 100644
--- a/benchmark/yaml_benchmark.hpp
+++ b/benchmark/yaml_benchmark.hpp
@@ -1,9 +1,10 @@
+#include <iostream>
+
 #include "iguana/yaml_reader.hpp"
 #include "iguana/yaml_writer.hpp"
-#include <iostream>
 
 class ScopedTimer {
-public:
+ public:
   ScopedTimer(const char *name)
       : m_name(name), m_beg(std::chrono::high_resolution_clock::now()) {}
   ScopedTimer(const char *name, uint64_t &ns) : ScopedTimer(name) {
@@ -20,7 +21,7 @@ class ScopedTimer {
                 << std::setw(12) << dur.count() << " ns\n";
   }
 
-private:
+ private:
   const char *m_name;
   std::chrono::time_point<std::chrono::high_resolution_clock> m_beg;
   uint64_t *m_ns = nullptr;
@@ -42,31 +43,31 @@ std::string yaml_file_content(const std::string &filename) {
   return content;
 }
 
-/*--------- REFLECTION appveyor.yml-------------*/
+/*--------- YLT_REFL appveyor.yml-------------*/
 
 struct matrix_t {
   std::string_view compiler;
   std::string_view generator;
   std::string_view configuration;
 };
-REFLECTION(matrix_t, compiler, generator, configuration);
+YLT_REFL(matrix_t, compiler, generator, configuration);
 struct environment_t {
   std::vector<matrix_t> matrix;
 };
-REFLECTION(environment_t, matrix);
+YLT_REFL(environment_t, matrix);
 struct ex_matrix_t {
   std::string_view fast_finish;
 };
-REFLECTION(ex_matrix_t, fast_finish);
+YLT_REFL(ex_matrix_t, fast_finish);
 struct artifact_t {
   std::string_view path;
   std::string_view name;
 };
-REFLECTION(artifact_t, path, name);
+YLT_REFL(artifact_t, path, name);
 struct skip_commit_t {
   std::vector<std::string_view> files;
 };
-REFLECTION(skip_commit_t, files);
+YLT_REFL(skip_commit_t, files);
 struct appveyor_t {
   std::string_view version;
   std::string_view image;
@@ -78,33 +79,33 @@ struct appveyor_t {
   std::vector<artifact_t> artifacts;
   skip_commit_t skip_commits;
 };
-REFLECTION(appveyor_t, version, image, environment, matrix, install,
-           build_script, test_script, artifacts, skip_commits);
+YLT_REFL(appveyor_t, version, image, environment, matrix, install, build_script,
+         test_script, artifacts, skip_commits);
 
-/*--------- REFLECTION travis.yml-------------*/
+/*--------- YLT_REFL travis.yml-------------*/
 struct apt_t {
   std::vector<std::string_view> sources;
 };
-REFLECTION(apt_t, sources);
+YLT_REFL(apt_t, sources);
 struct addon_t {
   apt_t apt;
 };
-REFLECTION(addon_t, apt);
+YLT_REFL(addon_t, apt);
 
 struct env_t {
   std::vector<std::string_view> global;
 };
-REFLECTION(env_t, global);
+YLT_REFL(env_t, global);
 
 struct in_env_t {
   std::string_view env;
 };
-REFLECTION(in_env_t, env);
+YLT_REFL(in_env_t, env);
 
 struct mat_t {
   std::vector<in_env_t> include;
 };
-REFLECTION(mat_t, include);
+YLT_REFL(mat_t, include);
 
 struct travis_t {
   std::string_view sudo;
@@ -117,5 +118,5 @@ struct travis_t {
   std::vector<std::string_view> script;
   std::vector<std::string_view> after_success;
 };
-REFLECTION(travis_t, sudo, dist, language, addons, env, matrix, install, script,
-           after_success);
+YLT_REFL(travis_t, sudo, dist, language, addons, env, matrix, install, script,
+         after_success);
diff --git a/example/example.cpp b/example/example.cpp
index d5b65522..f7cdd06e 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -8,19 +8,19 @@ struct person {
   std::string name;
   int age;
 };
-REFLECTION(person, name, age)
+YLT_REFL(person, name, age)
 
 struct one_t {
   int id;
 };
-REFLECTION(one_t, id);
+YLT_REFL(one_t, id);
 
 struct two {
   std::string name;
   one_t one;
   int age;
 };
-REFLECTION(two, name, one, age);
+YLT_REFL(two, name, one, age);
 
 struct composit_t {
   int a;
@@ -31,7 +31,7 @@ struct composit_t {
   double f;
   std::vector<one_t> g;
 };
-REFLECTION(composit_t, a, b, c, d, e, f, g);
+YLT_REFL(composit_t, a, b, c, d, e, f, g);
 
 void test_json() {
   person p;
diff --git a/example/json_example.cpp b/example/json_example.cpp
index 4d18fa37..a98fa058 100644
--- a/example/json_example.cpp
+++ b/example/json_example.cpp
@@ -14,28 +14,26 @@ inline char* to_chars_float(T value, char* buffer) {
 #include <iguana/json_reader.hpp>
 #include <iguana/json_writer.hpp>
 
-//#include <boost/timer.hpp>
-
 namespace client {
 struct person {
   std::string name;
   int64_t age;
 };
 
-REFLECTION(person, name, age);
+YLT_REFL(person, name, age);
 }  // namespace client
 
 struct MyStruct {
   uint64_t a;
 };
-REFLECTION(MyStruct, a);
+YLT_REFL(MyStruct, a);
 
 struct student {
   int id;
   std::string name;
   int age;
 };
-REFLECTION(student, id, name, age);
+YLT_REFL(student, id, name, age);
 
 void test() {
   MyStruct p = {5566777755311};
@@ -82,7 +80,7 @@ struct book_t {
   std::string_view edition;
   std::vector<std::string_view> author;
 };
-REFLECTION(book_t, title, edition, author);
+YLT_REFL(book_t, title, edition, author);
 
 void test_str_view() {
   {
@@ -114,6 +112,8 @@ struct my_struct {
   }
 };
 
+void ylt_custom_reflect(my_struct*) {}
+
 template <bool Is_writing_escape, typename Stream>
 inline void to_json_impl(Stream& s, const my_struct& t) {
   iguana::to_json(*(int(*)[3]) & t, s);
@@ -134,11 +134,11 @@ struct nest {
   }
 };
 
-REFLECTION(nest, name, value);
+YLT_REFL(nest, name, value);
 
 void user_defined_struct_example() {
   {
-    my_space::my_struct v{1, 2, 3}, v2;
+    my_space::my_struct v{7, 8, 9}, v2;
     std::string s;
     iguana::to_json(v, s);
     std::cout << s << std::endl;
@@ -159,7 +159,7 @@ struct test_float_t {
   double a;
   float b;
 };
-REFLECTION(test_float_t, a, b);
+YLT_REFL(test_float_t, a, b);
 
 void user_defined_tochars_example() {
   test_float_t t{2.011111, 2.54};
diff --git a/example/xml_example.cpp b/example/xml_example.cpp
index d75f151f..397f2d20 100644
--- a/example/xml_example.cpp
+++ b/example/xml_example.cpp
@@ -1,5 +1,6 @@
 #include <iguana/xml_reader.hpp>
 #include <iguana/xml_writer.hpp>
+#include <iostream>
 
 enum class enum_status {
   start,
@@ -9,7 +10,7 @@ struct child_t {
   int key1;
   int key2;
 };
-REFLECTION(child_t, key1, key2);
+YLT_REFL(child_t, key1, key2);
 struct some_type_t {
   std::vector<float> price;
   std::optional<std::string> description;
@@ -21,8 +22,8 @@ struct some_type_t {
   std::string_view addr;
   enum_status status;
 };
-REFLECTION(some_type_t, price, description, child, hasdescription, c, d_v, name,
-           addr, status);
+YLT_REFL(some_type_t, price, description, child, hasdescription, c, d_v, name,
+         addr, status);
 void some_type_example() {
   std::string str = R"(
 <?xml version="1.0" encoding="UTF-8"?>
@@ -71,11 +72,11 @@ struct book_t {
   std::string title;
   std::string author;
 };
-REFLECTION(book_t, title, author);
+YLT_REFL(book_t, title, author);
 struct library {
   iguana::xml_attr_t<book_t> book;
 };
-REFLECTION(library, book);
+YLT_REFL(library, book);
 
 void lib_example() {
   std::string str = R"(
@@ -121,7 +122,7 @@ struct package_t {
   iguana::xml_attr_t<std::optional<std::string_view>> version;
   iguana::xml_attr_t<std::string_view> changelog;
 };
-REFLECTION(package_t, version, changelog);
+YLT_REFL(package_t, version, changelog);
 void package_example() {
   auto validator = [](iguana::xml_attr_t<package_t> package) {
     assert(package.attr()["name"] == "apr-util-ldap");
@@ -164,7 +165,7 @@ struct derived_t : public base_t {
   int version;
   std::string tag;
 };
-REFLECTION(derived_t, id, name, version, tag);
+YLT_REFL(derived_t, id, name, version, tag);
 
 void derived_object() {
   derived_t d{};
@@ -191,13 +192,13 @@ void derived_object() {
 struct description_t {
   iguana::xml_cdata_t<std::string> cdata;
 };
-REFLECTION(description_t, cdata);
+YLT_REFL(description_t, cdata);
 struct node_t {
   std::string title;
   description_t description;
   iguana::xml_cdata_t<> cdata;
 };
-REFLECTION(node_t, title, description, cdata);
+YLT_REFL(node_t, title, description, cdata);
 void cdata_example() {
   std::string str = R"(
     <node_t>
@@ -232,18 +233,18 @@ struct city_t {
   iguana::xml_cdata_t<> cd;
   std::string name;
 };
-REFLECTION(city_t, area, cd, name);
+YLT_REFL(city_t, area, cd, name);
 struct cities_t {
   std::vector<city_t> city;
 };
-REFLECTION(cities_t, city);
+YLT_REFL(cities_t, city);
 struct province {
   iguana::xml_attr_t<long> area;
   iguana::xml_cdata_t<> cd;
   std::unique_ptr<cities_t> cities;
   std::string capital;
 };
-REFLECTION(province, area, cd, cities, capital);
+YLT_REFL(province, area, cd, cities, capital);
 
 void province_example() {
   std::string_view str = R"(
@@ -286,7 +287,7 @@ struct text_t {
   escape_attr_t ID;
   std::string DisplayName;
 };
-REFLECTION(text_t, ID, DisplayName);
+YLT_REFL(text_t, ID, DisplayName);
 void escape_example() {
   {
     std::string str = R"(
diff --git a/example/yaml_example.cpp b/example/yaml_example.cpp
index 15c93129..5f375a12 100644
--- a/example/yaml_example.cpp
+++ b/example/yaml_example.cpp
@@ -1,5 +1,3 @@
-#include "iguana/yaml_reader.hpp"
-#include "iguana/yaml_writer.hpp"
 #include <cassert>
 #include <deque>
 #include <iostream>
@@ -8,6 +6,9 @@
 #include <optional>
 #include <vector>
 
+#include "iguana/yaml_reader.hpp"
+#include "iguana/yaml_writer.hpp"
+
 enum class enum_status {
   start,
   stop,
@@ -23,8 +24,8 @@ struct some_type_t {
   std::string_view addr;
   enum_status status;
 };
-REFLECTION(some_type_t, price, description, child, hasdescription, c, d_v, name,
-           addr, status);
+YLT_REFL(some_type_t, price, description, child, hasdescription, c, d_v, name,
+         addr, status);
 
 void some_type_example() {
   std::string str = R"(
@@ -65,19 +66,19 @@ struct address_t {
   std::string_view state;
   std::string_view country;
 };
-REFLECTION(address_t, street, city, state, country);
+YLT_REFL(address_t, street, city, state, country);
 struct contact_t {
   std::string_view type;
   std::string_view value;
 };
-REFLECTION(contact_t, type, value);
+YLT_REFL(contact_t, type, value);
 struct person_t {
   std::string_view name;
   int age;
   address_t address;
   std::vector<contact_t> contacts;
 };
-REFLECTION(person_t, name, age, address, contacts);
+YLT_REFL(person_t, name, age, address, contacts);
 
 std::ostream &operator<<(std::ostream &os, person_t p) {
   os << "name: " << p.name << "\tage: " << p.age << std::endl;
@@ -126,7 +127,7 @@ struct map_person_t {
   map_type address;
   std::vector<map_type> contacts;
 };
-REFLECTION(map_person_t, name, age, address, contacts);
+YLT_REFL(map_person_t, name, age, address, contacts);
 void map_person_example() {
   std::string str = R"(
 name: John Doe
@@ -161,17 +162,17 @@ struct product_t {
   float price;
   std::optional<std::string> description;
 };
-REFLECTION(product_t, name, price, description);
+YLT_REFL(product_t, name, price, description);
 struct store_t {
   std::string name;
   std::string_view location;
   std::vector<product_t> products;
 };
-REFLECTION(store_t, name, location, products);
+YLT_REFL(store_t, name, location, products);
 struct store_example_t {
   store_t store;
 };
-REFLECTION(store_example_t, store);
+YLT_REFL(store_example_t, store);
 void store_example() {
   std::string str = R"(
 store:
@@ -212,17 +213,17 @@ struct book_t {
   std::optional<std::string_view> title;
   std::vector<std::string_view> categories;
 };
-REFLECTION(book_t, title, categories);
+YLT_REFL(book_t, title, categories);
 struct library_t {
   std::unique_ptr<std::string_view> name;
   std::string location;
   std::vector<std::unique_ptr<book_t>> books;
 };
-REFLECTION(library_t, name, location, books);
+YLT_REFL(library_t, name, location, books);
 struct library_example_t {
   std::vector<library_t> libraries;
 };
-REFLECTION(library_example_t, libraries);
+YLT_REFL(library_example_t, libraries);
 
 void library_example() {
   std::string str = R"(
@@ -284,7 +285,7 @@ struct movie_t {
   std::optional<int> year;
   std::vector<std::string> actors;
 };
-REFLECTION(movie_t, title, year, actors);
+YLT_REFL(movie_t, title, year, actors);
 void test_tuple_example() {
   std::string str = R"(
 # this is a movie
diff --git a/iguana/common.hpp b/iguana/common.hpp
new file mode 100644
index 00000000..8fcf601a
--- /dev/null
+++ b/iguana/common.hpp
@@ -0,0 +1,281 @@
+#pragma once
+#include <any>
+
+#include "util.hpp"
+
+namespace iguana {
+struct iguana_adl_t {};
+
+namespace detail {
+template <typename T>
+struct identity {};
+
+struct field_info {
+  size_t offset;
+  std::string_view type_name;
+};
+
+struct base {
+  virtual void to_pb(std::string& str) const {}
+  virtual void from_pb(std::string_view str) {}
+  virtual void to_xml(std::string& str) const {}
+  virtual void from_xml(std::string_view str) {}
+  virtual void to_json(std::string& str) const {}
+  virtual void from_json(std::string_view str) {}
+  virtual void to_yaml(std::string& str) const {}
+  virtual void from_yaml(std::string_view str) {}
+  virtual std::vector<std::string_view> get_fields_name() const { return {}; }
+  virtual std::any get_field_any(std::string_view name) const { return {}; }
+  virtual iguana::detail::field_info get_field_info(
+      std::string_view name) const {
+    return {};
+  }
+
+  template <typename T>
+  T& get_field_value(std::string_view name) {
+    auto info = get_field_info(name);
+    check_field<T>(name, info);
+    auto ptr = (((char*)this) + info.offset);
+    return *((T*)ptr);
+  }
+
+  template <typename T, typename FiledType = T>
+  void set_field_value(std::string_view name, T val) {
+    auto info = get_field_info(name);
+    check_field<FiledType>(name, info);
+
+    auto ptr = (((char*)this) + info.offset);
+
+    static_assert(std::is_constructible_v<FiledType, T>, "can not assign");
+
+    *((FiledType*)ptr) = std::move(val);
+  }
+  virtual ~base() {}
+
+ private:
+  template <typename T>
+  void check_field(std::string_view name, const field_info& info) {
+    if (info.offset == 0) {
+      throw std::invalid_argument(std::string(name) + " field not exist ");
+    }
+
+#if defined(__clang__) || defined(_MSC_VER) || \
+    (defined(__GNUC__) && __GNUC__ > 8)
+    if (info.type_name != iguana::type_string<T>()) {
+      std::string str = "type is not match: can not assign ";
+      str.append(iguana::type_string<T>());
+      str.append(" to ").append(info.type_name);
+
+      throw std::invalid_argument(str);
+    }
+#endif
+  }
+};
+
+inline std::unordered_map<std::string_view,
+                          std::function<std::shared_ptr<base>()>>
+    g_pb_map;
+
+template <typename T>
+struct field_type_t;
+
+template <typename... Args>
+struct field_type_t<std::tuple<Args...>> {
+  using value_type = std::variant<Args...>;
+};
+
+template <typename T>
+constexpr size_t count_variant_size() {
+  if constexpr (is_variant<T>::value) {
+    return std::variant_size_v<T>;
+  }
+  else {
+    return 1;
+  }
+}
+
+template <typename T, size_t... I>
+constexpr size_t tuple_type_count_impl(std::index_sequence<I...>) {
+  return (
+      (count_variant_size<member_value_type_t<std::tuple_element_t<I, T>>>() +
+       ...));
+}
+
+template <typename T>
+constexpr size_t tuple_type_count() {
+  return tuple_type_count_impl<T>(
+      std::make_index_sequence<std::tuple_size_v<T>>{});
+}
+
+template <typename T, size_t Size, typename Tuple, size_t... I>
+constexpr auto inline get_members_impl(Tuple&& tp, std::index_sequence<I...>) {
+  return frozen::unordered_map<uint32_t, T, sizeof...(I)>{
+      {std::get<I>(tp).field_no,
+       T{std::in_place_index<I>, std::move(std::get<I>(tp))}}...};
+}
+
+template <typename T, typename = void>
+struct is_custom_reflection : std::false_type {};
+
+template <typename T>
+struct is_custom_reflection<
+    T, std::void_t<decltype(get_members_impl(std::declval<T*>()))>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_custom_reflection_v =
+    is_custom_reflection<ylt::reflection::remove_cvref_t<T>>::value;
+
+// owner_type: parant type, value_type: member value type, SubType: subtype from
+// variant
+template <typename Owner, typename Value, size_t FieldNo,
+          typename ElementType = Value>
+struct pb_field_t {
+  using owner_type = Owner;
+  using value_type = Value;
+  using sub_type = ElementType;
+
+  // constexpr pb_field_t() = default;
+  auto& value(owner_type& value) const {
+    auto member_ptr = (value_type*)((char*)(&value) + offset);
+    return *member_ptr;
+  }
+  // auto const& value(owner_type const& value) const {
+  //   auto member_ptr =
+  //                     (value_type *)((char *)(&value) + offset);
+  //   return *member_ptr;
+  // }
+
+  size_t offset;
+  std::string_view field_name;
+
+  inline static constexpr uint32_t field_no = FieldNo;
+};
+
+template <size_t I, typename ValueType, typename Array>
+constexpr inline auto get_field_no_impl(Array& arr, size_t& index) {
+  arr[I] = index;
+  if constexpr (is_variant<ValueType>::value) {
+    constexpr size_t variant_size = std::variant_size_v<ValueType>;
+    index += (variant_size);
+  }
+  else {
+    index++;
+    return;
+  }
+}
+
+template <typename Tuple, size_t... I>
+inline constexpr auto get_field_no(std::index_sequence<I...>) {
+  std::array<size_t, sizeof...(I)> arr{};
+  size_t index = 0;
+  (get_field_no_impl<
+       I, ylt::reflection::remove_cvref_t<std::tuple_element_t<I, Tuple>>>(
+       arr, index),
+   ...);
+  return arr;
+}
+
+template <typename T, typename value_type, size_t field_no, size_t... I>
+constexpr inline auto build_pb_variant_fields(size_t offset,
+                                              std::string_view name,
+                                              std::index_sequence<I...>) {
+  return std::tuple(
+      pb_field_t<T, value_type, field_no + I + 1,
+                 std::variant_alternative_t<I, value_type>>{offset, name}...);
+}
+
+template <typename T, size_t field_no, typename ValueType>
+constexpr inline auto build_pb_fields_impl(size_t offset,
+                                           std::string_view name) {
+  using value_type = ylt::reflection::remove_cvref_t<ValueType>;
+  using U = std::remove_reference_t<T>;
+
+  if constexpr (is_variant<value_type>::value) {
+    constexpr uint32_t variant_size = std::variant_size_v<value_type>;
+    return build_pb_variant_fields<U, value_type, field_no>(
+        offset, name, std::make_index_sequence<variant_size>{});
+  }
+  else {
+    return std::tuple(pb_field_t<U, value_type, field_no + 1>{offset, name});
+  }
+}
+
+template <typename Tuple, typename T, typename Array, size_t... I>
+inline auto build_pb_fields(const Array& offset_arr,
+                            std::index_sequence<I...>) {
+  constexpr auto arr = ylt::reflection::get_member_names<T>();
+  constexpr std::array<size_t, sizeof...(I)> indexs =
+      get_field_no<Tuple>(std::make_index_sequence<sizeof...(I)>{});
+  return std::tuple_cat(
+      build_pb_fields_impl<T, indexs[I], std::tuple_element_t<I, Tuple>>(
+          offset_arr[I], arr[I])...);
+}
+
+template <typename T>
+inline auto get_pb_members_tuple(T&& t) {
+  using U = ylt::reflection::remove_cvref_t<T>;
+  if constexpr (ylt_refletable_v<U>) {
+    static auto& offset_arr = ylt::reflection::internal::get_member_offset_arr(
+        ylt::reflection::internal::wrapper<U>::value);
+    using Tuple = decltype(ylt::reflection::object_to_tuple(std::declval<U>()));
+    return build_pb_fields<Tuple, T>(
+        offset_arr, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+  }
+  else if constexpr (is_custom_reflection_v<U>) {
+    return get_members_impl((U*)nullptr);
+  }
+  else {
+    static_assert(!sizeof(T), "not a reflectable type");
+  }
+}
+
+template <typename T>
+inline auto get_members(T&& t) {
+  if constexpr (ylt_refletable_v<T> || is_custom_reflection_v<T>) {
+    static auto tp = get_pb_members_tuple(std::forward<T>(t));
+    using Tuple = std::decay_t<decltype(tp)>;
+    using value_type = typename field_type_t<Tuple>::value_type;
+    constexpr auto Size = tuple_type_count<Tuple>();
+    return get_members_impl<value_type, Size>(tp,
+                                              std::make_index_sequence<Size>{});
+  }
+  else {
+    static_assert(!sizeof(T), "expected reflection or custom reflection");
+  }
+}
+}  // namespace detail
+
+template <typename T>
+inline bool register_type() {
+#if defined(__clang__) || defined(_MSC_VER) || \
+    (defined(__GNUC__) && __GNUC__ > 8)
+  if constexpr (std::is_base_of_v<detail::base, T>) {
+    auto it = detail::g_pb_map.emplace(type_string<T>(), [] {
+      return std::make_shared<T>();
+    });
+    return it.second;
+  }
+  else {
+    return true;
+  }
+#else
+  return true;
+#endif
+}
+
+template <typename T, typename U>
+IGUANA_INLINE constexpr size_t member_offset(T* t, U T::*member) {
+  return (char*)&(t->*member) - (char*)t;
+}
+
+template <auto ptr, size_t field_no>
+IGUANA_INLINE auto build_pb_field(std::string_view name) {
+  using owner =
+      typename ylt::reflection::member_traits<decltype(ptr)>::owner_type;
+  using value_type =
+      typename ylt::reflection::member_traits<decltype(ptr)>::value_type;
+  size_t offset = member_offset((owner*)nullptr, ptr);
+  return iguana::detail::pb_field_t<owner, value_type, field_no>{offset, name};
+}
+}  // namespace iguana
\ No newline at end of file
diff --git a/iguana/define.h b/iguana/define.h
index 2887122c..0c0b4485 100644
--- a/iguana/define.h
+++ b/iguana/define.h
@@ -21,7 +21,8 @@
 #define IGUANA__INLINE_LAMBDA constexpr __attribute__((always_inline))
 #endif
 
-#if __has_cpp_attribute(likely) && __has_cpp_attribute(unlikely)
+#if __has_cpp_attribute(likely) && __has_cpp_attribute(unlikely) && \
+    __cplusplus >= 202002L
 #define IGUANA_LIKELY [[likely]]
 #define IGUANA_UNLIKELY [[unlikely]]
 #else
diff --git a/iguana/detail/pb_type.hpp b/iguana/detail/pb_type.hpp
index 2d17cb8e..d9a2c791 100644
--- a/iguana/detail/pb_type.hpp
+++ b/iguana/detail/pb_type.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include <cstdint>
 #include <type_traits>
 
 namespace iguana {
diff --git a/iguana/detail/traits.hpp b/iguana/detail/traits.hpp
index 57a9fa45..a62d3238 100644
--- a/iguana/detail/traits.hpp
+++ b/iguana/detail/traits.hpp
@@ -11,6 +11,7 @@
 #include <queue>
 #include <type_traits>
 #include <unordered_map>
+#include <variant>
 #include <vector>
 
 #include "iguana/define.h"
diff --git a/iguana/dynamic.hpp b/iguana/dynamic.hpp
index 4b479b0c..47cf2015 100644
--- a/iguana/dynamic.hpp
+++ b/iguana/dynamic.hpp
@@ -1,14 +1,9 @@
 #pragma once
-#include "reflection.hpp"
+#include "common.hpp"
 
 namespace iguana {
 using base = detail::base;
 
-template <typename T, typename U>
-IGUANA_INLINE constexpr size_t member_offset(T* t, U T::*member) {
-  return (char*)&(t->*member) - (char*)t;
-}
-
 constexpr inline uint8_t ENABLE_JSON = 0x01;
 constexpr inline uint8_t ENABLE_YAML = 0x02;
 constexpr inline uint8_t ENABLE_XML = 0x04;
@@ -17,6 +12,7 @@ constexpr inline uint8_t ENABLE_ALL = 0x0F;
 
 template <typename T, uint8_t ENABLE_FLAG = ENABLE_PB>
 struct base_impl : public base {
+  base_impl() { [[maybe_unused]] static bool r = register_type<T>(); }
   void to_pb(std::string& str) const override {
     if constexpr ((ENABLE_FLAG & ENABLE_PB) != 0) {
       to_pb_adl((iguana_adl_t*)nullptr, *(static_cast<T const*>(this)), str);
@@ -91,7 +87,8 @@ struct base_impl : public base {
 
   iguana::detail::field_info get_field_info(
       std::string_view name) const override {
-    static constexpr auto map = iguana::get_members<T>();
+    static auto map =
+        detail::get_members(ylt::reflection::internal::wrapper<T>::value);
     iguana::detail::field_info info{};
     for (auto const& [no, field] : map) {
       if (info.offset > 0) {
@@ -100,7 +97,7 @@ struct base_impl : public base {
       std::visit(
           [&](auto const& val) {
             if (val.field_name == name) {
-              info.offset = member_offset((T*)this, val.member_ptr);
+              info.offset = val.offset;
               using value_type =
                   typename std::remove_reference_t<decltype(val)>::value_type;
 #if defined(__clang__) || defined(_MSC_VER) || \
@@ -116,7 +113,8 @@ struct base_impl : public base {
   }
 
   std::vector<std::string_view> get_fields_name() const override {
-    static constexpr auto map = iguana::get_members<T>();
+    static auto map =
+        detail::get_members(ylt::reflection::internal::wrapper<T>::value);
 
     std::vector<std::string_view> vec;
 
@@ -135,7 +133,8 @@ struct base_impl : public base {
   }
 
   std::any get_field_any(std::string_view name) const override {
-    static constexpr auto map = iguana::get_members<T>();
+    static auto map =
+        detail::get_members(ylt::reflection::internal::wrapper<T>::value);
     std::any result;
 
     for (auto const& [no, field] : map) {
@@ -147,8 +146,7 @@ struct base_impl : public base {
             if (val.field_name == name) {
               using value_type =
                   typename std::remove_reference_t<decltype(val)>::value_type;
-              auto const offset = member_offset((T*)this, val.member_ptr);
-              auto ptr = (char*)this + offset;
+              auto ptr = (char*)this + val.offset;
               result = *((value_type*)ptr);
             }
           },
diff --git a/iguana/json_reader.hpp b/iguana/json_reader.hpp
index d433f017..765815fe 100644
--- a/iguana/json_reader.hpp
+++ b/iguana/json_reader.hpp
@@ -4,9 +4,18 @@
 #include "json_util.hpp"
 namespace iguana {
 
-template <typename T, typename It, std::enable_if_t<refletable_v<T>, int> = 0>
+template <typename T, typename It,
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_json(T &value, It &&it, It &&end);
 
+template <typename T, typename View,
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
+IGUANA_INLINE void from_json(T &value, const View &view);
+
+template <typename T, typename View,
+          std::enable_if_t<non_ylt_refletable_v<T>, int> = 0>
+IGUANA_INLINE void from_json(T &value, const View &view);
+
 namespace detail {
 
 template <typename U, typename It,
@@ -16,7 +25,8 @@ IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end);
 template <typename U, typename It, std::enable_if_t<smart_ptr_v<U>, int> = 0>
 IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end);
 
-template <typename U, typename It, std::enable_if_t<refletable_v<U>, int> = 0>
+template <typename U, typename It,
+          std::enable_if_t<ylt_refletable_v<U>, int> = 0>
 IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
   from_json(value, it, end);
 }
@@ -86,10 +96,10 @@ IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
   }
 }
 
-template <typename U, typename It, std::enable_if_t<is_pb_type_v<U>, int> = 0>
-IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
-  from_json_impl(value.val, it, end);
-}
+// template <typename U, typename It, std::enable_if_t<is_pb_type_v<U>, int> =
+// 0> IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
+//   from_json_impl(value.val, it, end);
+// }
 
 template <typename U, typename It, std::enable_if_t<numeric_str_v<U>, int> = 0>
 IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
@@ -404,18 +414,20 @@ IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
   match<'['>(it, end);
   skip_ws(it, end);
 
-  for_each(value, [&](auto &v, auto i) IGUANA__INLINE_LAMBDA {
-    constexpr auto I = decltype(i)::value;
-    if (it == end || *it == ']') {
-      return;
-    }
-    if constexpr (I != 0) {
-      match<','>(it, end);
-      skip_ws(it, end);
-    }
-    from_json_impl(v, it, end);
-    skip_ws(it, end);
-  });
+  foreach_tuple(
+      [&](auto &v, auto i) IGUANA__INLINE_LAMBDA {
+        constexpr auto I = decltype(i)::value;
+        if (it == end || *it == ']') {
+          return;
+        }
+        if constexpr (I != 0) {
+          match<','>(it, end);
+          skip_ws(it, end);
+        }
+        from_json_impl(v, it, end);
+        skip_ws(it, end);
+      },
+      value);
 
   match<']'>(it, end);
 }
@@ -542,7 +554,7 @@ IGUANA_INLINE void from_json_impl(U &value, It &&it, It &&end) {
 }
 }  // namespace detail
 
-template <typename T, typename It, std::enable_if_t<refletable_v<T>, int>>
+template <typename T, typename It, std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void from_json(T &value, It &&it, It &&end) {
   skip_ws(it, end);
   match<'{'>(it, end);
@@ -553,80 +565,80 @@ IGUANA_INLINE void from_json(T &value, It &&it, It &&end) {
       ++it;
       return;
     }
-  std::string_view key = detail::get_key(it, end);
+  using U = ylt::reflection::remove_cvref_t<T>;
+  constexpr auto Count = ylt::reflection::members_count_v<U>;
+  if constexpr (Count > 0) {
+    std::string_view key = detail::get_key(it, end);
 #ifdef SEQUENTIAL_PARSE
-  bool parse_done = false;
-  for_each(value, [&](const auto member_ptr, auto i) IGUANA__INLINE_LAMBDA {
-    constexpr auto mkey = iguana::get_name<T, decltype(i)::value>();
-    constexpr std::string_view st_key(mkey.data(), mkey.size());
-    if (parse_done || (key != st_key))
-      IGUANA_UNLIKELY { return; }
-    skip_ws(it, end);
-    match<':'>(it, end);
-    {
-      using namespace detail;
-      from_json_impl(value.*member_ptr, it, end);
+    bool parse_done = false;
+    ylt::reflection::for_each(
+        value, [&](auto &field, auto name, auto index) IGUANA__INLINE_LAMBDA {
+          if (parse_done || (key != name))
+            IGUANA_UNLIKELY { return; }
+          skip_ws(it, end);
+          match<':'>(it, end);
+          {
+            using namespace detail;
+            from_json_impl(field, it, end);
+          }
+
+          skip_ws(it, end);
+          if (*it == '}')
+            IGUANA_UNLIKELY {
+              ++it;
+              parse_done = true;
+              return;
+            }
+          else
+            IGUANA_LIKELY { match<','>(it, end); }
+          key = detail::get_key(it, end);
+        });
+    if (parse_done) [[unlikely]] {
+      return;
     }
-
-    skip_ws(it, end);
-    if (*it == '}')
-      IGUANA_UNLIKELY {
-        ++it;
-        parse_done = true;
-        return;
-      }
-    else
-      IGUANA_LIKELY { match<','>(it, end); }
-    key = detail::get_key(it, end);
-  });
-  if (parse_done) [[unlikely]] {
-    return;
-  }
 #endif
-  while (it != end) {
-    static constexpr auto frozen_map = get_iguana_struct_map<T>();
-    if constexpr (frozen_map.size() > 0) {
-      const auto &member_it = frozen_map.find(key);
-      skip_ws(it, end);
-      match<':'>(it, end);
-      if (member_it != frozen_map.end())
-        IGUANA_LIKELY {
-          std::visit(
-              [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
-                using V = std::decay_t<decltype(member_ptr)>;
-                if constexpr (std::is_member_pointer_v<V>) {
+    while (it != end) {
+      static auto frozen_map = ylt::reflection::get_variant_map<U>();
+      if (frozen_map.size() > 0) {
+        const auto &member_it = frozen_map.find(key);
+        skip_ws(it, end);
+        match<':'>(it, end);
+        if (member_it != frozen_map.end())
+          IGUANA_LIKELY {
+            std::visit(
+                [&](auto offset) IGUANA__INLINE_LAMBDA {
                   using namespace detail;
-                  from_json_impl(value.*member_ptr, it, end);
-                }
-                else {
-                  static_assert(!sizeof(V), "type not supported");
-                }
-              },
-              member_it->second);
-        }
-      else
-        IGUANA_UNLIKELY {
+                  using value_type = typename decltype(offset)::type;
+                  auto member_ptr =
+                      (value_type *)((char *)(&value) + offset.value);
+                  from_json_impl(*member_ptr, it, end);
+                },
+                member_it->second);
+          }
+        else
+          IGUANA_UNLIKELY {
 #ifdef THROW_UNKNOWN_KEY
-          throw std::runtime_error("Unknown key: " + std::string(key));
+            throw std::runtime_error("Unknown key: " + std::string(key));
 #else
-          detail::skip_object_value(it, end);
+            detail::skip_object_value(it, end);
 #endif
+          }
+      }
+      skip_ws(it, end);
+      if (*it == '}')
+        IGUANA_UNLIKELY {
+          ++it;
+          return;
         }
+      else
+        IGUANA_LIKELY { match<','>(it, end); }
+      key = detail::get_key(it, end);
     }
-    skip_ws(it, end);
-    if (*it == '}')
-      IGUANA_UNLIKELY {
-        ++it;
-        return;
-      }
-    else
-      IGUANA_LIKELY { match<','>(it, end); }
-    key = detail::get_key(it, end);
   }
 }
 
 template <typename T, typename It,
-          std::enable_if_t<non_refletable_v<T>, int> = 0>
+          std::enable_if_t<non_ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_json(T &value, It &&it, It &&end) {
   using namespace detail;
   from_json_impl(value, it, end);
@@ -643,35 +655,15 @@ IGUANA_INLINE void from_json(T &value, It &&it, It &&end,
   }
 }
 
-template <typename T, typename View,
-          std::enable_if_t<json_view_v<View>, int> = 0>
+template <typename T, typename View, std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void from_json(T &value, const View &view) {
   from_json(value, std::begin(view), std::end(view));
 }
 
-template <
-    auto member,
-    typename Parant = typename member_tratis<decltype(member)>::owner_type,
-    typename T>
-IGUANA_INLINE void from_json(T &value, std::string_view str) {
-  constexpr size_t duplicate_count =
-      iguana::duplicate_count<std::remove_reference_t<Parant>, member>();
-  static_assert(duplicate_count != 1, "the member is not belong to the object");
-  static_assert(duplicate_count == 2, "has duplicate field name");
-
-  constexpr auto name = name_of<member>();
-  constexpr size_t index = index_of<member>();
-  constexpr size_t member_count = member_count_of<member>();
-  str = str.substr(str.find(name) + name.size());
-  size_t pos = str.find(":") + 1;
-  if constexpr (index == member_count - 1) {  // last field
-    str = str.substr(pos, str.find("}") - pos + 1);
-  }
-  else {
-    str = str.substr(pos, str.find(",") - pos);
-  }
-
-  detail::from_json_impl(value.*member, std::begin(str), std::end(str));
+template <typename T, typename View,
+          std::enable_if_t<non_ylt_refletable_v<T>, int>>
+IGUANA_INLINE void from_json(T &value, const View &view) {
+  from_json(value, std::begin(view), std::end(view));
 }
 
 template <typename T, typename View,
diff --git a/iguana/json_util.hpp b/iguana/json_util.hpp
index 5887599f..e5c51d31 100644
--- a/iguana/json_util.hpp
+++ b/iguana/json_util.hpp
@@ -3,7 +3,8 @@
 
 #pragma once
 
-#include "detail/pb_type.hpp"
+#include "common.hpp"
+#include "detail/string_stream.hpp"
 #include "util.hpp"
 #include "value.hpp"
 
diff --git a/iguana/json_writer.hpp b/iguana/json_writer.hpp
index 498e0a2d..1901d565 100644
--- a/iguana/json_writer.hpp
+++ b/iguana/json_writer.hpp
@@ -9,7 +9,7 @@
 namespace iguana {
 
 template <bool Is_writing_escape = true, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_json(T &&t, Stream &s);
 namespace detail {
 template <bool Is_writing_escape = true, typename Stream, typename T>
@@ -76,11 +76,11 @@ IGUANA_INLINE void to_json_impl(Stream &ss, T value) {
   ss.append(temp, p - temp);
 }
 
-template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<is_pb_type_v<T>, int> = 0>
-IGUANA_INLINE void to_json_impl(Stream &ss, T value) {
-  to_json_impl<Is_writing_escape>(ss, value.val);
-}
+// template <bool Is_writing_escape, typename Stream, typename T,
+//           std::enable_if_t<is_pb_type_v<T>, int> = 0>
+// IGUANA_INLINE void to_json_impl(Stream &ss, T value) {
+//   to_json_impl<Is_writing_escape>(ss, value.val);
+// }
 
 template <bool Is_writing_escape, typename Stream, typename T,
           std::enable_if_t<numeric_str_v<T>, int> = 0>
@@ -109,11 +109,11 @@ IGUANA_INLINE void render_key(Stream &ss, const T &t) {
   ss.push_back('"');
 }
 
-template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<is_pb_type_v<T>, int> = 0>
-IGUANA_INLINE void render_key(Stream &ss, const T &t) {
-  render_key<Is_writing_escape>(ss, t.val);
-}
+// template <bool Is_writing_escape, typename Stream, typename T,
+//           std::enable_if_t<is_pb_type_v<T>, int> = 0>
+// IGUANA_INLINE void render_key(Stream &ss, const T &t) {
+//   render_key<Is_writing_escape>(ss, t.val);
+// }
 
 template <bool Is_writing_escape, typename Stream, typename T,
           std::enable_if_t<string_container_v<T>, int> = 0>
@@ -122,7 +122,7 @@ IGUANA_INLINE void render_key(Stream &ss, T &&t) {
 }
 
 template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_json_impl(Stream &ss, T &&t) {
   to_json(std::forward<T>(t), ss);
 }
@@ -218,11 +218,9 @@ IGUANA_INLINE void to_json_impl(Stream &ss, const T &v) {
   ss.push_back(']');
 }
 
-constexpr auto write_json_key = [](auto &s, auto i,
-                                   auto &t) IGUANA__INLINE_LAMBDA {
+constexpr auto write_json_key = [](auto &s, auto name) IGUANA__INLINE_LAMBDA {
   s.push_back('"');
   // will be replaced by string_view later
-  constexpr auto name = get_name<decltype(t), decltype(i)::value>();
   s.append(name.data(), name.size());
   s.push_back('"');
 };
@@ -244,13 +242,14 @@ IGUANA_INLINE void to_json_impl(Stream &s, T &&t) {
   using U = typename std::decay_t<T>;
   s.push_back('[');
   constexpr size_t size = std::tuple_size_v<U>;
-  for_each(std::forward<T>(t),
-           [&s, size](auto &v, auto i) IGUANA__INLINE_LAMBDA {
-             to_json_impl<Is_writing_escape>(s, v);
+  foreach_tuple(
+      [&s, size](auto &v, auto i) IGUANA__INLINE_LAMBDA {
+        to_json_impl<Is_writing_escape>(s, v);
 
-             if (i != size - 1)
-               IGUANA_LIKELY { s.push_back(','); }
-           });
+        if (i != size - 1)
+          IGUANA_LIKELY { s.push_back(','); }
+      },
+      std::forward<T>(t));
   s.push_back(']');
 }
 
@@ -267,28 +266,27 @@ IGUANA_INLINE void to_json_impl(Stream &s, T &&t) {
 }
 }  // namespace detail
 template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int>>
+          std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void to_json(T &&t, Stream &s) {
   using namespace detail;
   s.push_back('{');
-  for_each(std::forward<T>(t),
-           [&t, &s](const auto &v, auto i) IGUANA__INLINE_LAMBDA {
-             using M = decltype(iguana_reflect_type(std::forward<T>(t)));
-             constexpr auto Idx = decltype(i)::value;
-             constexpr auto Count = M::value();
-             static_assert(Idx < Count);
-
-             write_json_key(s, i, t);
-             s.push_back(':');
-             to_json_impl<Is_writing_escape>(s, t.*v);
-             if (Idx < Count - 1)
-               IGUANA_LIKELY { s.push_back(','); }
-           });
+  using U = ylt::reflection::remove_cvref_t<T>;
+  constexpr auto Count = ylt::reflection::members_count_v<U>;
+  if constexpr (Count > 0) {
+    ylt::reflection::for_each(t, [&](auto &field, auto name, auto index) {
+      write_json_key(s, name);
+      s.push_back(':');
+      to_json_impl<Is_writing_escape>(s, field);
+      if (index < Count - 1)
+        IGUANA_LIKELY { s.push_back(','); }
+    });
+  }
+
   s.push_back('}');
 }
 
 template <bool Is_writing_escape = true, typename Stream, typename T,
-          std::enable_if_t<non_refletable_v<T>, int> = 0>
+          std::enable_if_t<non_ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_json(T &&t, Stream &s) {
   using namespace detail;
   to_json_impl<Is_writing_escape>(s, t);
diff --git a/iguana/pb_reader.hpp b/iguana/pb_reader.hpp
index 83d2425d..a91a6969 100644
--- a/iguana/pb_reader.hpp
+++ b/iguana/pb_reader.hpp
@@ -27,7 +27,7 @@ template <typename T>
 IGUANA_INLINE void from_pb_impl(T& val, std::string_view& pb_str,
                                 uint32_t field_no) {
   size_t pos = 0;
-  if constexpr (is_reflection_v<T>) {
+  if constexpr (ylt_refletable_v<T>) {
     size_t pos;
     uint32_t size = detail::decode_varint(pb_str, pos);
     pb_str = pb_str.substr(pos);
@@ -191,14 +191,16 @@ IGUANA_INLINE void from_pb(T& t, std::string_view pb_str) {
   WireType wire_type = static_cast<WireType>(key & 0b0111);
   uint32_t field_number = key >> 3;
 #ifdef SEQUENTIAL_PARSE
-  constexpr static auto tp = get_members_tuple<T>();
+  static auto tp = detail::get_pb_members_tuple(t);
   constexpr size_t SIZE = std::tuple_size_v<std::decay_t<decltype(tp)>>;
   bool parse_done = false;
+  auto ptr = &t;
   detail::for_each_n(
-      [&](auto i) IGUANA__INLINE_LAMBDA {
-        constexpr auto val = std::get<decltype(i)::value>(tp);
+      [&, ptr](auto i) IGUANA__INLINE_LAMBDA {
+        auto val = std::get<decltype(i)::value>(tp);
         using sub_type = typename std::decay_t<decltype(val)>::sub_type;
         using value_type = typename std::decay_t<decltype(val)>::value_type;
+        constexpr bool is_variant_v = variant_v<value_type>;
         // sub_type is the element type when value_type is the variant type;
         // otherwise, they are the same.
         if (parse_done || field_number != val.field_no) {
@@ -207,11 +209,13 @@ IGUANA_INLINE void from_pb(T& t, std::string_view pb_str) {
         pb_str = pb_str.substr(pos);
         if (wire_type != detail::get_wire_type<sub_type>())
           IGUANA_UNLIKELY { throw std::runtime_error("unmatched wire_type"); }
-        if constexpr (variant_v<value_type>) {
-          detail::parse_oneof(val.value(t), val, pb_str);
+
+        auto member_ptr = (value_type*)((char*)(ptr) + val.offset);
+        if constexpr (is_variant_v) {
+          detail::parse_oneof(*member_ptr, val, pb_str);
         }
         else {
-          detail::from_pb_impl(val.value(t), pb_str, val.field_no);
+          detail::from_pb_impl(*member_ptr, pb_str, val.field_no);
         }
         if (pb_str.empty()) {
           parse_done = true;
@@ -227,7 +231,7 @@ IGUANA_INLINE void from_pb(T& t, std::string_view pb_str) {
 #endif
   while (true) {
     pb_str = pb_str.substr(pos);
-    constexpr static auto map = get_members<T>();
+    static auto map = detail::get_members(std::forward<T>(t));
     auto& member = map.at(field_number);
     std::visit(
         [&t, &pb_str, wire_type](auto& val) {
diff --git a/iguana/pb_util.hpp b/iguana/pb_util.hpp
index 27bc9a89..bd8d5faa 100644
--- a/iguana/pb_util.hpp
+++ b/iguana/pb_util.hpp
@@ -13,8 +13,8 @@
 #include <variant>
 #include <vector>
 
+#include "common.hpp"
 #include "detail/pb_type.hpp"
-#include "reflection.hpp"
 #include "util.hpp"
 
 namespace iguana {
@@ -60,7 +60,7 @@ constexpr inline WireType get_wire_type() {
   }
   else if constexpr (std::is_same_v<T, std::string> ||
                      std::is_same_v<T, std::string_view> ||
-                     is_reflection_v<T> || is_sequence_container<T>::value ||
+                     ylt_refletable_v<T> || is_sequence_container<T>::value ||
                      is_map_container<T>::value) {
     return WireType::LengthDelimeted;
   }
@@ -439,9 +439,9 @@ IGUANA_INLINE size_t pb_oneof_size(Type&& t, Arr& size_arr) {
 template <size_t key_size, bool omit_default_val, typename Type, typename Arr>
 IGUANA_INLINE size_t pb_key_value_size(Type&& t, Arr& size_arr) {
   using T = std::remove_const_t<std::remove_reference_t<Type>>;
-  if constexpr (is_reflection_v<T> || is_custom_reflection_v<T>) {
+  if constexpr (ylt_refletable_v<T>) {
     size_t len = 0;
-    static constexpr auto tuple = get_members_tuple<T>();
+    static auto tuple = get_pb_members_tuple(std::forward<Type>(t));
     constexpr size_t SIZE = std::tuple_size_v<std::decay_t<decltype(tuple)>>;
     size_t pre_index = -1;
     if constexpr (!inherits_from_base_v<T> && key_size != 0) {
@@ -453,13 +453,13 @@ IGUANA_INLINE size_t pb_key_value_size(Type&& t, Arr& size_arr) {
           using field_type =
               std::tuple_element_t<decltype(i)::value,
                                    std::decay_t<decltype(tuple)>>;
-          constexpr auto value = std::get<decltype(i)::value>(tuple);
+          auto value = std::get<decltype(i)::value>(tuple);
           using U = typename field_type::value_type;
-          auto const& val = value.value(t);
+          using sub_type = typename field_type::sub_type;
+          auto& val = value.value(t);
           if constexpr (variant_v<U>) {
             constexpr auto offset =
-                get_variant_index<U, typename field_type::sub_type,
-                                  std::variant_size_v<U> - 1>();
+                get_variant_index<U, sub_type, std::variant_size_v<U> - 1>();
             if constexpr (offset == 0) {
               len += pb_oneof_size<value.field_no>(val, size_arr);
             }
@@ -541,7 +541,7 @@ IGUANA_INLINE size_t pb_key_value_size(Type&& t, Arr& size_arr) {
 template <bool skip_next = true, typename Type>
 IGUANA_INLINE size_t pb_value_size(Type&& t, uint32_t*& sz_ptr) {
   using T = std::remove_const_t<std::remove_reference_t<Type>>;
-  if constexpr (is_reflection_v<T> || is_custom_reflection_v<T>) {
+  if constexpr (ylt_refletable_v<T> || is_custom_reflection_v<T>) {
     if constexpr (inherits_from_base_v<T>) {
       return t.cache_size;
     }
diff --git a/iguana/pb_writer.hpp b/iguana/pb_writer.hpp
index 219650fb..b40fbf72 100644
--- a/iguana/pb_writer.hpp
+++ b/iguana/pb_writer.hpp
@@ -100,7 +100,7 @@ IGUANA_INLINE void to_pb_oneof(Type&& t, It&& it, uint32_t*& sz_ptr) {
 template <uint32_t key, bool omit_default_val, typename Type, typename It>
 IGUANA_INLINE void to_pb_impl(Type&& t, It&& it, uint32_t*& sz_ptr) {
   using T = std::remove_const_t<std::remove_reference_t<Type>>;
-  if constexpr (is_reflection_v<T> || is_custom_reflection_v<T>) {
+  if constexpr (ylt_refletable_v<T> || is_custom_reflection_v<T>) {
     // can't be omitted even if values are empty
     if constexpr (key != 0) {
       auto len = pb_value_size(t, sz_ptr);
@@ -109,21 +109,21 @@ IGUANA_INLINE void to_pb_impl(Type&& t, It&& it, uint32_t*& sz_ptr) {
       if (len == 0)
         IGUANA_UNLIKELY { return; }
     }
-    static constexpr auto tuple = get_members_tuple<T>();
+    static auto tuple = get_pb_members_tuple(std::forward<Type>(t));
     constexpr size_t SIZE = std::tuple_size_v<std::decay_t<decltype(tuple)>>;
     for_each_n(
         [&t, &it, &sz_ptr](auto i) IGUANA__INLINE_LAMBDA {
           using field_type =
               std::tuple_element_t<decltype(i)::value,
                                    std::decay_t<decltype(tuple)>>;
-          constexpr auto value = std::get<decltype(i)::value>(tuple);
+          auto value = std::get<decltype(i)::value>(tuple);
           auto& val = value.value(t);
 
           using U = typename field_type::value_type;
+          using sub_type = typename field_type::sub_type;
           if constexpr (variant_v<U>) {
             constexpr auto offset =
-                get_variant_index<U, typename field_type::sub_type,
-                                  std::variant_size_v<U> - 1>();
+                get_variant_index<U, sub_type, std::variant_size_v<U> - 1>();
             if constexpr (offset == 0) {
               to_pb_oneof<value.field_no>(val, it, sz_ptr);
             }
@@ -297,10 +297,11 @@ IGUANA_INLINE void to_proto_impl(
     std::string_view field_name = "", uint32_t field_no = 0) {
   std::string sub_str;
   using T = std::remove_const_t<std::remove_reference_t<Type>>;
-  if constexpr (is_reflection_v<T> || is_custom_reflection_v<T>) {
-    constexpr auto name = get_name<T>();
+  if constexpr (ylt_refletable_v<T> || is_custom_reflection_v<T>) {
+    constexpr auto name = type_string<T>();
     out.append("message ").append(name).append(" {\n");
-    static constexpr auto tuple = get_members_tuple<T>();
+    static T t;
+    static auto tuple = get_pb_members_tuple(t);
     constexpr size_t SIZE = std::tuple_size_v<std::decay_t<decltype(tuple)>>;
 
     for_each_n(
@@ -308,10 +309,11 @@ IGUANA_INLINE void to_proto_impl(
           using field_type =
               std::tuple_element_t<decltype(i)::value,
                                    std::decay_t<decltype(tuple)>>;
-          constexpr auto value = std::get<decltype(i)::value>(tuple);
+          auto value = std::get<decltype(i)::value>(tuple);
 
           using U = typename field_type::value_type;
-          if constexpr (is_reflection_v<U>) {
+          using sub_type = typename field_type::sub_type;
+          if constexpr (ylt_refletable_v<U>) {
             constexpr auto str_type = get_type_string<U>();
             build_proto_field(
                 out, str_type,
@@ -322,7 +324,6 @@ IGUANA_INLINE void to_proto_impl(
           }
           else if constexpr (variant_v<U>) {
             constexpr size_t var_size = std::variant_size_v<U>;
-            using sub_type = typename field_type::sub_type;
 
             constexpr auto offset =
                 get_variant_index<U, sub_type, var_size - 1>();
@@ -340,7 +341,7 @@ IGUANA_INLINE void to_proto_impl(
             out.append("  ");
             build_proto_field(out, str_type, field_name, value.field_no);
 
-            if constexpr (is_reflection_v<sub_type>) {
+            if constexpr (ylt_refletable_v<sub_type>) {
               build_sub_proto<sub_type>(map, str_type, sub_str);
             }
 
@@ -363,7 +364,7 @@ IGUANA_INLINE void to_proto_impl(
 
     if constexpr (is_lenprefix_v<item_type>) {
       // non-packed
-      if constexpr (is_reflection_v<item_type>) {
+      if constexpr (ylt_refletable_v<item_type>) {
         constexpr auto str_type = get_type_string<item_type>();
         build_proto_field(out, str_type, field_name, field_no);
 
@@ -389,7 +390,7 @@ IGUANA_INLINE void to_proto_impl(
 
     build_proto_field<1>(out, "", field_name, field_no);
 
-    if constexpr (is_reflection_v<second_type>) {
+    if constexpr (ylt_refletable_v<second_type>) {
       constexpr auto str_type = get_type_string<second_type>();
       build_sub_proto<second_type>(map, str_type, sub_str);
     }
@@ -449,7 +450,8 @@ IGUANA_INLINE void build_sub_proto(Map& map, std::string_view str_type,
 #endif
 }  // namespace detail
 
-template <typename T, typename Stream>
+template <typename T, typename Stream,
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_pb(T const& t, Stream& out) {
   std::vector<uint32_t> size_arr;
   auto byte_len = detail::pb_key_value_size<0>(t, size_arr);
diff --git a/iguana/reflection.hpp b/iguana/reflection.hpp
deleted file mode 100644
index 474e27fa..00000000
--- a/iguana/reflection.hpp
+++ /dev/null
@@ -1,1349 +0,0 @@
-//
-// Created by Qiyu on 17-6-5.
-//
-
-#ifndef IGUANA_REFLECTION_HPP
-#define IGUANA_REFLECTION_HPP
-#include <any>
-#include <array>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
-#include <variant>
-#include <vector>
-
-#include "detail/string_stream.hpp"
-#include "detail/traits.hpp"
-#include "field_reflection.hpp"
-#include "frozen/string.h"
-#include "frozen/unordered_map.h"
-
-namespace iguana::detail {
-/******************************************/
-/* arg list expand macro, now support 120 args */
-#define MAKE_ARG_LIST_1(op, arg, ...) op(arg)
-#define MAKE_ARG_LIST_2(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_1(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_3(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_2(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_4(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_3(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_5(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_4(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_6(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_5(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_7(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_6(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_8(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_7(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_9(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_8(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_10(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_9(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_11(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_10(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_12(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_11(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_13(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_12(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_14(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_13(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_15(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_14(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_16(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_15(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_17(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_16(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_18(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_17(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_19(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_18(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_20(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_19(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_21(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_20(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_22(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_21(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_23(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_22(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_24(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_23(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_25(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_24(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_26(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_25(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_27(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_26(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_28(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_27(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_29(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_28(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_30(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_29(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_31(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_30(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_32(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_31(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_33(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_32(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_34(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_33(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_35(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_34(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_36(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_35(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_37(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_36(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_38(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_37(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_39(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_38(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_40(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_39(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_41(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_40(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_42(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_41(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_43(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_42(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_44(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_43(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_45(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_44(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_46(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_45(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_47(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_46(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_48(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_47(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_49(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_48(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_50(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_49(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_51(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_50(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_52(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_51(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_53(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_52(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_54(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_53(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_55(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_54(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_56(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_55(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_57(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_56(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_58(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_57(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_59(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_58(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_60(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_59(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_61(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_60(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_62(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_61(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_63(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_62(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_64(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_63(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_65(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_64(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_66(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_65(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_67(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_66(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_68(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_67(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_69(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_68(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_70(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_69(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_71(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_70(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_72(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_71(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_73(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_72(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_74(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_73(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_75(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_74(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_76(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_75(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_77(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_76(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_78(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_77(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_79(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_78(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_80(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_79(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_81(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_80(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_82(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_81(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_83(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_82(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_84(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_83(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_85(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_84(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_86(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_85(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_87(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_86(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_88(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_87(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_89(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_88(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_90(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_89(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_91(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_90(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_92(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_91(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_93(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_92(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_94(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_93(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_95(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_94(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_96(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_95(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_97(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_96(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_98(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_97(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_99(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_98(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_100(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_99(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_101(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_100(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_102(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_101(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_103(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_102(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_104(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_103(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_105(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_104(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_106(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_105(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_107(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_106(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_108(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_107(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_109(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_108(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_110(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_109(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_111(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_110(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_112(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_111(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_113(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_112(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_114(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_113(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_115(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_114(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_116(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_115(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_117(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_116(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_118(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_117(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_119(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_118(op, __VA_ARGS__))
-#define MAKE_ARG_LIST_120(op, arg, ...) \
-  op(arg), MARCO_EXPAND(MAKE_ARG_LIST_119(op, __VA_ARGS__))
-
-#define ADD_VIEW(str) std::string_view(#str, sizeof(#str) - 1)
-
-#define SEPERATOR ,
-#define CON_STR_1(element, ...) ADD_VIEW(element)
-#define CON_STR_2(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_1(__VA_ARGS__))
-#define CON_STR_3(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_2(__VA_ARGS__))
-#define CON_STR_4(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_3(__VA_ARGS__))
-#define CON_STR_5(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_4(__VA_ARGS__))
-#define CON_STR_6(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_5(__VA_ARGS__))
-#define CON_STR_7(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_6(__VA_ARGS__))
-#define CON_STR_8(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_7(__VA_ARGS__))
-#define CON_STR_9(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_8(__VA_ARGS__))
-#define CON_STR_10(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_9(__VA_ARGS__))
-#define CON_STR_11(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_10(__VA_ARGS__))
-#define CON_STR_12(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_11(__VA_ARGS__))
-#define CON_STR_13(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_12(__VA_ARGS__))
-#define CON_STR_14(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_13(__VA_ARGS__))
-#define CON_STR_15(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_14(__VA_ARGS__))
-#define CON_STR_16(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_15(__VA_ARGS__))
-#define CON_STR_17(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_16(__VA_ARGS__))
-#define CON_STR_18(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_17(__VA_ARGS__))
-#define CON_STR_19(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_18(__VA_ARGS__))
-#define CON_STR_20(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_19(__VA_ARGS__))
-#define CON_STR_21(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_20(__VA_ARGS__))
-#define CON_STR_22(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_21(__VA_ARGS__))
-#define CON_STR_23(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_22(__VA_ARGS__))
-#define CON_STR_24(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_23(__VA_ARGS__))
-#define CON_STR_25(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_24(__VA_ARGS__))
-#define CON_STR_26(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_25(__VA_ARGS__))
-#define CON_STR_27(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_26(__VA_ARGS__))
-#define CON_STR_28(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_27(__VA_ARGS__))
-#define CON_STR_29(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_28(__VA_ARGS__))
-#define CON_STR_30(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_29(__VA_ARGS__))
-#define CON_STR_31(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_30(__VA_ARGS__))
-#define CON_STR_32(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_31(__VA_ARGS__))
-#define CON_STR_33(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_32(__VA_ARGS__))
-#define CON_STR_34(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_33(__VA_ARGS__))
-#define CON_STR_35(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_34(__VA_ARGS__))
-#define CON_STR_36(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_35(__VA_ARGS__))
-#define CON_STR_37(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_36(__VA_ARGS__))
-#define CON_STR_38(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_37(__VA_ARGS__))
-#define CON_STR_39(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_38(__VA_ARGS__))
-#define CON_STR_40(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_39(__VA_ARGS__))
-#define CON_STR_41(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_40(__VA_ARGS__))
-#define CON_STR_42(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_41(__VA_ARGS__))
-#define CON_STR_43(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_42(__VA_ARGS__))
-#define CON_STR_44(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_43(__VA_ARGS__))
-#define CON_STR_45(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_44(__VA_ARGS__))
-#define CON_STR_46(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_45(__VA_ARGS__))
-#define CON_STR_47(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_46(__VA_ARGS__))
-#define CON_STR_48(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_47(__VA_ARGS__))
-#define CON_STR_49(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_48(__VA_ARGS__))
-#define CON_STR_50(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_49(__VA_ARGS__))
-#define CON_STR_51(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_50(__VA_ARGS__))
-#define CON_STR_52(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_51(__VA_ARGS__))
-#define CON_STR_53(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_52(__VA_ARGS__))
-#define CON_STR_54(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_53(__VA_ARGS__))
-#define CON_STR_55(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_54(__VA_ARGS__))
-#define CON_STR_56(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_55(__VA_ARGS__))
-#define CON_STR_57(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_56(__VA_ARGS__))
-#define CON_STR_58(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_57(__VA_ARGS__))
-#define CON_STR_59(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_58(__VA_ARGS__))
-#define CON_STR_60(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_59(__VA_ARGS__))
-#define CON_STR_61(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_60(__VA_ARGS__))
-#define CON_STR_62(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_61(__VA_ARGS__))
-#define CON_STR_63(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_62(__VA_ARGS__))
-#define CON_STR_64(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_63(__VA_ARGS__))
-#define CON_STR_65(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_64(__VA_ARGS__))
-#define CON_STR_66(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_65(__VA_ARGS__))
-#define CON_STR_67(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_66(__VA_ARGS__))
-#define CON_STR_68(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_67(__VA_ARGS__))
-#define CON_STR_69(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_68(__VA_ARGS__))
-#define CON_STR_70(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_69(__VA_ARGS__))
-#define CON_STR_71(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_70(__VA_ARGS__))
-#define CON_STR_72(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_71(__VA_ARGS__))
-#define CON_STR_73(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_72(__VA_ARGS__))
-#define CON_STR_74(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_73(__VA_ARGS__))
-#define CON_STR_75(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_74(__VA_ARGS__))
-#define CON_STR_76(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_75(__VA_ARGS__))
-#define CON_STR_77(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_76(__VA_ARGS__))
-#define CON_STR_78(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_77(__VA_ARGS__))
-#define CON_STR_79(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_78(__VA_ARGS__))
-#define CON_STR_80(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_79(__VA_ARGS__))
-#define CON_STR_81(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_80(__VA_ARGS__))
-#define CON_STR_82(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_81(__VA_ARGS__))
-#define CON_STR_83(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_82(__VA_ARGS__))
-#define CON_STR_84(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_83(__VA_ARGS__))
-#define CON_STR_85(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_84(__VA_ARGS__))
-#define CON_STR_86(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_85(__VA_ARGS__))
-#define CON_STR_87(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_86(__VA_ARGS__))
-#define CON_STR_88(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_87(__VA_ARGS__))
-#define CON_STR_89(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_88(__VA_ARGS__))
-#define CON_STR_90(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_89(__VA_ARGS__))
-#define CON_STR_91(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_90(__VA_ARGS__))
-#define CON_STR_92(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_91(__VA_ARGS__))
-#define CON_STR_93(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_92(__VA_ARGS__))
-#define CON_STR_94(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_93(__VA_ARGS__))
-#define CON_STR_95(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_94(__VA_ARGS__))
-#define CON_STR_96(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_95(__VA_ARGS__))
-#define CON_STR_97(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_96(__VA_ARGS__))
-#define CON_STR_98(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_97(__VA_ARGS__))
-#define CON_STR_99(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_98(__VA_ARGS__))
-#define CON_STR_100(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_99(__VA_ARGS__))
-#define CON_STR_101(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_100(__VA_ARGS__))
-#define CON_STR_102(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_101(__VA_ARGS__))
-#define CON_STR_103(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_102(__VA_ARGS__))
-#define CON_STR_104(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_103(__VA_ARGS__))
-#define CON_STR_105(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_104(__VA_ARGS__))
-#define CON_STR_106(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_105(__VA_ARGS__))
-#define CON_STR_107(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_106(__VA_ARGS__))
-#define CON_STR_108(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_107(__VA_ARGS__))
-#define CON_STR_109(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_108(__VA_ARGS__))
-#define CON_STR_110(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_109(__VA_ARGS__))
-#define CON_STR_111(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_110(__VA_ARGS__))
-#define CON_STR_112(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_111(__VA_ARGS__))
-#define CON_STR_113(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_112(__VA_ARGS__))
-#define CON_STR_114(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_113(__VA_ARGS__))
-#define CON_STR_115(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_114(__VA_ARGS__))
-#define CON_STR_116(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_115(__VA_ARGS__))
-#define CON_STR_117(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_116(__VA_ARGS__))
-#define CON_STR_118(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_117(__VA_ARGS__))
-#define CON_STR_119(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_118(__VA_ARGS__))
-#define CON_STR_120(element, ...) \
-  ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_119(__VA_ARGS__))
-#define RSEQ_N()                                                               \
-  119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105,   \
-      104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, \
-      87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70,  \
-      69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52,  \
-      51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34,  \
-      33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,  \
-      15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
-
-#define ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14,     \
-              _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, \
-              _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
-              _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, \
-              _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, \
-              _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, _77, _78, _79, \
-              _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, \
-              _93, _94, _95, _96, _97, _98, _99, _100, _101, _102, _103, _104, \
-              _105, _106, _107, _108, _109, _110, _111, _112, _113, _114,      \
-              _115, _116, _117, _118, _119, N, ...)                            \
-  N
-
-#define MARCO_EXPAND(...) __VA_ARGS__
-#define APPLY_VARIADIC_MACRO(macro, ...) MARCO_EXPAND(macro(__VA_ARGS__))
-
-#define ADD_REFERENCE(t) std::reference_wrapper<decltype(t)>(t)
-#define ADD_REFERENCE_CONST(t) \
-  std::reference_wrapper<std::add_const_t<decltype(t)>>(t)
-#define FIELD(t) t
-#define MAKE_NAMES(...) #__VA_ARGS__,
-
-// note use MACRO_CONCAT like A##_##B direct may cause marco expand error
-#define MACRO_CONCAT(A, B) MACRO_CONCAT1(A, B)
-#define MACRO_CONCAT1(A, B) A##_##B
-
-#define MAKE_ARG_LIST(N, op, arg, ...) \
-  MACRO_CONCAT(MAKE_ARG_LIST, N)(op, arg, __VA_ARGS__)
-
-#define GET_ARG_COUNT_INNER(...) MARCO_EXPAND(ARG_N(__VA_ARGS__))
-#define GET_ARG_COUNT(...) GET_ARG_COUNT_INNER(__VA_ARGS__, RSEQ_N())
-
-#define MAKE_STR_LIST(...) \
-  MACRO_CONCAT(CON_STR, GET_ARG_COUNT(__VA_ARGS__))(__VA_ARGS__)
-
-template <typename T>
-struct identity {};
-
-struct field_info {
-  size_t offset;
-  std::string_view type_name;
-};
-
-struct base {
-  virtual void to_pb(std::string &str) const {}
-  virtual void from_pb(std::string_view str) {}
-  virtual void to_xml(std::string &str) const {}
-  virtual void from_xml(std::string_view str) {}
-  virtual void to_json(std::string &str) const {}
-  virtual void from_json(std::string_view str) {}
-  virtual void to_yaml(std::string &str) const {}
-  virtual void from_yaml(std::string_view str) {}
-  virtual std::vector<std::string_view> get_fields_name() const { return {}; }
-  virtual std::any get_field_any(std::string_view name) const { return {}; }
-  virtual iguana::detail::field_info get_field_info(
-      std::string_view name) const {
-    return {};
-  }
-
-  template <typename T>
-  T &get_field_value(std::string_view name) {
-    auto info = get_field_info(name);
-    check_field<T>(name, info);
-    auto ptr = (((char *)this) + info.offset);
-    return *((T *)ptr);
-  }
-
-  template <typename T, typename FiledType = T>
-  void set_field_value(std::string_view name, T val) {
-    auto info = get_field_info(name);
-    check_field<FiledType>(name, info);
-
-    auto ptr = (((char *)this) + info.offset);
-
-    static_assert(std::is_constructible_v<FiledType, T>, "can not assign");
-
-    *((FiledType *)ptr) = std::move(val);
-  }
-  virtual ~base() {}
-
- private:
-  template <typename T>
-  void check_field(std::string_view name, const field_info &info) {
-    if (info.offset == 0) {
-      throw std::invalid_argument(std::string(name) + " field not exist ");
-    }
-
-#if defined(__clang__) || defined(_MSC_VER) || \
-    (defined(__GNUC__) && __GNUC__ > 8)
-    if (info.type_name != iguana::type_string<T>()) {
-      std::string str = "type is not match: can not assign ";
-      str.append(iguana::type_string<T>());
-      str.append(" to ").append(info.type_name);
-
-      throw std::invalid_argument(str);
-    }
-#endif
-  }
-};
-
-inline std::unordered_map<std::string_view,
-                          std::function<std::shared_ptr<base>()>>
-    g_pb_map;
-
-template <typename T>
-inline bool register_type() {
-#if defined(__clang__) || defined(_MSC_VER) || \
-    (defined(__GNUC__) && __GNUC__ > 8)
-  if constexpr (std::is_base_of_v<base, T>) {
-    auto it = g_pb_map.emplace(type_string<T>(), [] {
-      return std::make_shared<T>();
-    });
-    return it.second;
-  }
-  else {
-    return true;
-  }
-#else
-  return true;
-#endif
-}
-
-#define MAKE_META_DATA_IMPL(STRUCT_NAME, ...)                                 \
-  static inline bool IGUANA_UNIQUE_VARIABLE(reg_var) =                        \
-      iguana::detail::register_type<STRUCT_NAME>();                           \
-  [[maybe_unused]] inline static auto iguana_reflect_members(                 \
-      const iguana::detail::identity<STRUCT_NAME> &) {                        \
-    struct reflect_members {                                                  \
-      constexpr decltype(auto) static apply_impl() {                          \
-        return std::make_tuple(__VA_ARGS__);                                  \
-      }                                                                       \
-      using size_type =                                                       \
-          std::integral_constant<size_t, GET_ARG_COUNT(__VA_ARGS__)>;         \
-      constexpr static std::string_view name() { return name_##STRUCT_NAME; } \
-      constexpr static std::string_view struct_name() {                       \
-        return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1);      \
-      }                                                                       \
-      constexpr static std::string_view fields() {                            \
-        return fields_##STRUCT_NAME;                                          \
-      }                                                                       \
-      constexpr static size_t value() { return size_type::value; }            \
-      constexpr static std::array<frozen::string, size_type::value> arr() {   \
-        return arr_##STRUCT_NAME;                                             \
-      }                                                                       \
-    };                                                                        \
-    return reflect_members{};                                                 \
-  }
-
-#define MAKE_META_DATA(STRUCT_NAME, TABLE_NAME, N, ...)                       \
-  static constexpr inline std::array<frozen::string, N> arr_##STRUCT_NAME = { \
-      MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__))};                   \
-  static constexpr inline std::string_view fields_##STRUCT_NAME = {           \
-      MAKE_NAMES(__VA_ARGS__)};                                               \
-  static constexpr inline std::string_view name_##STRUCT_NAME = TABLE_NAME;   \
-  MAKE_META_DATA_IMPL(STRUCT_NAME,                                            \
-                      MAKE_ARG_LIST(N, &STRUCT_NAME::FIELD, __VA_ARGS__))
-
-#define REFLECTION_ALIAS_IMPL(STRUCT_NAME, ALIAS, N, ...) \
-  MAKE_META_DATA_IMPL_ALIAS(STRUCT_NAME, ALIAS, __VA_ARGS__)
-
-#define FLDALIAS(a, b) \
-  std::pair { a, b }
-
-template <typename... Args>
-constexpr auto get_mem_ptr_tp(Args... pair) {
-  return std::make_tuple(std::get<0>(pair)...);
-}
-
-template <size_t N, typename... Args>
-constexpr std::array<frozen::string, N> get_alias_arr(Args... pairs) {
-  return std::array<frozen::string, sizeof...(Args)>{
-      frozen::string(std::get<1>(pairs))...};
-}
-
-#define MAKE_META_DATA_IMPL_ALIAS(STRUCT_NAME, ALIAS, ...)                    \
-  [[maybe_unused]] inline static auto iguana_reflect_members(                 \
-      const iguana::detail::identity<STRUCT_NAME> &) {                        \
-    struct reflect_members {                                                  \
-      constexpr decltype(auto) static apply_impl() {                          \
-        return iguana::detail::get_mem_ptr_tp(__VA_ARGS__);                   \
-      }                                                                       \
-      using size_type = std::integral_constant<                               \
-          size_t, std::tuple_size_v<decltype(std::make_tuple(__VA_ARGS__))>>; \
-      constexpr static std::string_view name() { return ALIAS; }              \
-      constexpr static std::string_view struct_name() {                       \
-        return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1);      \
-      }                                                                       \
-      constexpr static size_t value() { return size_type::value; }            \
-      constexpr static std::array<frozen::string, size_type::value> arr() {   \
-        return iguana::detail::get_alias_arr<size_type::value>(__VA_ARGS__);  \
-      }                                                                       \
-    };                                                                        \
-    return reflect_members{};                                                 \
-  }
-
-#define MAKE_META_DATA_IMPL_EMPTY(STRUCT_NAME)                              \
-  inline auto iguana_reflect_members(                                       \
-      const iguana::detail::identity<STRUCT_NAME> &) {                      \
-    struct reflect_members {                                                \
-      constexpr decltype(auto) static apply_impl() {                        \
-        return std::make_tuple();                                           \
-      }                                                                     \
-      using size_type = std::integral_constant<size_t, 0>;                  \
-      constexpr static std::string_view name() {                            \
-        return std::string_view(#STRUCT_NAME, sizeof(#STRUCT_NAME) - 1);    \
-      }                                                                     \
-      constexpr static size_t value() { return size_type::value; }          \
-      constexpr static std::array<frozen::string, size_type::value> arr() { \
-        return arr_##STRUCT_NAME;                                           \
-      }                                                                     \
-    };                                                                      \
-    return reflect_members{};                                               \
-  }
-
-#define MAKE_META_DATA_EMPTY(STRUCT_NAME)                                \
-  constexpr inline std::array<frozen::string, 0> arr_##STRUCT_NAME = {}; \
-  MAKE_META_DATA_IMPL_EMPTY(STRUCT_NAME)
-
-template <typename... Args>
-inline auto get_value_type(std::tuple<Args...>) {
-  return std::variant<Args...>{};
-}
-
-inline constexpr frozen::string filter_str(const frozen::string &str) {
-  if (str.size() > 3 && str[0] == '_' && str[1] == '_' && str[2] == '_') {
-    auto ptr = str.data() + 3;
-    return frozen::string(ptr, str.size() - 3);
-  }
-  return str;
-}
-
-template <typename T, size_t... Is>
-inline constexpr auto get_iguana_struct_map_impl(
-    const std::array<frozen::string, sizeof...(Is)> &arr, T &&t,
-    std::index_sequence<Is...>) {
-  using ValueType = decltype(get_value_type(t));
-  return frozen::unordered_map<frozen::string, ValueType, sizeof...(Is)>{
-      {filter_str(arr[Is]),
-       ValueType{std::in_place_index<Is>, std::get<Is>(t)}}...};
-}
-}  // namespace iguana::detail
-
-namespace iguana {
-#define REFLECTION_WITH_NAME(STRUCT_NAME, TABLE_NAME, ...)            \
-  MAKE_META_DATA(STRUCT_NAME, TABLE_NAME, GET_ARG_COUNT(__VA_ARGS__), \
-                 __VA_ARGS__)
-
-struct iguana_adl_t {};
-
-template <typename T>
-inline auto iguana_reflect_type(const T &t);
-
-inline std::unordered_map<
-    std::string_view,
-    std::vector<std::pair<std::string_view, std::string_view>>>
-    g_iguana_custom_map;
-template <typename T>
-inline constexpr auto get_iguana_struct_map() {
-  using reflect_members = decltype(iguana_reflect_type(std::declval<T>()));
-  if constexpr (reflect_members::value() == 0) {
-    return std::array<int, 0>{};
-  }
-  else {
-    return detail::get_iguana_struct_map_impl(
-        reflect_members::arr(), reflect_members::apply_impl(),
-        std::make_index_sequence<reflect_members::value()>{});
-  }
-}
-
-template <typename T,
-          typename ElementType = typename member_traits<T>::value_type>
-struct field_t {
-  using member_type = T;
-  using owner_type = typename member_traits<T>::owner_type;
-  using value_type = typename member_traits<T>::value_type;
-  using sub_type = ElementType;
-  constexpr field_t() = default;
-  constexpr field_t(T member, uint32_t number, frozen::string name = "")
-      : member_ptr(member), field_name(name), field_no(number) {}
-
-  T member_ptr;
-  frozen::string field_name;
-  uint32_t field_no;
-
-  auto &value(owner_type &value) const { return value.*member_ptr; }
-  auto const &value(owner_type const &value) const { return value.*member_ptr; }
-};
-
-template <typename T>
-struct field_type_t;
-
-template <typename... Args>
-struct field_type_t<std::tuple<Args...>> {
-  using value_type = std::variant<Args...>;
-};
-
-template <typename T, typename = void>
-struct is_custom_reflection : std::false_type {};
-
-template <typename T>
-struct is_custom_reflection<
-    T, std::void_t<decltype(get_members_impl(std::declval<T *>()))>>
-    : std::true_type {};
-
-template <typename T, typename = void>
-struct is_reflection : std::false_type {};
-
-template <typename T>
-inline constexpr bool is_reflection_v = is_reflection<T>::value;
-
-template <typename T>
-inline constexpr bool is_custom_reflection_v = is_custom_reflection<T>::value;
-
-template <typename T, typename S, size_t... I>
-constexpr inline auto build_variant_fields(T t, S &s, uint32_t base_idx,
-                                           std::index_sequence<I...>) {
-  using value_type = typename member_traits<T>::value_type;
-  return std::tuple(field_t<T, std::variant_alternative_t<I, value_type>>{
-      t, (base_idx + uint32_t(I)), s}...);
-}
-
-template <uint32_t I, typename T, typename S>
-constexpr inline auto build_fields(T t, S &s, uint32_t &index) {
-  using value_type = typename member_traits<T>::value_type;
-  if constexpr (is_variant<value_type>::value) {
-    constexpr uint32_t Size = std::variant_size_v<value_type>;
-    index += (Size - 1);
-    return build_variant_fields(t, s, I + 1, std::make_index_sequence<Size>{});
-  }
-  else {
-    uint32_t field_no = (I == index) ? (I + 1) : (2 + index);
-    index++;
-    return std::tuple(field_t{t, field_no, s});
-  }
-}
-
-template <typename T, typename U, size_t... I>
-constexpr inline auto get_members_tuple_impl(T &&tp, U &&arr,
-                                             std::index_sequence<I...> &&) {
-  uint32_t index = 0;
-  return std::tuple_cat(build_fields<I>(std::get<I>(tp), arr[I], index)...);
-}
-
-template <typename T>
-constexpr inline auto get_members_tuple() {
-  if constexpr (is_reflection<T>::value) {
-    using reflect_members = decltype(iguana_reflect_type(std::declval<T>()));
-    using Tuple = decltype(reflect_members::apply_impl());
-    constexpr size_t Size = std::tuple_size_v<Tuple>;
-    return get_members_tuple_impl(reflect_members::apply_impl(),
-                                  reflect_members::arr(),
-                                  std::make_index_sequence<Size>{});
-  }
-  else if constexpr (is_custom_reflection_v<T>) {
-    using U = std::remove_const_t<std::remove_reference_t<T>>;
-    return get_members_impl((U *)nullptr);
-  }
-  else {
-    static_assert(!sizeof(T), "expected reflection or custom reflection");
-  }
-}
-
-template <typename T, size_t Size, typename Tuple, size_t... I>
-constexpr auto inline get_members_impl(Tuple &&tp, std::index_sequence<I...>) {
-  return frozen::unordered_map<uint32_t, T, sizeof...(I)>{
-      {std::get<I>(tp).field_no,
-       T{std::in_place_index<I>, std::move(std::get<I>(tp))}}...};
-}
-
-template <typename T>
-constexpr size_t count_variant_size() {
-  if constexpr (is_variant<T>::value) {
-    return std::variant_size_v<T>;
-  }
-  else {
-    return 1;
-  }
-}
-
-template <typename T, size_t... I>
-constexpr size_t tuple_type_count_impl(std::index_sequence<I...>) {
-  return (
-      (count_variant_size<member_value_type_t<std::tuple_element_t<I, T>>>() +
-       ...));
-}
-
-template <typename T>
-constexpr size_t tuple_type_count() {
-  return tuple_type_count_impl<T>(
-      std::make_index_sequence<std::tuple_size_v<T>>{});
-}
-
-template <typename T>
-constexpr inline auto get_members() {
-  if constexpr (is_reflection_v<T> || is_custom_reflection_v<T>) {
-    constexpr auto tp = get_members_tuple<T>();
-    using Tuple = std::decay_t<decltype(tp)>;
-    using value_type = typename field_type_t<Tuple>::value_type;
-    constexpr auto Size = tuple_type_count<Tuple>();
-    return get_members_impl<value_type, Size>(tp,
-                                              std::make_index_sequence<Size>{});
-  }
-  else {
-    static_assert(!sizeof(T), "expected reflection or custom reflection");
-  }
-}
-
-#define REFLECTION(STRUCT_NAME, ...)                                    \
-  MAKE_META_DATA(STRUCT_NAME, #STRUCT_NAME, GET_ARG_COUNT(__VA_ARGS__), \
-                 __VA_ARGS__)
-
-#define REFLECTION_EMPTY(STRUCT_NAME) MAKE_META_DATA_EMPTY(STRUCT_NAME)
-
-#define REFLECTION_ALIAS(STRUCT_NAME, ALIAS, ...) \
-  REFLECTION_ALIAS_IMPL(                          \
-      STRUCT_NAME, ALIAS,                         \
-      std::tuple_size_v<decltype(std::make_tuple(__VA_ARGS__))>, __VA_ARGS__)
-
-#define IGUANA_UNIQUE_VARIABLE(str) MACRO_CONCAT(str, __COUNTER__)
-template <typename T>
-struct iguana_required_struct;
-#define REQUIRED_IMPL(STRUCT_NAME, N, ...)                      \
-  template <>                                                   \
-  struct iguana::iguana_required_struct<STRUCT_NAME> {          \
-    inline static constexpr auto requied_arr() {                \
-      std::array<std::string_view, N> arr_required = {          \
-          MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__))}; \
-      return arr_required;                                      \
-    }                                                           \
-  };
-
-#define REQUIRED(STRUCT_NAME, ...) \
-  REQUIRED_IMPL(STRUCT_NAME, GET_ARG_COUNT(__VA_ARGS__), __VA_ARGS__)
-
-template <class T, class = void>
-struct has_iguana_required_arr : std::false_type {};
-
-template <class T>
-struct has_iguana_required_arr<
-    T, std::void_t<decltype(iguana_required_struct<T>::requied_arr())>>
-    : std::true_type {};
-
-template <class T>
-constexpr bool has_iguana_required_arr_v = has_iguana_required_arr<T>::value;
-
-inline std::string_view trim_sv(std::string_view str) {
-  std::string_view whitespaces(" \t\f\v\n\r");
-  auto first = str.find_first_not_of(whitespaces);
-  auto last = str.find_last_not_of(whitespaces);
-  if (first == std::string_view::npos || last == std::string_view::npos)
-    return std::string_view();
-  return str.substr(first, last - first + 1);
-}
-
-inline int add_custom_fields(std::string_view key,
-                             std::vector<std::string_view> v) {
-  std::vector<std::pair<std::string_view, std::string_view>> vec;
-  for (auto val : v) {
-    std::string_view str = {val.data() + 1, val.size() - 2};
-    size_t pos = str.find(',');
-    if (pos == std::string_view::npos || pos == str.size() - 1) {
-      continue;
-    }
-
-    std::string_view origin = str.substr(0, pos);
-    std::string_view alias = str.substr(pos + 1);
-
-    vec.push_back(std::make_pair(trim_sv(origin), trim_sv(alias)));
-  }
-  g_iguana_custom_map.emplace(key, std::move(vec));
-  return 0;
-}
-
-#define CUSTOM_FIELDS_IMPL(STRUCT_NAME, N, ...)                                \
-  inline auto IGUANA_UNIQUE_VARIABLE(STRUCT_NAME) = iguana::add_custom_fields( \
-      #STRUCT_NAME, {MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__))});
-
-#define CUSTOM_FIELDS(STRUCT_NAME, ...) \
-  CUSTOM_FIELDS_IMPL(STRUCT_NAME, GET_ARG_COUNT(__VA_ARGS__), __VA_ARGS__)
-
-template <typename T>
-using Reflect_members = decltype(iguana_reflect_members(
-    std::declval<iguana::detail::identity<T>>()));
-
-template <typename T, typename = void>
-struct is_public_reflection : std::false_type {};
-
-template <typename T>
-struct is_public_reflection<T,
-                            std::void_t<decltype(iguana_reflect_members(
-                                std::declval<iguana::detail::identity<T>>()))>>
-    : std::true_type {};
-
-template <typename T>
-constexpr bool is_public_reflection_v = is_public_reflection<T>::value;
-
-template <typename T, typename = void>
-struct is_private_reflection : std::false_type {};
-
-template <typename T>
-struct is_private_reflection<
-    T, std::void_t<decltype(std::declval<T>().iguana_reflect_members(
-           std::declval<iguana::detail::identity<T>>()))>> : std::true_type {};
-
-template <typename T>
-constexpr bool is_private_reflection_v = is_private_reflection<T>::value;
-
-template <typename T>
-struct is_reflection<T, std::enable_if_t<is_private_reflection_v<T>>>
-    : std::true_type {};
-
-template <typename T>
-struct is_reflection<T, std::enable_if_t<is_public_reflection_v<T>>>
-    : std::true_type {};
-
-template <typename T>
-inline auto iguana_reflect_type(const T &t) {
-  if constexpr (is_public_reflection_v<std::decay_t<T>>) {
-    return iguana_reflect_members(iguana::detail::identity<T>{});
-  }
-  else {
-    return t.iguana_reflect_members(iguana::detail::identity<T>{});
-  }
-}
-
-template <std::size_t index, template <typename...> typename Condition,
-          typename Tuple, typename Owner>
-constexpr int element_index_helper() {
-  if constexpr (index == std::tuple_size_v<Tuple>) {
-    return index;
-  }
-  else {
-    using type_v = decltype(std::declval<Owner>().*
-                            std::declval<std::tuple_element_t<index, Tuple>>());
-    using item_type = std::decay_t<type_v>;
-
-    return Condition<item_type>::value
-               ? index
-               : element_index_helper<index + 1, Condition, Tuple, Owner>();
-  }
-}
-
-template <template <typename...> typename Condition, typename T>
-constexpr int tuple_element_index() {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  using Tuple = decltype(M::apply_impl());
-  return element_index_helper<0, Condition, Tuple, T>();
-}
-
-template <size_t I, typename T>
-constexpr decltype(auto) get(T &&t) {
-  using M = decltype(iguana_reflect_type(std::forward<T>(t)));
-  using U = decltype(std::forward<T>(t).*(std::get<I>(M::apply_impl())));
-
-  if constexpr (std::is_array_v<U>) {
-    auto s = std::forward<T>(t).*(std::get<I>(M::apply_impl()));
-    std::array<char, sizeof(U)> arr;
-    memcpy(arr.data(), s, arr.size());
-    return arr;
-  }
-  else
-    return std::forward<T>(t).*(std::get<I>(M::apply_impl()));
-}
-
-template <template <typename...> typename Condition, typename T>
-constexpr size_t get_type_index() {
-  return tuple_element_index<Condition, T>();
-}
-
-template <typename T, size_t... Is>
-constexpr auto get_impl(T const &t, std::index_sequence<Is...>) {
-  return std::make_tuple(get<Is>(t)...);
-}
-
-template <typename T, size_t... Is>
-constexpr auto get_impl(T &t, std::index_sequence<Is...>) {
-  return std::make_tuple(std::ref(get<Is>(t))...);
-}
-
-template <typename T>
-constexpr auto get(T const &t) {
-  using M = decltype(iguana_reflect_type(t));
-  return get_impl(t, std::make_index_sequence<M::value()>{});
-}
-
-template <typename T>
-constexpr auto get_ref(T &t) {
-  using M = decltype(iguana_reflect_type(t));
-  return get_impl(t, std::make_index_sequence<M::value()>{});
-}
-
-template <typename T, size_t I>
-constexpr const auto get_name() {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  static_assert(I < M::value(), "out of range");
-  return M::arr()[I];
-}
-
-template <typename T>
-constexpr const auto get_name(size_t i) {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  //		static_assert(I<M::value(), "out of range");
-  return M::arr()[i];
-}
-
-template <typename T>
-constexpr const std::string_view get_name() {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  return M::name();
-}
-
-namespace detail {
-template <typename T, typename U>
-constexpr bool get_index_imple(T ptr, U ele) {
-  if constexpr (std::is_same_v<decltype(ptr), decltype(ele)>) {
-    if (ele == ptr) {
-      return true;
-    }
-    else {
-      return false;
-    }
-  }
-  else {
-    return false;
-  }
-}
-
-template <typename T, typename Tuple, size_t... I>
-constexpr size_t member_index_impl(T ptr, Tuple &tp,
-                                   std::index_sequence<I...>) {
-  bool r = false;
-  size_t index = 0;
-  ((void)(!r && (r = get_index_imple(ptr, std::get<I>(tp)),
-                 !r ? index++ : index, true)),
-   ...);
-  return index;
-}
-
-template <typename T, typename Tuple>
-constexpr size_t member_index(T ptr, Tuple &tp) {
-  return member_index_impl(
-      ptr, tp,
-      std::make_index_sequence<
-          std::tuple_size_v<std::decay_t<decltype(tp)>>>{});
-}
-}  // namespace detail
-
-template <auto member>
-constexpr size_t index_of() {
-  using namespace detail;
-  using T = typename member_tratis<decltype(member)>::owner_type;
-  using M = Reflect_members<T>;
-  constexpr auto tp = M::apply_impl();
-  constexpr size_t Size = std::tuple_size_v<decltype(tp)>;
-  constexpr size_t index = member_index(member, tp);
-  static_assert(index < Size, "out of range");
-  return index;
-}
-
-template <auto... members>
-constexpr std::array<size_t, sizeof...(members)> indexs_of() {
-  return std::array<size_t, sizeof...(members)>{index_of<members>()...};
-}
-
-template <auto member>
-constexpr auto name_of() {
-  using T = typename member_tratis<decltype(member)>::owner_type;
-  using M = Reflect_members<T>;
-  constexpr auto s = M::arr()[index_of<member>()];
-  return std::string_view(s.data(), s.size());
-}
-
-template <auto... members>
-constexpr std::array<std::string_view, sizeof...(members)> names_of() {
-  return std::array<std::string_view, sizeof...(members)>{
-      name_of<members>()...};
-}
-
-template <auto member>
-constexpr auto member_count_of() {
-  using T = typename member_tratis<decltype(member)>::owner_type;
-  using M = Reflect_members<T>;
-  return M::value();
-}
-
-template <typename T, auto member>
-constexpr size_t duplicate_count();
-
-template <auto ptr, typename Member>
-constexpr void check_duplicate(Member member, size_t &index) {
-  using value_type = typename member_tratis<decltype(member)>::value_type;
-
-  if (detail::get_index_imple(ptr, member)) {
-    index++;
-  }
-
-  if constexpr (is_reflection_v<value_type>) {
-    index += iguana::duplicate_count<value_type, ptr>();
-  }
-}
-
-template <typename T, auto member>
-constexpr size_t duplicate_count() {
-  using M = Reflect_members<T>;
-  constexpr auto name = name_of<member>();
-  constexpr auto arr = M::arr();
-
-  constexpr auto tp = M::apply_impl();
-  size_t index = 0;
-  std::apply(
-      [&](auto... ele) {
-        (check_duplicate<member>(ele, index), ...);
-      },
-      tp);
-
-  for (auto &s : arr) {
-    if (s == name) {
-      index++;
-      break;
-    }
-  }
-
-  return index;
-}
-
-template <typename T>
-constexpr const std::string_view get_fields() {
-  using M = Reflect_members<T>;
-  return M::fields();
-}
-
-template <typename T>
-constexpr std::enable_if_t<is_reflection<T>::value, size_t> get_value() {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  return M::value();
-}
-
-template <typename T>
-constexpr std::enable_if_t<!is_reflection<T>::value, size_t> get_value() {
-  return 1;
-}
-
-template <typename T>
-constexpr auto get_array() {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  return M::arr();
-}
-
-template <typename T>
-inline bool has_custom_fields(std::string_view key = "") {
-  if (key.empty()) {
-    return !g_iguana_custom_map.empty();
-  }
-
-  return g_iguana_custom_map.find(key) != g_iguana_custom_map.end();
-}
-
-template <typename T>
-inline std::string_view get_custom_fields(std::string_view origin) {
-  constexpr std::string_view name = get_name<T>();
-  auto it = g_iguana_custom_map.find(name);
-  if (it == g_iguana_custom_map.end()) {
-    return "";
-  }
-
-  auto &vec = it->second;
-  auto find_it = std::find_if(vec.begin(), vec.end(), [origin](auto &pair) {
-    return pair.first == origin;
-  });
-
-  if (find_it == vec.end()) {
-    return "";
-  }
-
-  return (*find_it).second;
-}
-
-template <typename T>
-constexpr auto get_index(std::string_view name) {
-  using M = decltype(iguana_reflect_type(std::declval<T>()));
-  constexpr auto arr = M::arr();
-
-  auto it = std::find_if(arr.begin(), arr.end(), [name](auto str) {
-    return (str == name);
-  });
-
-  return std::distance(arr.begin(), it);
-}
-
-template <class Tuple, class F, std::size_t... Is>
-void tuple_switch(std::size_t i, Tuple &&t, F &&f, std::index_sequence<Is...>) {
-  ((i == Is &&
-    ((std::forward<F>(f)(std::get<Is>(std::forward<Tuple>(t)))), false)),
-   ...);
-}
-
-//-------------------------------------------------------------------------------------------------------------//
-//-------------------------------------------------------------------------------------------------------------//
-template <typename... Args, typename F, std::size_t... Idx>
-constexpr void for_each(std::tuple<Args...> &t, F &&f,
-                        std::index_sequence<Idx...>) {
-  (std::forward<F>(f)(std::get<Idx>(t), std::integral_constant<size_t, Idx>{}),
-   ...);
-}
-
-template <typename... Args, typename F, std::size_t... Idx>
-constexpr void for_each(const std::tuple<Args...> &t, F &&f,
-                        std::index_sequence<Idx...>) {
-  (std::forward<F>(f)(std::get<Idx>(t), std::integral_constant<size_t, Idx>{}),
-   ...);
-}
-
-template <typename T, typename F>
-constexpr std::enable_if_t<is_reflection<std::decay_t<T>>::value> for_each(
-    T &&t, F &&f) {
-  using M = decltype(iguana_reflect_type(std::forward<T>(t)));
-  for_each(M::apply_impl(), std::forward<F>(f),
-           std::make_index_sequence<M::value()>{});
-}
-
-template <typename T, typename F>
-constexpr std::enable_if_t<is_tuple<std::decay_t<T>>::value> for_each(T &&t,
-                                                                      F &&f) {
-  constexpr const size_t SIZE = std::tuple_size_v<std::decay_t<T>>;
-  for_each(std::forward<T>(t), std::forward<F>(f),
-           std::make_index_sequence<SIZE>{});
-}
-}  // namespace iguana
-#endif  // IGUANA_REFLECTION_HPP
diff --git a/iguana/util.hpp b/iguana/util.hpp
index 1f08ed52..614040cc 100644
--- a/iguana/util.hpp
+++ b/iguana/util.hpp
@@ -13,13 +13,15 @@
 
 #include "define.h"
 #include "detail/charconv.h"
+#include "detail/pb_type.hpp"
+#include "detail/traits.hpp"
 #include "detail/utf.hpp"
 #include "error_code.h"
 #include "field_reflection.hpp"
-#include "reflection.hpp"
+#include "ylt/reflection/member_value.hpp"
+#include "ylt/reflection/user_reflect_macro.hpp"
 
 namespace iguana {
-
 template <typename T>
 inline constexpr bool char_v = std::is_same_v<std::decay_t<T>, char> ||
                                std::is_same_v<std::decay_t<T>, char16_t> ||
@@ -137,11 +139,35 @@ template <size_t Idx, typename T>
 using variant_element_t = std::remove_reference_t<decltype(std::get<Idx>(
     std::declval<std::remove_reference_t<T>>()))>;
 
-template <typename T>
-constexpr inline bool refletable_v = is_reflection_v<std::remove_cvref_t<T>>;
+template <typename F, typename Tuple, size_t... Is>
+constexpr void foreach_tuple(F&& f, Tuple& tp, std::index_sequence<Is...>) {
+  (void(f(std::get<Is>(tp), std::integral_constant<size_t, Is>{})), ...);
+}
+
+template <typename F, typename Tuple>
+constexpr void foreach_tuple(F&& f, Tuple& tp) {
+  foreach_tuple(std::forward<F>(f), tp,
+                std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+}
+
+template <typename F, typename T>
+inline constexpr auto for_each_tuple(F&& f, T&& tup) {
+  std::apply(
+      [&f](auto&&... args) {
+        (f(args), ...);
+      },
+      std::forward<T>(tup));
+}
+
+template <class T>
+constexpr inline bool ylt_refletable_v =
+    (ylt::reflection::is_ylt_refl_v<T> ||
+     std::is_aggregate_v<
+         ylt::reflection::remove_cvref_t<T>>)&&!fixed_array_v<T> &&
+    !ylt::reflection::is_custom_refl_v<T> && !is_pb_type_v<T>;
 
 template <class T>
-constexpr inline bool non_refletable_v = !refletable_v<T>;
+constexpr inline bool non_ylt_refletable_v = !ylt_refletable_v<T>;
 
 template <typename T>
 constexpr inline bool plain_v =
diff --git a/iguana/xml_reader.hpp b/iguana/xml_reader.hpp
index 8b9c908f..b060117a 100644
--- a/iguana/xml_reader.hpp
+++ b/iguana/xml_reader.hpp
@@ -16,7 +16,8 @@ template <typename U, typename It, std::enable_if_t<smart_ptr_v<U>, int> = 0>
 IGUANA_INLINE void xml_parse_item(U &value, It &&it, It &&end,
                                   std::string_view name);
 
-template <typename U, typename It, std::enable_if_t<refletable_v<U>, int> = 0>
+template <typename U, typename It,
+          std::enable_if_t<ylt_refletable_v<U>, int> = 0>
 IGUANA_INLINE void xml_parse_item(U &value, It &&it, It &&end,
                                   std::string_view name);
 
@@ -289,7 +290,7 @@ IGUANA_INLINE void skip_comment(It &&it, It &&end) {
 
 // return true means reach the close tag
 template <size_t cdata_idx, typename T, typename It,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE auto skip_till_close_tag(T &value, It &&it, It &&end) {
   while (true) {
     skip_sapces_and_newline(it, end);
@@ -309,7 +310,7 @@ IGUANA_INLINE auto skip_till_close_tag(T &value, It &&it, It &&end) {
         ++it;
         if (*it == '[') {
           // <![
-          if constexpr (cdata_idx == iguana::get_value<std::decay_t<T>>()) {
+          if constexpr (cdata_idx == ylt::reflection::members_count_v<T>) {
             skip_cdata(it, end);
           }
           else {
@@ -317,7 +318,7 @@ IGUANA_INLINE auto skip_till_close_tag(T &value, It &&it, It &&end) {
             ++it;
             match<'C', 'D', 'A', 'T', 'A', '['>(it, end);
             skip_sapces_and_newline(it, end);
-            auto &cdata_value = get<cdata_idx>(value);
+            auto &cdata_value = ylt::reflection::get<cdata_idx>(value);
             using VT = typename std::decay_t<decltype(cdata_value)>::value_type;
             auto vb = it;
             auto ve = skip_pass<']'>(it, end);
@@ -392,7 +393,7 @@ IGUANA_INLINE void check_required(std::string_view key_set) {
   }
 }
 
-template <typename T, typename It, std::enable_if_t<refletable_v<T>, int>>
+template <typename T, typename It, std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void xml_parse_item(T &value, It &&it, It &&end,
                                   std::string_view name) {
   using U = std::decay_t<T>;
@@ -411,21 +412,19 @@ IGUANA_INLINE void xml_parse_item(T &value, It &&it, It &&end,
   [[maybe_unused]] std::string key_set;
   bool parse_done = false;
   // sequential parse
-  for_each(value, [&](const auto member_ptr, auto i) IGUANA__INLINE_LAMBDA {
+  ylt::reflection::for_each(value, [&](auto &field, auto st_key, auto index) {
 #if defined(_MSC_VER) && _MSVC_LANG < 202002L
     // seems MVSC can't pass a constexpr value to lambda
     constexpr auto cdata_idx = get_type_index<is_cdata_t, U>();
 #endif
-    using item_type = std::remove_reference_t<decltype(value.*member_ptr)>;
-    constexpr auto mkey = iguana::get_name<T, decltype(i)::value>();
-    constexpr std::string_view st_key(mkey.data(), mkey.size());
+    using item_type = std::remove_reference_t<decltype(field)>;
     if constexpr (cdata_v<item_type>) {
       return;
     }
     if (parse_done || key != st_key)
       IGUANA_UNLIKELY { return; }
     if constexpr (!cdata_v<item_type>) {
-      xml_parse_item(value.*member_ptr, it, end, key);
+      xml_parse_item(field, it, end, key);
       if constexpr (iguana::has_iguana_required_arr_v<U>) {
         key_set.append(key).append(", ");
       }
@@ -448,18 +447,17 @@ IGUANA_INLINE void xml_parse_item(T &value, It &&it, It &&end,
     }
   // map parse
   while (true) {
-    static constexpr auto frozen_map = get_iguana_struct_map<T>();
+    static auto frozen_map = ylt::reflection::get_variant_map<U>();
     const auto &member_it = frozen_map.find(key);
     if (member_it != frozen_map.end())
       IGUANA_LIKELY {
         std::visit(
-            [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
-              static_assert(
-                  std::is_member_pointer_v<std::decay_t<decltype(member_ptr)>>,
-                  "type must be memberptr");
-              using V = std::remove_reference_t<decltype(value.*member_ptr)>;
-              if constexpr (!cdata_v<V>) {
-                xml_parse_item(value.*member_ptr, it, end, key);
+            [&](auto offset) IGUANA__INLINE_LAMBDA {
+              using value_type = typename decltype(offset)::type;
+              if constexpr (!cdata_v<value_type>) {
+                auto member_ptr =
+                    (value_type *)((char *)(&value) + offset.value);
+                xml_parse_item(*member_ptr, it, end, key);
                 if constexpr (iguana::has_iguana_required_arr_v<U>) {
                   key_set.append(key).append(", ");
                 }
@@ -500,7 +498,8 @@ IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   detail::xml_parse_item(value.value(), it, end, key);
 }
 
-template <typename It, typename U, std::enable_if_t<refletable_v<U>, int> = 0>
+template <typename It, typename U,
+          std::enable_if_t<ylt_refletable_v<U>, int> = 0>
 IGUANA_INLINE void from_xml(U &value, It &&it, It &&end) {
   detail::skip_till_first_key(it, end);
   auto start = it;
diff --git a/iguana/xml_util.hpp b/iguana/xml_util.hpp
index 8259e176..a166e2d2 100644
--- a/iguana/xml_util.hpp
+++ b/iguana/xml_util.hpp
@@ -1,8 +1,35 @@
 #pragma once
+#include "common.hpp"
 #include "detail/pb_type.hpp"
 #include "util.hpp"
 
 namespace iguana {
+template <typename T>
+struct iguana_required_struct;
+#define REQUIRED_IMPL(STRUCT_NAME, N, ...)             \
+  template <>                                          \
+  struct iguana::iguana_required_struct<STRUCT_NAME> { \
+    inline static constexpr auto requied_arr() {       \
+      std::array<std::string_view, N> arr_required = { \
+          WRAP_ARGS(CONCAT_NAME, 0, ##__VA_ARGS__)};   \
+      return arr_required;                             \
+    }                                                  \
+  };
+
+#define REQUIRED(STRUCT_NAME, ...) \
+  REQUIRED_IMPL(STRUCT_NAME, YLT_ARG_COUNT(__VA_ARGS__), __VA_ARGS__)
+
+template <class T, class = void>
+struct has_iguana_required_arr : std::false_type {};
+
+template <class T>
+struct has_iguana_required_arr<
+    T, std::void_t<decltype(iguana_required_struct<T>::requied_arr())>>
+    : std::true_type {};
+
+template <class T>
+constexpr bool has_iguana_required_arr_v = has_iguana_required_arr<T>::value;
+
 template <typename T,
           typename map_type = std::unordered_map<std::string, std::string>>
 class xml_attr_t {
@@ -49,6 +76,33 @@ struct is_cdata_t : std::false_type {};
 template <typename T>
 struct is_cdata_t<xml_cdata_t<T>> : std::true_type {};
 
+template <std::size_t index, template <typename...> typename Condition,
+          typename Tuple>
+constexpr int element_index_helper() {
+  if constexpr (index == std::tuple_size_v<Tuple>) {
+    return index;
+  }
+  else {
+    using item_type =
+        ylt::reflection::remove_cvref_t<std::tuple_element_t<index, Tuple>>;
+
+    return Condition<item_type>::value
+               ? index
+               : element_index_helper<index + 1, Condition, Tuple>();
+  }
+}
+
+template <template <typename...> typename Condition, typename T>
+constexpr int tuple_element_index() {
+  using Tuple = decltype(ylt::reflection::object_to_tuple(std::declval<T>()));
+  return element_index_helper<0, Condition, Tuple>();
+}
+
+template <template <typename...> typename Condition, typename T>
+constexpr size_t get_type_index() {
+  return tuple_element_index<Condition, T>();
+}
+
 template <typename T>
 constexpr inline bool cdata_v = is_cdata_t<std::remove_cvref_t<T>>::value;
 
diff --git a/iguana/xml_writer.hpp b/iguana/xml_writer.hpp
index f9d5009d..57536f82 100644
--- a/iguana/xml_writer.hpp
+++ b/iguana/xml_writer.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "detail/charconv.h"
-#include "reflection.hpp"
 #include "xml_util.hpp"
 
 namespace iguana {
@@ -69,7 +68,7 @@ IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
                                     std::string_view name);
 
 template <bool pretty, size_t spaces, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name);
 
 template <bool pretty, size_t spaces, typename Stream>
@@ -249,41 +248,33 @@ IGUANA_INLINE void render_xml_value(Stream &ss, const T &value,
 }
 
 template <bool pretty, size_t spaces, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int>>
+          std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void render_xml_value(Stream &ss, T &&t, std::string_view name) {
   if constexpr (pretty) {
     ss.push_back('\n');
   }
-  for_each(std::forward<T>(t),
-           [&](const auto &v, auto i) IGUANA__INLINE_LAMBDA {
-             using M = decltype(iguana_reflect_type(std::forward<T>(t)));
-             using value_type = underline_type_t<decltype(t.*v)>;
-             constexpr auto Idx = decltype(i)::value;
-             constexpr auto Count = M::value();
-             [[maybe_unused]] constexpr std::string_view tag_name =
-                 std::string_view(get_name<std::decay_t<T>, Idx>().data(),
-                                  get_name<std::decay_t<T>, Idx>().size());
-             static_assert(Idx < Count);
-             if constexpr (sequence_container_v<value_type>) {
-               render_xml_value<pretty, spaces + 1>(ss, t.*v, tag_name);
-             }
-             else if constexpr (attr_v<value_type>) {
-               render_xml_value<pretty, spaces + 1>(ss, t.*v, tag_name);
-             }
-             else if constexpr (cdata_v<value_type>) {
-               if constexpr (pretty) {
-                 ss.append(spaces + 1, '\t');
-                 ss.append("<![CDATA[").append((t.*v).value()).append("]]>\n");
-               }
-               else {
-                 ss.append("<![CDATA[").append((t.*v).value()).append("]]>");
-               }
-             }
-             else {
-               render_head<pretty, spaces + 1>(ss, tag_name);
-               render_xml_value<pretty, spaces + 1>(ss, t.*v, tag_name);
-             }
-           });
+  ylt::reflection::for_each(t, [&](auto &field, auto tag_name, auto index) {
+    using value_type = underline_type_t<decltype(field)>;
+    if constexpr (sequence_container_v<value_type>) {
+      render_xml_value<pretty, spaces + 1>(ss, field, tag_name);
+    }
+    else if constexpr (attr_v<value_type>) {
+      render_xml_value<pretty, spaces + 1>(ss, field, tag_name);
+    }
+    else if constexpr (cdata_v<value_type>) {
+      if constexpr (pretty) {
+        ss.append(spaces + 1, '\t');
+        ss.append("<![CDATA[").append(field.value()).append("]]>\n");
+      }
+      else {
+        ss.append("<![CDATA[").append(field.value()).append("]]>");
+      }
+    }
+    else {
+      render_head<pretty, spaces + 1>(ss, tag_name);
+      render_xml_value<pretty, spaces + 1>(ss, field, tag_name);
+    }
+  });
   render_tail<pretty, spaces>(ss, name);
 }
 
@@ -291,17 +282,17 @@ template <bool pretty = false, typename Stream, typename T,
           std::enable_if_t<attr_v<T>, int> = 0>
 IGUANA_INLINE void to_xml(T &&t, Stream &s) {
   using value_type = typename std::decay_t<T>::value_type;
-  static_assert(refletable_v<value_type>, "value_type must be refletable");
-  constexpr std::string_view root_name = std::string_view(
-      get_name<value_type>().data(), get_name<value_type>().size());
+  static_assert(ylt_refletable_v<value_type>, "value_type must be refletable");
+  constexpr std::string_view root_name =
+      ylt::reflection::get_struct_name<value_type>();
   render_xml_value<pretty, 0>(s, std::forward<T>(t), root_name);
 }
 
 template <bool pretty = false, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_xml(T &&t, Stream &s) {
-  constexpr std::string_view root_name = std::string_view(
-      get_name<std::decay_t<T>>().data(), get_name<std::decay_t<T>>().size());
+  constexpr std::string_view root_name =
+      ylt::reflection::get_struct_name<ylt::reflection::remove_cvref_t<T>>();
   render_head<pretty, 0>(s, root_name);
   render_xml_value<pretty, 0>(s, std::forward<T>(t), root_name);
 }
diff --git a/iguana/yaml_reader.hpp b/iguana/yaml_reader.hpp
index 4e1f050a..44cfd9e8 100644
--- a/iguana/yaml_reader.hpp
+++ b/iguana/yaml_reader.hpp
@@ -8,7 +8,8 @@
 
 namespace iguana {
 
-template <typename T, typename It, std::enable_if_t<refletable_v<T>, int> = 0>
+template <typename T, typename It,
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end,
                              size_t min_spaces = 0);
 
@@ -221,7 +222,8 @@ IGUANA_INLINE void yaml_parse_value(U &&value, It &&value_begin,
     IGUANA_UNLIKELY { throw std::runtime_error("Expected true or false"); }
 }
 
-template <typename U, typename It, std::enable_if_t<refletable_v<U>, int> = 0>
+template <typename U, typename It,
+          std::enable_if_t<ylt_refletable_v<U>, int> = 0>
 IGUANA_INLINE void yaml_parse_item(U &value, It &&it, It &&end,
                                    size_t min_spaces) {
   from_yaml(value, it, end, min_spaces);
@@ -349,43 +351,47 @@ IGUANA_INLINE void yaml_parse_item(U &value, It &&it, It &&end,
   if (*it == '[') {
     ++it;
     skip_space_and_lines(it, end, min_spaces);
-    for_each(value, [&](auto &v, auto i) IGUANA__INLINE_LAMBDA {
-      using value_type = std::decay_t<decltype(v)>;
-      skip_space_and_lines(it, end, min_spaces);
-      if constexpr (plain_v<value_type>) {
-        auto start = it;
-        auto value_end = yaml_skip_till<',', ']'>(it, end);
-        yaml_parse_value(v, start, value_end);
-      }
-      else {
-        yaml_parse_item(v, it, end, spaces + 1);
-        skip_space_and_lines(it, end, min_spaces);
-        ++it;  // skip ,
-      }
-    });
+    for_each_tuple(
+        [&](auto &v) IGUANA__INLINE_LAMBDA {
+          using value_type = std::decay_t<decltype(v)>;
+          skip_space_and_lines(it, end, min_spaces);
+          if constexpr (plain_v<value_type>) {
+            auto start = it;
+            auto value_end = yaml_skip_till<',', ']'>(it, end);
+            yaml_parse_value(v, start, value_end);
+          }
+          else {
+            yaml_parse_item(v, it, end, spaces + 1);
+            skip_space_and_lines(it, end, min_spaces);
+            ++it;  // skip ,
+          }
+        },
+        value);
   }
   else if (*it == '-') {
-    for_each(value, [&](auto &v, auto i) IGUANA__INLINE_LAMBDA {
-      // we don't need to determine when it will end
-      // because the user decides how many items there are
-      // the following is similar to sequence_t
-      using value_type = std::decay_t<decltype(v)>;
-      skip_space_and_lines(it, end, spaces);
-      match<'-'>(it, end);
-      [[maybe_unused]] auto subspaces =
-          skip_space_and_lines(it, end, spaces + 1);
-      if constexpr (string_v<value_type>) {
-        yaml_parse_item(v, it, end, spaces + 1);
-      }
-      else if constexpr (plain_v<value_type>) {
-        auto start = it;
-        auto value_end = skip_till_newline(it, end);
-        yaml_parse_value(v, start, value_end);
-      }
-      else {
-        yaml_parse_item(v, it, end, subspaces);
-      }
-    });
+    for_each_tuple(
+        [&](auto &v) IGUANA__INLINE_LAMBDA {
+          // we don't need to determine when it will end
+          // because the user decides how many items there are
+          // the following is similar to sequence_t
+          using value_type = std::decay_t<decltype(v)>;
+          skip_space_and_lines(it, end, spaces);
+          match<'-'>(it, end);
+          [[maybe_unused]] auto subspaces =
+              skip_space_and_lines(it, end, spaces + 1);
+          if constexpr (string_v<value_type>) {
+            yaml_parse_item(v, it, end, spaces + 1);
+          }
+          else if constexpr (plain_v<value_type>) {
+            auto start = it;
+            auto value_end = skip_till_newline(it, end);
+            yaml_parse_value(v, start, value_end);
+          }
+          else {
+            yaml_parse_item(v, it, end, subspaces);
+          }
+        },
+        value);
   }
   else {
     throw std::runtime_error("Expected ']' or '-'");
@@ -530,7 +536,7 @@ IGUANA_INLINE void skip_object_value(It &&it, It &&end, size_t min_spaces) {
 
 }  // namespace detail
 
-template <typename T, typename It, std::enable_if_t<refletable_v<T>, int>>
+template <typename T, typename It, std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end, size_t min_spaces) {
   auto spaces = skip_space_and_lines(it, end, min_spaces);
   while (it != end) {
@@ -538,21 +544,18 @@ IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end, size_t min_spaces) {
     auto keyend = yaml_skip_till<':'>(it, end);
     std::string_view key = std::string_view{
         &*start, static_cast<size_t>(std::distance(start, keyend))};
-    static constexpr auto frozen_map = get_iguana_struct_map<T>();
+    static auto frozen_map = ylt::reflection::get_variant_map<T>();
+
     if constexpr (frozen_map.size() > 0) {
       const auto &member_it = frozen_map.find(key);
       if (member_it != frozen_map.end())
         IGUANA_LIKELY {
           std::visit(
-              [&](auto &&member_ptr) IGUANA__INLINE_LAMBDA {
-                using V = std::decay_t<decltype(member_ptr)>;
-                if constexpr (std::is_member_pointer_v<V>) {
-                  detail::yaml_parse_item(value.*member_ptr, it, end,
-                                          spaces + 1);
-                }
-                else {
-                  static_assert(!sizeof(V), "type not supported");
-                }
+              [&](auto offset) IGUANA__INLINE_LAMBDA {
+                using value_type = typename decltype(offset)::type;
+                auto member_ptr =
+                    (value_type *)((char *)(&value) + offset.value);
+                detail::yaml_parse_item(*member_ptr, it, end, spaces + 1);
               },
               member_it->second);
         }
@@ -575,7 +578,7 @@ IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end, size_t min_spaces) {
 }
 
 template <typename T, typename It,
-          std::enable_if_t<non_refletable_v<T>, int> = 0>
+          std::enable_if_t<non_ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void from_yaml(T &value, It &&it, It &&end) {
   detail::yaml_parse_item(value, it, end, 0);
 }
diff --git a/iguana/yaml_util.hpp b/iguana/yaml_util.hpp
index 920a9918..1ba0e1fe 100644
--- a/iguana/yaml_util.hpp
+++ b/iguana/yaml_util.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "common.hpp"
 #include "detail/pb_type.hpp"
 #include "util.hpp"
 
diff --git a/iguana/yaml_writer.hpp b/iguana/yaml_writer.hpp
index 1feed6d4..95374e3c 100644
--- a/iguana/yaml_writer.hpp
+++ b/iguana/yaml_writer.hpp
@@ -12,11 +12,11 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces = 0) {
 }
 
 template <bool Is_writing_escape = false, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s, size_t min_spaces = 0);
 
 template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int> = 0>
+          std::enable_if_t<ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
   ss.push_back('\n');
   to_yaml<Is_writing_escape>(std::forward<T>(t), ss, min_spaces);
@@ -119,12 +119,13 @@ template <bool Is_writing_escape, typename Stream, typename T,
           std::enable_if_t<tuple_v<T>, int> = 0>
 IGUANA_INLINE void render_yaml_value(Stream &ss, T &&t, size_t min_spaces) {
   ss.push_back('\n');
-  for_each(std::forward<T>(t),
-           [&ss, min_spaces](auto &v, auto i) IGUANA__INLINE_LAMBDA {
-             ss.append(min_spaces, ' ');
-             ss.append("- ");
-             render_yaml_value<Is_writing_escape>(ss, v, min_spaces + 1);
-           });
+  for_each_tuple(
+      [&ss, min_spaces](auto &v) IGUANA__INLINE_LAMBDA {
+        ss.append(min_spaces, ' ');
+        ss.append("- ");
+        render_yaml_value<Is_writing_escape>(ss, v, min_spaces + 1);
+      },
+      std::forward<T>(t));
 }
 
 template <bool Is_writing_escape, typename Stream, typename T,
@@ -165,36 +166,25 @@ IGUANA_INLINE void render_yaml_value(Stream &ss, const T &val,
   }
 }
 
-constexpr auto write_yaml_key = [](auto &s, auto i,
-                                   auto &t) IGUANA__INLINE_LAMBDA {
-  constexpr auto name = get_name<decltype(t), decltype(i)::value>();
-  s.append(name.data(), name.size());
-};
-
 template <bool Is_writing_escape, typename Stream, typename T,
-          std::enable_if_t<refletable_v<T>, int>>
+          std::enable_if_t<ylt_refletable_v<T>, int>>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s, size_t min_spaces) {
-  for_each(std::forward<T>(t),
-           [&t, &s, min_spaces](const auto &v, auto i) IGUANA__INLINE_LAMBDA {
-             using M = decltype(iguana_reflect_type(std::forward<T>(t)));
-             constexpr auto Idx = decltype(i)::value;
-             constexpr auto Count = M::value();
-             static_assert(Idx < Count);
-             s.append(min_spaces, ' ');
-             write_yaml_key(s, i, t);
-             s.append(": ");
-             if constexpr (!is_reflection<std::decay_t<decltype(v)>>::value) {
-               render_yaml_value<Is_writing_escape>(s, t.*v, min_spaces + 1);
-             }
-             else {
-               s.push_back('\n');
-               to_yaml<Is_writing_escape>(t.*v, s, min_spaces + 1);
-             }
-           });
+  ylt::reflection::for_each(t, [&](auto &field, auto field_name, auto index) {
+    s.append(min_spaces, ' ');
+    s.append(field_name);
+    s.append(": ");
+    if constexpr (!ylt_refletable_v<std::decay_t<decltype(field)>>) {
+      render_yaml_value<Is_writing_escape>(s, field, min_spaces + 1);
+    }
+    else {
+      s.push_back('\n');
+      to_yaml<Is_writing_escape>(field, s, min_spaces + 1);
+    }
+  });
 }
 
 template <bool Is_writing_escape = false, typename Stream, typename T,
-          std::enable_if_t<non_refletable_v<T>, int> = 0>
+          std::enable_if_t<non_ylt_refletable_v<T>, int> = 0>
 IGUANA_INLINE void to_yaml(T &&t, Stream &s) {
   if constexpr (tuple_v<T> || map_container_v<T> || sequence_container_v<T> ||
                 optional_v<T> || smart_ptr_v<T>)
diff --git a/iguana/ylt/reflection/internal/arg_list_macro.hpp b/iguana/ylt/reflection/internal/arg_list_macro.hpp
index 12cb82a1..d819ba57 100644
--- a/iguana/ylt/reflection/internal/arg_list_macro.hpp
+++ b/iguana/ylt/reflection/internal/arg_list_macro.hpp
@@ -7,5 +7,5 @@
 
 #define WRAP_ARGS_(w, object, ...)                  \
   YLT_CONCAT(WRAP_ARGS, YLT_ARG_COUNT(__VA_ARGS__)) \
-  (w, object, __VA_ARGS__)
-#define WRAP_ARGS(w, object, ...) WRAP_ARGS_(w, object, __VA_ARGS__)
\ No newline at end of file
+  (w, object, ##__VA_ARGS__)
+#define WRAP_ARGS(w, object, ...) WRAP_ARGS_(w, object, ##__VA_ARGS__)
\ No newline at end of file
diff --git a/iguana/ylt/reflection/internal/args_count.hpp b/iguana/ylt/reflection/internal/args_count.hpp
index ec93dd61..69d7a090 100644
--- a/iguana/ylt/reflection/internal/args_count.hpp
+++ b/iguana/ylt/reflection/internal/args_count.hpp
@@ -2,18 +2,45 @@
 
 #define YLT_MACRO_EXPAND(...) __VA_ARGS__
 
-#define YLT_ARG_COUNT(...)                                                     \
-  YLT_MACRO_EXPAND(YLT_ARG_COUNT_IMPL(                                         \
-      0, ##__VA_ARGS__, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, \
-      113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100,    \
-      99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82,  \
-      81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64,  \
-      63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46,  \
-      45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28,  \
-      27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  \
-      9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+#ifdef _MSC_VER  // Microsoft compilers
 
-#define YLT_ARG_COUNT_IMPL(                                                    \
+#define __NARGS(                                                               \
+    _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, \
+    _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+    _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, \
+    _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, \
+    _77, _78, _79, _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, \
+    _92, _93, _94, _95, _96, _97, _98, _99, _100, _101, _102, _103, _104,      \
+    _105, _106, _107, _108, _109, _110, _111, _112, _113, _114, _115, _116,    \
+    _117, _118, _119, _120, _121, _122, _123, _124, _125, N, ...)              \
+  N
+#define NARGS_1(...)                                                           \
+  YLT_MACRO_EXPAND(__NARGS(                                                    \
+      __VA_ARGS__, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, \
+      112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, \
+      97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80,  \
+      79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62,  \
+      61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44,  \
+      43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26,  \
+      25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, \
+      6, 5, 4, 3, 2, 1, 0))
+
+#define AUGMENTER(...) unused, __VA_ARGS__
+#define YLT_ARG_COUNT(...) NARGS_1(AUGMENTER(__VA_ARGS__))
+
+#else  // Others
+
+#define YLT_ARG_COUNT(...)                                                    \
+  __NARGS(0, ##__VA_ARGS__, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, \
+          114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102,    \
+          101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86,   \
+          85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, \
+          68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, \
+          51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, \
+          34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
+          17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#define __NARGS(                                                               \
     _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
     _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, \
     _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, \
@@ -24,3 +51,5 @@
     _105, _106, _107, _108, _109, _110, _111, _112, _113, _114, _115, _116,    \
     _117, _118, _119, _120, _121, _122, _123, _124, N, ...)                    \
   N
+
+#endif
diff --git a/iguana/ylt/reflection/member_names.hpp b/iguana/ylt/reflection/member_names.hpp
index fbaa5ad2..72c94168 100644
--- a/iguana/ylt/reflection/member_names.hpp
+++ b/iguana/ylt/reflection/member_names.hpp
@@ -7,6 +7,12 @@
 
 namespace ylt::reflection {
 
+template <typename T>
+struct ylt_alias_struct;
+
+template <typename T>
+inline constexpr auto get_alias_field_names();
+
 namespace internal {
 
 template <class T>
@@ -48,6 +54,39 @@ inline constexpr std::string_view get_member_name() {
 #endif
 }
 
+template <class T>
+struct member_tratis {};
+
+template <class T, class Owner>
+struct member_tratis<T Owner::*> {
+  using owner_type = Owner;
+  using value_type = T;
+};
+
+template <typename T, typename = void>
+struct has_alias_field_names_t : std::false_type {};
+
+template <typename T>
+struct has_alias_field_names_t<
+    T, std::void_t<decltype(ylt_alias_struct<T>::get_alias_field_names())>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool has_alias_field_names_v =
+    has_alias_field_names_t<T>::value;
+
+template <typename T, typename = void>
+struct has_alias_struct_names_t : std::false_type {};
+
+template <typename T>
+struct has_alias_struct_names_t<
+    T, std::void_t<decltype(ylt_alias_struct<T>::get_alias_struct_name())>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool has_alias_struct_name_v =
+    has_alias_struct_names_t<T>::value;
+
 template <typename T, typename U, size_t... Is>
 inline constexpr void init_arr_with_tuple(const T& tp, U& arr,
                                           std::index_sequence<Is...>) {
@@ -107,25 +146,22 @@ inline constexpr auto get_member_names_map() {
 }
 
 template <typename T, typename Tuple, size_t... Is>
-inline auto get_member_offset_arr_impl(Tuple& tp, std::index_sequence<Is...>) {
+inline auto get_member_offset_arr_impl(T& t, Tuple& tp,
+                                       std::index_sequence<Is...>) {
   std::array<size_t, sizeof...(Is)> arr;
-  ((arr[Is] = size_t((const char*)std::get<Is>(tp) -
-                     (char*)(&internal::wrapper<T>::value))),
-   ...);
+  ((arr[Is] = size_t((const char*)&std::get<Is>(tp) - (char*)(&t))), ...);
   return arr;
 }
 
 template <typename T>
-inline const auto& get_member_offset_arr() {
+inline const auto& get_member_offset_arr(T&& t) {
   constexpr size_t Count = members_count_v<T>;
-  constexpr auto tp = struct_to_tuple<T>();
+  auto tp = ylt::reflection::object_to_tuple(std::forward<T>(t));
 
 #if __cplusplus >= 202002L
   [[maybe_unused]] static std::array<size_t, Count> arr = {[&]<size_t... Is>(
       std::index_sequence<Is...>) mutable {std::array<size_t, Count> arr;
-  ((arr[Is] = size_t((const char*)std::get<Is>(tp) -
-                     (char*)(&internal::wrapper<T>::value))),
-   ...);
+  ((arr[Is] = size_t((const char*)&std::get<Is>(tp) - (char*)(&t))), ...);
   return arr;
 }
 (std::make_index_sequence<Count>{})
@@ -134,10 +170,15 @@ inline const auto& get_member_offset_arr() {
 return arr;
 #else
   [[maybe_unused]] static std::array<size_t, Count> arr =
-      get_member_offset_arr_impl<T>(tp, std::make_index_sequence<Count>{});
+      get_member_offset_arr_impl(t, tp, std::make_index_sequence<Count>{});
   return arr;
 #endif
 }  // namespace ylt::reflection
+
+template <typename T>
+inline const auto& get_member_offset_arr() {
+  return get_member_offset_arr(internal::wrapper<T>::value);
+}  // namespace ylt::reflection
 }  // namespace internal
 
 template <typename... Args>
@@ -153,10 +194,71 @@ template <typename T>
 constexpr auto member_names_map = internal::get_member_names_map<T>();
 
 template <typename T>
-constexpr auto member_names = internal::get_member_names<T>();
+inline auto member_offsets = internal::get_member_offset_arr<T>();
+
+template <auto member>
+inline constexpr size_t index_of() {
+  using T = typename internal::member_tratis<
+      std::remove_const_t<decltype(member)>>::owner_type;
+  constexpr auto name = field_string<member>();
+  constexpr auto names = internal::get_member_names<T>();
+  for (size_t i = 0; i < names.size(); i++) {
+    if (name == names[i]) {
+      return i;
+    }
+  }
+  return names.size();
+}
+
+template <size_t Idx>
+struct field_alias_t {
+  std::string_view alias_name;
+  inline static constexpr auto index = Idx;
+};
+
+template <typename Tuple, size_t... Is>
+inline constexpr auto get_alias_field_names_impl(Tuple& tp,
+                                                 std::index_sequence<Is...>) {
+  return std::array<std::pair<size_t, std::string_view>, sizeof...(Is)>{
+      std::make_pair(std::tuple_element_t<Is, std::decay_t<Tuple>>::index,
+                     std::get<Is>(tp).alias_name)...};
+}
 
 template <typename T>
-inline auto member_offsets = internal::get_member_offset_arr<T>();
+inline constexpr auto get_alias_field_names() {
+  if constexpr (internal::has_alias_field_names_v<T>) {
+    constexpr auto tp = ylt_alias_struct<T>::get_alias_field_names();
+    return get_alias_field_names_impl(
+        tp, std::make_index_sequence<std::tuple_size_v<decltype(tp)>>{});
+  }
+  else {
+    return std::array<std::string_view, 0>{};
+  }
+}
+
+template <typename T>
+constexpr std::string_view get_struct_name() {
+  if constexpr (internal::has_alias_struct_name_v<T>) {
+    return ylt_alias_struct<T>::get_alias_struct_name();
+  }
+  else {
+    return type_string<T>();
+  }
+}
+
+template <typename T>
+inline constexpr std::array<std::string_view, members_count_v<T>>
+get_member_names() {
+  auto arr = internal::get_member_names<T>();
+  using U = ylt::reflection::remove_cvref_t<T>;
+  if constexpr (internal::has_alias_field_names_v<U>) {
+    constexpr auto alias_arr = get_alias_field_names<U>();
+    for (size_t i = 0; i < alias_arr.size(); i++) {
+      arr[alias_arr[i].first] = alias_arr[i].second;
+    }
+  }
+  return arr;
+}
 
 template <std::size_t N>
 struct FixedString {
@@ -173,7 +275,7 @@ struct FixedString {
 
 template <typename T>
 inline constexpr size_t index_of(std::string_view name) {
-  constexpr auto& arr = member_names<T>;
+  constexpr auto arr = get_member_names<T>();
   for (size_t i = 0; i < arr.size(); i++) {
     if (arr[i] == name) {
       return i;
@@ -193,13 +295,13 @@ inline constexpr size_t index_of() {
 template <typename T, size_t index>
 inline constexpr std::string_view name_of() {
   static_assert(index < members_count_v<T>, "index out of range");
-  constexpr auto& arr = member_names<T>;
+  constexpr auto arr = get_member_names<T>();
   return arr[index];
 }
 
 template <typename T>
 inline constexpr std::string_view name_of(size_t index) {
-  constexpr auto& arr = member_names<T>;
+  constexpr auto arr = get_member_names<T>();
   if (index >= arr.size()) {
     return "";
   }
@@ -226,7 +328,7 @@ inline constexpr void for_each_impl(Visit&& func, U& arr,
 
 template <typename T, typename Visit>
 inline constexpr void for_each(Visit&& func) {
-  constexpr auto& arr = member_names<T>;
+  constexpr auto arr = get_member_names<T>();
 #if __cplusplus >= 202002L
   [&]<size_t... Is>(std::index_sequence<Is...>) mutable {
     if constexpr (std::is_invocable_v<Visit, std::string_view, size_t>) {
diff --git a/iguana/ylt/reflection/member_ptr.hpp b/iguana/ylt/reflection/member_ptr.hpp
index 2a847d8b..fec004ec 100644
--- a/iguana/ylt/reflection/member_ptr.hpp
+++ b/iguana/ylt/reflection/member_ptr.hpp
@@ -84,7 +84,7 @@ inline constexpr remove_cvref_t<T>& get_fake_object() noexcept {
 #include "member_macro.hpp"
 
 template <class T>
-inline constexpr auto tuple_view(T& t) {
+inline constexpr auto tuple_view(T&& t) {
   return internal::object_tuple_view_helper<T, members_count_v<T>>::tuple_view(
       t);
 }
@@ -124,8 +124,8 @@ inline constexpr decltype(auto) visit_members(T&& t, Visitor&& visitor) {
                               std::forward<Visitor>(visitor));
   }
   else if constexpr (is_inner_ylt_refl_v<type>) {
-    return type::refl_object_to_tuple(std::forward<T>(t),
-                                      std::forward<Visitor>(visitor));
+    return t.refl_visit_members(std::forward<T>(t),
+                                std::forward<Visitor>(visitor));
   }
   else {
     return internal::tuple_view<Count>(std::forward<T>(t),
diff --git a/iguana/ylt/reflection/member_value.hpp b/iguana/ylt/reflection/member_value.hpp
index 4f6ada49..483955c9 100644
--- a/iguana/ylt/reflection/member_value.hpp
+++ b/iguana/ylt/reflection/member_value.hpp
@@ -48,8 +48,49 @@ struct switch_helper {
     }
   }
 };
+
+inline constexpr frozen::string filter_str(const frozen::string& str) {
+  if (str.size() > 3 && str[0] == '_' && str[1] == '_' && str[2] == '_') {
+    auto ptr = str.data() + 3;
+    return frozen::string(ptr, str.size() - 3);
+  }
+  return str;
+}
+
+template <typename value_type>
+struct offset_t {
+  using type = value_type;
+  size_t value;
+};
+
+template <typename T, typename Tuple, size_t... Is>
+inline auto get_variant_type() {
+  return std::variant<offset_t<
+      ylt::reflection::remove_cvref_t<std::tuple_element_t<Is, Tuple>>>...>{};
+}
+
+template <typename T, size_t... Is>
+inline constexpr auto get_variant_map_impl(std::index_sequence<Is...>) {
+  using U = ylt::reflection::remove_cvref_t<T>;
+  constexpr auto arr = ylt::reflection::get_member_names<U>();
+  auto& offset_arr = get_member_offset_arr(wrapper<U>::value);
+  using Tuple = decltype(ylt::reflection::object_to_tuple(std::declval<U>()));
+  using ValueType = decltype(get_variant_type<U, Tuple, Is...>());
+  return frozen::unordered_map<frozen::string, ValueType, sizeof...(Is)>{
+      {filter_str(arr[Is]),
+       ValueType{std::in_place_index<Is>,
+                 offset_t<ylt::reflection::remove_cvref_t<
+                     std::tuple_element_t<Is, Tuple>>>{offset_arr[Is]}}}...};
+}
+
 }  // namespace internal
 
+template <typename T>
+inline constexpr auto get_variant_map() {
+  return internal::get_variant_map_impl<T>(
+      std::make_index_sequence<members_count_v<T>>{});
+}
+
 template <typename Member, typename T>
 inline Member& get(T& t, size_t index) {
   auto ref_tp = object_to_tuple(t);
@@ -138,7 +179,7 @@ inline size_t index_of(T& t, Field& value) {
 template <typename T, typename Field>
 inline constexpr std::string_view name_of(T& t, Field& value) {
   size_t index = index_of(t, value);
-  constexpr auto arr = member_names<T>;
+  constexpr auto arr = get_member_names<T>();
   if (index == arr.size()) {
     return "";
   }
@@ -146,11 +187,21 @@ inline constexpr std::string_view name_of(T& t, Field& value) {
   return arr[index];
 }
 
-template <typename Visit, typename U, size_t... Is, typename... Args>
-inline constexpr void visit_members_impl(Visit&& func, U& arr,
+template <typename T, typename Visit, typename U, size_t... Is,
+          typename... Args>
+inline constexpr void visit_members_impl0(Visit&& func,
+                                          std::index_sequence<Is...>,
+                                          Args&... args) {
+  constexpr auto arr = get_member_names<T>();
+  (func(args, arr[Is]), ...);
+}
+
+template <typename T, typename Visit, size_t... Is, typename... Args>
+inline constexpr void visit_members_impl(Visit&& func,
                                          std::index_sequence<Is...>,
                                          Args&... args) {
-  (func(args, arr[Is]), ...);
+  constexpr auto arr = get_member_names<T>();
+  (func(args, arr[Is], Is), ...);
 }
 
 template <typename T, typename Visit>
@@ -163,16 +214,18 @@ inline constexpr void for_each(T&& t, Visit&& func) {
     });
   }
   else {
-    constexpr auto arr = member_names<T>;
     if constexpr (std::is_invocable_v<Visit, first_t, std::string_view>) {
       visit_members(t, [&](auto&... args) {
 #if __cplusplus >= 202002L
         [&]<size_t... Is>(std::index_sequence<Is...>) mutable {
+          constexpr auto arr = get_member_names<T>();
           (func(args, arr[Is]), ...);
         }
-        (std::make_index_sequence<arr.size()>{});
+        (std::make_index_sequence<sizeof...(args)>{});
 #else
-          visit_members_impl(std::forward<Visit>(func), arr, std::make_index_sequence<arr.size()>{}, args...);
+            visit_members_impl0<T>(std::forward<Visit>(func),
+                                   std::make_index_sequence<sizeof...(args)>{},
+                                   args...);
 #endif
       });
     }
@@ -181,11 +234,14 @@ inline constexpr void for_each(T&& t, Visit&& func) {
       visit_members(t, [&](auto&... args) {
 #if __cplusplus >= 202002L
         [&]<size_t... Is>(std::index_sequence<Is...>) mutable {
+          constexpr auto arr = get_member_names<T>();
           (func(args, arr[Is], Is), ...);
         }
-        (std::make_index_sequence<arr.size()>{});
+        (std::make_index_sequence<sizeof...(args)>{});
 #else
-          visit_members_impl(std::forward<Visit>(func), arr, std::make_index_sequence<arr.size()>{}, args...);
+            visit_members_impl<T>(std::forward<Visit>(func),
+                                  std::make_index_sequence<sizeof...(args)>{},
+                                  args...);
 #endif
       });
     }
diff --git a/iguana/ylt/reflection/user_reflect_macro.hpp b/iguana/ylt/reflection/user_reflect_macro.hpp
index 9aeee665..7c7b96e3 100644
--- a/iguana/ylt/reflection/user_reflect_macro.hpp
+++ b/iguana/ylt/reflection/user_reflect_macro.hpp
@@ -6,6 +6,9 @@
 #include "internal/arg_list_macro.hpp"
 
 namespace ylt::reflection {
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
 template <class T>
 struct member_traits {
   using value_type = T;
@@ -24,23 +27,23 @@ using member_value_type_t = typename member_traits<T>::value_type;
   template <typename Visitor>                                               \
   inline static constexpr decltype(auto) refl_visit_members(                \
       STRUCT &t, Visitor &&visitor) {                                       \
-    return visitor(WRAP_ARGS(CONCAT_MEMBER, t, __VA_ARGS__));               \
+    return visitor(WRAP_ARGS(CONCAT_MEMBER, t, ##__VA_ARGS__));             \
   }                                                                         \
   template <typename Visitor>                                               \
   inline static constexpr decltype(auto) refl_visit_members(                \
       const STRUCT &t, Visitor &&visitor) {                                 \
-    return visitor(WRAP_ARGS(CONCAT_MEMBER, t, __VA_ARGS__));               \
+    return visitor(WRAP_ARGS(CONCAT_MEMBER, t, ##__VA_ARGS__));             \
   }                                                                         \
   inline static decltype(auto) refl_object_to_tuple(STRUCT &t) {            \
-    return std::tie(WRAP_ARGS(CONCAT_MEMBER, t, __VA_ARGS__));              \
+    return std::tie(WRAP_ARGS(CONCAT_MEMBER, t, ##__VA_ARGS__));            \
   }                                                                         \
   inline static decltype(auto) refl_object_to_tuple(const STRUCT &t) {      \
-    return std::tie(WRAP_ARGS(CONCAT_MEMBER, t, __VA_ARGS__));              \
+    return std::tie(WRAP_ARGS(CONCAT_MEMBER, t, ##__VA_ARGS__));            \
   }                                                                         \
   inline static constexpr decltype(auto) refl_member_names(                 \
       const ylt::reflection::identity<STRUCT> &t) {                         \
     constexpr std::array<std::string_view, YLT_ARG_COUNT(__VA_ARGS__)> arr{ \
-        WRAP_ARGS(CONCAT_NAME, t, __VA_ARGS__)};                            \
+        WRAP_ARGS(CONCAT_NAME, t, ##__VA_ARGS__)};                          \
     return arr;                                                             \
   }                                                                         \
   inline static constexpr std::size_t refl_member_count(                    \
@@ -78,7 +81,7 @@ inline static decltype(auto) refl_object_to_tuple_impl(T &&t) {
 #define YLT_REFL_PRIVATE_(STRUCT, ...)                                 \
   namespace ylt::reflection {                                          \
   inline constexpr auto get_private_ptrs(const identity<STRUCT> &t);   \
-  template struct private_visitor<STRUCT, __VA_ARGS__>;                \
+  template struct private_visitor<STRUCT, ##__VA_ARGS__>;              \
   template <typename Visitor>                                          \
   inline static constexpr decltype(auto) refl_visit_members(           \
       STRUCT &t, Visitor &&visitor) {                                  \
@@ -105,10 +108,10 @@ inline static decltype(auto) refl_object_to_tuple_impl(T &&t) {
   inline static constexpr decltype(auto) refl_member_names(                 \
       const ylt::reflection::identity<STRUCT> &t) {                         \
     constexpr std::array<std::string_view, YLT_ARG_COUNT(__VA_ARGS__)> arr{ \
-        WRAP_ARGS(CONCAT_NAME, t, __VA_ARGS__)};                            \
+        WRAP_ARGS(CONCAT_NAME, t, ##__VA_ARGS__)};                          \
     return arr;                                                             \
   }                                                                         \
-  YLT_REFL_PRIVATE_(STRUCT, WRAP_ARGS(CONCAT_ADDR, STRUCT, __VA_ARGS__))
+  YLT_REFL_PRIVATE_(STRUCT, WRAP_ARGS(CONCAT_ADDR, STRUCT, ##__VA_ARGS__))
 
 template <typename T, typename = void>
 struct is_out_ylt_refl : std::false_type {};
@@ -136,7 +139,7 @@ template <typename T, typename = void>
 struct is_ylt_refl : std::false_type {};
 
 template <typename T>
-inline constexpr bool is_ylt_refl_v = is_ylt_refl<T>::value;
+inline constexpr bool is_ylt_refl_v = is_ylt_refl<remove_cvref_t<T>>::value;
 
 template <typename T>
 struct is_ylt_refl<T, std::enable_if_t<is_inner_ylt_refl_v<T>>>
@@ -145,4 +148,16 @@ struct is_ylt_refl<T, std::enable_if_t<is_inner_ylt_refl_v<T>>>
 template <typename T>
 struct is_ylt_refl<T, std::enable_if_t<is_out_ylt_refl_v<T>>> : std::true_type {
 };
+
+template <typename T, typename = void>
+struct is_custom_reflect : std::false_type {};
+
+template <typename T>
+struct is_custom_reflect<
+    T, std::void_t<decltype(ylt_custom_reflect((T *)nullptr))>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool is_custom_refl_v =
+    is_custom_reflect<remove_cvref_t<T>>::value;
 }  // namespace ylt::reflection
diff --git a/test/proto/unittest_proto3.h b/test/proto/unittest_proto3.h
index 603affab..ebc4d175 100644
--- a/test/proto/unittest_proto3.h
+++ b/test/proto/unittest_proto3.h
@@ -54,9 +54,9 @@ struct BaseTypeMsg PUBLIC(BaseTypeMsg) {
            optional_enum == other.optional_enum;
   }
 };
-REFLECTION(BaseTypeMsg, optional_int32, optional_int64, optional_uint32,
-           optional_uint64, optional_float, optional_double, optional_bool,
-           optional_string, optional_enum);
+YLT_REFL(BaseTypeMsg, optional_int32, optional_int64, optional_uint32,
+         optional_uint64, optional_float, optional_double, optional_bool,
+         optional_string, optional_enum);
 
 struct IguanaTypeMsg PUBLIC(IguanaTypeMsg) {
   IguanaTypeMsg() = default;
@@ -85,8 +85,8 @@ struct IguanaTypeMsg PUBLIC(IguanaTypeMsg) {
            optional_sfixed64 == other.optional_sfixed64;
   }
 };
-REFLECTION(IguanaTypeMsg, optional_sint32, optional_sint64, optional_fixed32,
-           optional_fixed64, optional_sfixed32, optional_sfixed64);
+YLT_REFL(IguanaTypeMsg, optional_sint32, optional_sint64, optional_fixed32,
+         optional_fixed64, optional_sfixed32, optional_sfixed64);
 
 struct RepeatBaseTypeMsg PUBLIC(RepeatBaseTypeMsg) {
   RepeatBaseTypeMsg() = default;
@@ -112,9 +112,9 @@ struct RepeatBaseTypeMsg PUBLIC(RepeatBaseTypeMsg) {
   std::vector<Enum> repeated_enum;
 };
 
-REFLECTION(RepeatBaseTypeMsg, repeated_uint32, repeated_uint64, repeated_int32,
-           repeated_int64, repeated_float, repeated_double, repeated_string,
-           repeated_enum);
+YLT_REFL(RepeatBaseTypeMsg, repeated_uint32, repeated_uint64, repeated_int32,
+         repeated_int64, repeated_float, repeated_double, repeated_string,
+         repeated_enum);
 
 struct RepeatIguanaTypeMsg PUBLIC(RepeatIguanaTypeMsg) {
   RepeatIguanaTypeMsg() = default;
@@ -138,9 +138,9 @@ struct RepeatIguanaTypeMsg PUBLIC(RepeatIguanaTypeMsg) {
   std::vector<iguana::sfixed64_t> repeated_sfixed64;
 };
 
-REFLECTION(RepeatIguanaTypeMsg, repeated_sint32, repeated_sint64,
-           repeated_fixed32, repeated_fixed64, repeated_sfixed32,
-           repeated_sfixed64);
+YLT_REFL(RepeatIguanaTypeMsg, repeated_sint32, repeated_sint64,
+         repeated_fixed32, repeated_fixed64, repeated_sfixed32,
+         repeated_sfixed64);
 
 struct NestedMsg PUBLIC(NestedMsg) {
   NestedMsg() = default;
@@ -157,8 +157,8 @@ struct NestedMsg PUBLIC(NestedMsg) {
   std::vector<IguanaTypeMsg> repeat_iguna_msg;
   std::vector<RepeatBaseTypeMsg> repeat_repeat_base_msg;
 };
-REFLECTION(NestedMsg, base_msg, repeat_base_msg, iguana_type_msg,
-           repeat_iguna_msg, repeat_repeat_base_msg);
+YLT_REFL(NestedMsg, base_msg, repeat_base_msg, iguana_type_msg,
+         repeat_iguna_msg, repeat_repeat_base_msg);
 
 struct MapMsg PUBLIC(MapMsg) {
   MapMsg() = default;
@@ -172,8 +172,8 @@ struct MapMsg PUBLIC(MapMsg) {
   std::unordered_map<std::string, IguanaTypeMsg> str_iguana_type_msg_map{};
   std::map<int, RepeatBaseTypeMsg> int_repeat_base_msg_map{};
 };
-REFLECTION(MapMsg, sfix64_str_map, str_iguana_type_msg_map,
-           int_repeat_base_msg_map);
+YLT_REFL(MapMsg, sfix64_str_map, str_iguana_type_msg_map,
+         int_repeat_base_msg_map);
 
 struct BaseOneofMsg PUBLIC(BaseOneofMsg) {
   BaseOneofMsg() = default;
@@ -184,7 +184,7 @@ struct BaseOneofMsg PUBLIC(BaseOneofMsg) {
   std::variant<double, std::string, BaseTypeMsg> one_of;
   double optional_double;
 };
-REFLECTION(BaseOneofMsg, optional_int32, one_of, optional_double);
+YLT_REFL(BaseOneofMsg, optional_int32, one_of, optional_double);
 
 struct NestOneofMsg PUBLIC(NestOneofMsg) {
   NestOneofMsg() = default;
@@ -192,7 +192,7 @@ struct NestOneofMsg PUBLIC(NestOneofMsg) {
       : nest_one_of_msg(std::move(a)) {}
   std::variant<std::string, BaseOneofMsg> nest_one_of_msg;
 };
-REFLECTION(NestOneofMsg, nest_one_of_msg);
+YLT_REFL(NestOneofMsg, nest_one_of_msg);
 
 struct simple_t PUBLIC(simple_t) {
   simple_t() = default;
@@ -204,7 +204,7 @@ struct simple_t PUBLIC(simple_t) {
   int64_t d;
   std::string str;
 };
-REFLECTION(simple_t, a, b, c, d, str);
+YLT_REFL(simple_t, a, b, c, d, str);
 
 struct simple_t1 PUBLIC(simple_t1) {
   simple_t1() = default;
@@ -216,7 +216,7 @@ struct simple_t1 PUBLIC(simple_t1) {
   int64_t d;
   std::string_view str;
 };
-REFLECTION(simple_t1, a, b, c, d, str);
+YLT_REFL(simple_t1, a, b, c, d, str);
 
 enum Color : uint8_t { Red, Green, Blue };
 
@@ -230,7 +230,7 @@ struct simple_t2 PUBLIC(simple_t2) {
   int64_t d;
   std::string_view str;
 };
-REFLECTION(simple_t2, a, b, c, d, str);
+YLT_REFL(simple_t2, a, b, c, d, str);
 
 struct person PUBLIC(person) {
   person() = default;
@@ -241,7 +241,7 @@ struct person PUBLIC(person) {
   int age;
   double salary;
 };
-REFLECTION(person, id, name, age, salary);
+YLT_REFL(person, id, name, age, salary);
 
 struct rect PUBLIC(rect) {
   rect() = default;
@@ -252,7 +252,7 @@ struct rect PUBLIC(rect) {
   int32_t width = 11;
   int32_t height = 1;
 };
-REFLECTION(rect, x, y, width, height);
+YLT_REFL(rect, x, y, width, height);
 
 struct Vec3 PUBLIC(Vec3) {
   Vec3() = default;
@@ -261,7 +261,7 @@ struct Vec3 PUBLIC(Vec3) {
   float y;
   float z;
 
-  REFLECTION(Vec3, x, y, z);
+  YLT_REFL(Vec3, x, y, z);
 };
 
 struct Weapon PUBLIC(Weapon) {
@@ -270,7 +270,7 @@ struct Weapon PUBLIC(Weapon) {
   std::string name;
   int32_t damage;
 };
-REFLECTION(Weapon, name, damage);
+YLT_REFL(Weapon, name, damage);
 
 struct Monster PUBLIC(Monster) {
   Monster() = default;
@@ -295,8 +295,8 @@ struct Monster PUBLIC(Monster) {
   Weapon equipped;
   std::vector<Vec3> path;
 };
-REFLECTION(Monster, pos, mana, hp, name, inventory, color, weapons, equipped,
-           path);
+YLT_REFL(Monster, pos, mana, hp, name, inventory, color, weapons, equipped,
+         path);
 
 struct bench_int32 PUBLIC(bench_int32) {
   bench_int32() = default;
@@ -307,7 +307,7 @@ struct bench_int32 PUBLIC(bench_int32) {
   int32_t c;
   int32_t d;
 };
-REFLECTION(bench_int32, a, b, c, d);
+YLT_REFL(bench_int32, a, b, c, d);
 
 }  // namespace stpb
 
diff --git a/test/test_cpp20.cpp b/test/test_cpp20.cpp
new file mode 100644
index 00000000..49e3b7d7
--- /dev/null
+++ b/test/test_cpp20.cpp
@@ -0,0 +1,293 @@
+#define DOCTEST_CONFIG_IMPLEMENT
+#define SEQUENTIAL_PARSE
+#include "doctest.h"
+#include "iguana/iguana.hpp"
+
+using namespace ylt::reflection;
+
+struct point_t {
+  int x;
+  int y;
+};
+REQUIRED(point_t, x, y);
+YLT_REFL(point_t, x, y);
+
+struct point_t1 {
+  int x;
+  int y;
+};
+YLT_REFL(point_t1, x, y);
+
+template <>
+struct ylt::reflection::ylt_alias_struct<point_t1> {
+  static constexpr std::string_view get_alias_struct_name() { return "point"; }
+
+  static constexpr auto get_alias_field_names() {
+    return std::make_tuple(field_alias_t<0>{"X"}, field_alias_t<1>{"Y"});
+  }
+};
+struct test_variant {
+  test_variant() = default;
+  test_variant(int a, std::variant<double, std::string, int> b, double c)
+      : x(a), y(std::move(b)), z(c) {}
+  int x;
+  std::variant<double, std::string, int> y;
+  double z;
+};
+YLT_REFL(test_variant, x, y, z);
+
+struct test_variant1 {
+  std::variant<double, std::string, int> x;
+  int y;
+  double z;
+};
+YLT_REFL(test_variant1, x, y, z);
+
+struct test_variant2 {
+  int x;
+  double y;
+  std::variant<double, std::string, int> z;
+};
+YLT_REFL(test_variant2, x, y, z);
+
+struct test_variant3 {
+  int x;
+  std::variant<double, std::string, int> y;
+  int z;
+  std::variant<double, std::string, int> a;
+  double b;
+  double c;
+};
+YLT_REFL(test_variant3, x, y, z, a, b, c);
+
+struct test_variant4 {
+  test_variant4() = default;
+  test_variant4(int a, std::variant<double, std::string, int> b, double c)
+      : x(a), y(std::move(b)), z(c) {}
+
+  YLT_REFL(test_variant4, x, y, z);
+
+ private:
+  int x;
+  std::variant<double, std::string, int> y;
+  double z;
+};
+
+TEST_CASE("test pb") {
+  {
+    using Tuple1 = decltype(ylt::reflection::object_to_tuple(
+        std::declval<test_variant4>()));
+    std::cout << type_string<Tuple1>() << "\n";
+
+    test_variant4 t(1, "test", 3);
+    auto tp = iguana::detail::get_pb_members_tuple(t);
+
+    std::string proto;
+    iguana::to_proto<test_variant4>(proto);
+    std::cout << proto;
+
+    CHECK(std::get<0>(tp).field_no == 1);
+    CHECK(std::get<1>(tp).field_no == 2);
+    CHECK(std::get<2>(tp).field_no == 3);
+    CHECK(std::get<3>(tp).field_no == 4);
+    CHECK(std::get<4>(tp).field_no == 5);
+
+    std::string str;
+    iguana::to_pb(t, str);
+
+    test_variant4 t1;
+    iguana::from_pb(t1, str);
+    std::cout << "\n";
+  }
+  {
+    test_variant t(1, "test", 3);
+    auto tp = iguana::detail::get_pb_members_tuple(t);
+
+    CHECK(std::get<0>(tp).field_no == 1);
+    CHECK(std::get<1>(tp).field_no == 2);
+    CHECK(std::get<2>(tp).field_no == 3);
+    CHECK(std::get<3>(tp).field_no == 4);
+    CHECK(std::get<4>(tp).field_no == 5);
+  }
+
+  {
+    test_variant1 t{"test", 2, 3};
+    auto tp = iguana::detail::get_pb_members_tuple(t);
+
+    CHECK(std::get<0>(tp).field_no == 1);
+    CHECK(std::get<1>(tp).field_no == 2);
+    CHECK(std::get<2>(tp).field_no == 3);
+    CHECK(std::get<3>(tp).field_no == 4);
+    CHECK(std::get<4>(tp).field_no == 5);
+  }
+
+  {
+    test_variant2 t{2, 3, "test"};
+    auto tp = iguana::detail::get_pb_members_tuple(t);
+
+    CHECK(std::get<0>(tp).field_no == 1);
+    CHECK(std::get<1>(tp).field_no == 2);
+    CHECK(std::get<2>(tp).field_no == 3);
+    CHECK(std::get<3>(tp).field_no == 4);
+    CHECK(std::get<4>(tp).field_no == 5);
+  }
+
+  {
+    test_variant3 t{2, "test", 3, "ok", 5, 6};
+    auto tp = iguana::detail::get_pb_members_tuple(t);
+
+    CHECK(std::get<0>(tp).field_no == 1);
+    CHECK(std::get<1>(tp).field_no == 2);
+    CHECK(std::get<2>(tp).field_no == 3);
+    CHECK(std::get<3>(tp).field_no == 4);
+    CHECK(std::get<4>(tp).field_no == 5);
+    CHECK(std::get<5>(tp).field_no == 6);
+    CHECK(std::get<6>(tp).field_no == 7);
+    CHECK(std::get<7>(tp).field_no == 8);
+    CHECK(std::get<8>(tp).field_no == 9);
+    CHECK(std::get<9>(tp).field_no == 10);
+
+    std::string str;
+    iguana::to_pb(t, str);
+    std::cout << str.size() << "\n";
+
+    test_variant3 pt1;
+    iguana::from_pb(pt1, str);
+    std::cout << "\n";
+  }
+
+  point_t pt{1, 2};
+  std::string str;
+
+  iguana::to_pb(pt, str);
+  std::cout << str.size() << "\n";
+
+  point_t pt1;
+  iguana::from_pb(pt1, str);
+
+  std::string proto;
+  iguana::to_proto<test_variant3>(proto);
+  std::cout << proto;
+}
+
+TEST_CASE("test simple") {
+  point_t pt{1, 2};
+  std::string str;
+  static_assert(iguana::ylt_refletable_v<point_t>, "e");
+  iguana::to_json(pt, str);
+  std::cout << str << "\n";
+  static auto map = ylt::reflection::get_variant_map<point_t>();
+  for (auto& [key, var] : map) {
+    std::cout << key.data() << "\n";
+    std::visit(
+        [&](auto offset) {
+          using value_type = typename decltype(offset)::type;
+          auto member_ptr = (value_type*)((char*)(&pt) + offset.value);
+          std::cout << *member_ptr << "\n";
+        },
+        var);
+  }
+
+  point_t pt1;
+  iguana::from_json(pt1, str);
+  std::cout << pt1.x << "\n";
+}
+
+struct description_t {
+  iguana::xml_cdata_t<std::string> cdata;
+};
+YLT_REFL(description_t, cdata);
+struct node_t {
+  std::string title;
+  description_t description;
+  iguana::xml_cdata_t<> cdata;
+};
+YLT_REFL(node_t, title, description, cdata);
+TEST_CASE("test example cdata") {
+  auto validator = [](node_t node) {
+    CHECK(node.title == "what's the cdata");
+    CHECK(node.cdata.value() == "<p>this is a  cdata node</p>");
+    CHECK(node.description.cdata.value() ==
+          "<p>nest cdata node1 and </p>node2</p>");
+  };
+  std::string str = R"(
+    <?xml version="1.0" encoding="UTF-8"?>
+    <node_t>
+      <title>what's the cdata</title>
+      <description>
+        <![CDATA[<p>nest cdata node1 and </p>]]>
+        <!-- This is a comment -->
+        <![CDATA[ node2</p>]]>
+      </description>
+      <!DOCTYPE test node>
+      <?myapp instruction?>
+      <!-- <price>3.25</price> -->
+      <!-- <price a="b"/> -->
+      <![CDATA[<p>this is a  cdata node</p>]]>
+    </node_t>
+  )";
+  // only parse cdata node
+  node_t node;
+  iguana::from_xml(node, str);
+  validator(node);
+
+  {
+    std::string ss;
+    iguana::to_xml(node, ss);
+    node_t node1;
+    iguana::from_xml(node1, ss);
+    validator(node1);
+  }
+  {
+    std::string ss;
+    iguana::to_xml<true>(node, ss);
+    node_t node1;
+    iguana::from_xml(node1, ss);
+    validator(node1);
+  }
+}
+
+TEST_CASE("test xml") {
+  constexpr auto alias_names =
+      ylt::reflection::get_alias_field_names<point_t1>();
+  constexpr auto names = ylt::reflection::get_member_names<point_t1>();
+  constexpr auto st_name = ylt::reflection::get_struct_name<point_t1>();
+  CHECK(names == std::array<std::string_view, 2>{"X", "Y"});
+  CHECK(alias_names[0].second == "X");
+  CHECK(alias_names[1].second == "Y");
+  CHECK(st_name == "point");
+
+  constexpr auto name1 = ylt::reflection::get_struct_name<int>();
+  static_assert(name1 == "int");
+
+  point_t1 t{1, 3};
+  std::string xml;
+  iguana::to_xml(t, xml);
+  std::cout << xml << "\n";
+
+  point_t1 t1;
+  iguana::from_xml(t1, xml.begin(), xml.end());
+  std::cout << t1.x << "\n";
+
+  std::string json;
+  iguana::to_json(t, json);
+
+  point_t1 t2;
+  iguana::from_json(t2, json);
+  std::cout << t2.x << "\n";
+}
+
+TEST_CASE("test yaml") {
+  point_t t{1, 3};
+  std::string yaml;
+  iguana::to_yaml(t, yaml);
+  std::cout << yaml << "\n";
+
+  point_t t1;
+  iguana::from_yaml(t1, yaml.begin(), yaml.end());
+  std::cout << t1.x << "\n";
+}
+
+DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007)
+int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); }
+DOCTEST_MSVC_SUPPRESS_WARNING_POP
\ No newline at end of file
diff --git a/test/test_headers.h b/test/test_headers.h
index d921cee4..a61c2444 100644
--- a/test/test_headers.h
+++ b/test/test_headers.h
@@ -3,7 +3,7 @@
 #include <optional>
 #include <vector>
 
-#include "iguana/reflection.hpp"
+#include "iguana/ylt/reflection/user_reflect_macro.hpp"
 
 struct MyClass1 {
   double member0;
@@ -16,7 +16,7 @@ struct MyClass1 {
            member2 == rhs.member2 && member3 == rhs.member3;
   }
 };
-REFLECTION(MyClass1, member0, member1, member2, member3);
+YLT_REFL(MyClass1, member0, member1, member2, member3);
 
 struct MyClass2 {
   unsigned member_unsigned0;
@@ -29,38 +29,38 @@ struct MyClass2 {
            member_signed == rhs.member_signed;
   }
 };
-REFLECTION(MyClass2, member_unsigned0, member_unsigned1, member_signed);
+YLT_REFL(MyClass2, member_unsigned0, member_unsigned1, member_signed);
 
 struct person {
   std::string name;
   int age;
 };
-REFLECTION(person, name, age);
+YLT_REFL(person, name, age);
 
 // canada.json
 struct property_t {
   std::string name;
-}; // Property
-REFLECTION(property_t, name);
+};  // Property
+YLT_REFL(property_t, name);
 
 struct polygon_t {
   std::string type;
   std::vector<std::vector<std::array<double, 2>>> coordinates;
-}; // Polygon
-REFLECTION(polygon_t, type, coordinates);
+};  // Polygon
+YLT_REFL(polygon_t, type, coordinates);
 
 struct feature_t {
   std::string type;
   property_t properties;
   polygon_t geometry;
-}; // Feature
-REFLECTION(feature_t, type, properties, geometry);
+};  // Feature
+YLT_REFL(feature_t, type, properties, geometry);
 
 struct FeatureCollection {
   std::string type;
   std::vector<feature_t> features;
-}; // FeatureCollection
-REFLECTION(FeatureCollection, type, features);
+};  // FeatureCollection
+YLT_REFL(FeatureCollection, type, features);
 
 // apache_builds.json
 struct jobs_t {
@@ -68,16 +68,16 @@ struct jobs_t {
   std::string url;
   std::string color;
 };
-REFLECTION(jobs_t, name, url, color);
+YLT_REFL(jobs_t, name, url, color);
 
 struct views_t {
   std::string name;
   std::string url;
 };
-REFLECTION(views_t, name, url);
+YLT_REFL(views_t, name, url);
 
 struct apache_empty_t {};
-REFLECTION_EMPTY(apache_empty_t);
+YLT_REFL(apache_empty_t);
 
 struct apache_builds {
   std::vector<apache_empty_t> assignedLabels;
@@ -96,10 +96,10 @@ struct apache_builds {
   bool useSecurity;
   std::vector<views_t> views;
 };
-REFLECTION(apache_builds, assignedLabels, mode, nodeDescription, nodeName,
-           numExecutors, description, jobs, overallLoad, primaryView,
-           quietingDown, slaveAgentPort, unlabeledLoad, useCrumbs, useSecurity,
-           views);
+YLT_REFL(apache_builds, assignedLabels, mode, nodeDescription, nodeName,
+         numExecutors, description, jobs, overallLoad, primaryView,
+         quietingDown, slaveAgentPort, unlabeledLoad, useCrumbs, useSecurity,
+         views);
 
 // citm_catalog.json
 struct events_value_t {
@@ -111,28 +111,28 @@ struct events_value_t {
   std::optional<int64_t> subjectCode;
   std::optional<std::string> subtitle;
   std::vector<std::int64_t> topicIds;
-}; // events_value_t
-REFLECTION(events_value_t, description, id, logo, name, subTopicIds,
-           subjectCode, subtitle, topicIds);
+};  // events_value_t
+YLT_REFL(events_value_t, description, id, logo, name, subTopicIds, subjectCode,
+         subtitle, topicIds);
 
 struct prices_element_t {
   std::int64_t amount;
   std::int64_t audienceSubCategoryId;
   std::int64_t seatCategoryId;
-}; // prices_element_t
-REFLECTION(prices_element_t, amount, audienceSubCategoryId, seatCategoryId);
+};  // prices_element_t
+YLT_REFL(prices_element_t, amount, audienceSubCategoryId, seatCategoryId);
 
 struct areas_element_t {
   std::int64_t areaId;
   std::vector<int64_t> blockIds;
-}; // areas_element_t
-REFLECTION(areas_element_t, areaId, blockIds);
+};  // areas_element_t
+YLT_REFL(areas_element_t, areaId, blockIds);
 
 struct seatCategories_element_t {
   std::vector<areas_element_t> areas;
   std::int64_t seatCategoryId;
-}; // seatCategories_element_t
-REFLECTION(seatCategories_element_t, areas, seatCategoryId);
+};  // seatCategories_element_t
+YLT_REFL(seatCategories_element_t, areas, seatCategoryId);
 
 struct performances_element_t {
   std::int64_t eventId;
@@ -144,14 +144,14 @@ struct performances_element_t {
   std::optional<std::string> seatMapImage;
   std::int64_t start;
   std::string venueCode;
-}; // performances_element_t
-REFLECTION(performances_element_t, eventId, id, logo, name, prices,
-           seatCategories, seatMapImage, start, venueCode);
+};  // performances_element_t
+YLT_REFL(performances_element_t, eventId, id, logo, name, prices,
+         seatCategories, seatMapImage, start, venueCode);
 
 struct venueNames_t {
   std::string PLEYEL_PLEYEL;
-}; // venueNames_t
-REFLECTION(venueNames_t, PLEYEL_PLEYEL);
+};  // venueNames_t
+YLT_REFL(venueNames_t, PLEYEL_PLEYEL);
 
 struct citm_object_t {
   std::unordered_map<std::int64_t, std::string> areaNames;
@@ -165,38 +165,38 @@ struct citm_object_t {
   std::unordered_map<std::string, std::string> topicNames;
   std::unordered_map<std::string, std::vector<std::int64_t>> topicSubTopics;
   std::optional<venueNames_t> venueNames;
-}; // citm_object_t
-REFLECTION(citm_object_t, areaNames, audienceSubCategoryNames, blockNames,
-           events, performances, seatCategoryNames, subTopicNames, subjectNames,
-           topicNames, topicSubTopics, venueNames);
+};  // citm_object_t
+YLT_REFL(citm_object_t, areaNames, audienceSubCategoryNames, blockNames, events,
+         performances, seatCategoryNames, subTopicNames, subjectNames,
+         topicNames, topicSubTopics, venueNames);
 
 // gsoc-2018.json
 struct sponsor_t {
-  std::string type; //@
+  std::string type;  //@
   std::string name;
   std::string disambiguatingDescription;
   std::string description;
   std::string url;
   std::string logo;
 };
-REFLECTION(sponsor_t, type, name, disambiguatingDescription, description, url,
-           logo);
+YLT_REFL(sponsor_t, type, name, disambiguatingDescription, description, url,
+         logo);
 
 struct author_t {
-  std::string type; //@
+  std::string type;  //@
   std::string name;
 };
-REFLECTION(author_t, type, name);
+YLT_REFL(author_t, type, name);
 
 struct gsoc_element_t {
-  std::string context; //@
-  std::string type;    //@
+  std::string context;  //@
+  std::string type;     //@
   std::string name;
   std::string description;
   sponsor_t sponsor;
   author_t author;
 };
-REFLECTION(gsoc_element_t, context, type, name, description, sponsor, author);
+YLT_REFL(gsoc_element_t, context, type, name, description, sponsor, author);
 
 using gsoc_object_t = std::map<int, gsoc_element_t>;
 
@@ -206,7 +206,7 @@ struct mesh_element_t {
   std::vector<int> usedBones;
   std::vector<int> vertexRange;
 };
-REFLECTION(mesh_element_t, indexRange, usedBones, vertexRange);
+YLT_REFL(mesh_element_t, indexRange, usedBones, vertexRange);
 
 struct mesh_t {
   std::vector<mesh_element_t> batches;
@@ -218,8 +218,8 @@ struct mesh_t {
   std::vector<double> positions;
   std::vector<double> tex0;
 };
-REFLECTION(mesh_t, batches, colors, indices, influences, morphTargets, normals,
-           positions, tex0);
+YLT_REFL(mesh_t, batches, colors, indices, influences, morphTargets, normals,
+         positions, tex0);
 
 // random.json
 struct friend_t {
@@ -227,7 +227,7 @@ struct friend_t {
   std::string name;
   std::string phone;
 };
-REFLECTION(friend_t, id, name, phone);
+YLT_REFL(friend_t, id, name, phone);
 
 struct random_element_t {
   int id;
@@ -242,8 +242,8 @@ struct random_element_t {
   std::vector<friend_t> friends;
   std::string field;
 };
-REFLECTION(random_element_t, id, avatar, age, admin, name, company, phone,
-           email, birthDate, friends, field);
+YLT_REFL(random_element_t, id, avatar, age, admin, name, company, phone, email,
+         birthDate, friends, field);
 
 struct random_t {
   int id;
@@ -251,7 +251,7 @@ struct random_t {
   int total;
   std::vector<random_element_t> result;
 };
-REFLECTION(random_t, id, jsonrpc, total, result);
+YLT_REFL(random_t, id, jsonrpc, total, result);
 
 // github_events.json
 namespace githubEvents {
@@ -272,9 +272,9 @@ struct user_t {
   std::string followers_url;
   std::string following_url;
 };
-REFLECTION(user_t, gists_url, gravatar_id, url, type, avatar_url,
-           subscriptions_url, organizations_url, received_events_url, repos_url,
-           login, starred_url, id, events_url, followers_url, following_url);
+YLT_REFL(user_t, gists_url, gravatar_id, url, type, avatar_url,
+         subscriptions_url, organizations_url, received_events_url, repos_url,
+         login, starred_url, id, events_url, followers_url, following_url);
 
 struct page_t {
   std::string page_name;
@@ -284,14 +284,14 @@ struct page_t {
   std::optional<std::string> summary;
   std::string action;
 };
-REFLECTION(page_t, page_name, html_url, title, sha, summary, action);
+YLT_REFL(page_t, page_name, html_url, title, sha, summary, action);
 
 struct pull_request_t {
   std::optional<std::string> html_url;
   std::optional<std::string> patch_url;
   std::optional<std::string> diff_url;
 };
-REFLECTION(pull_request_t, html_url, patch_url, diff_url);
+YLT_REFL(pull_request_t, html_url, patch_url, diff_url);
 
 struct forkee_t {
   std::string full_name;
@@ -359,18 +359,18 @@ struct forkee_t {
   int watchers;
   std::string git_url;
 };
-REFLECTION(forkee_t, full_name, stargazers_url, clone_url, fork, url, tags_url,
-           description, merges_url, forks, language, ___private, archive_url,
-           collaborators_url, languages_url, owner, git_refs_url, labels_url,
-           pushed_at, html_url, trees_url, forks_url, commits_url, branches_url,
-           notifications_url, created_at, has_issues, blobs_url, issues_url,
-           open_issues, contents_url, name, statuses_url, assignees_url,
-           forks_count, updated_at, issue_events_url, ssh_url, subscribers_url,
-           mirror_url, ___public, has_wiki, git_commits_url, downloads_url, id,
-           pulls_url, has_downloads, issue_comment_url, watchers_count,
-           homepage, hooks_url, subscription_url, milestones_url, events_url,
-           svn_url, git_tags_url, teams_url, comments_url, open_issues_count,
-           keys_url, contributors_url, size, watchers, git_url, compare_url);
+YLT_REFL(forkee_t, full_name, stargazers_url, clone_url, fork, url, tags_url,
+         description, merges_url, forks, language, ___private, archive_url,
+         collaborators_url, languages_url, owner, git_refs_url, labels_url,
+         pushed_at, html_url, trees_url, forks_url, commits_url, branches_url,
+         notifications_url, created_at, has_issues, blobs_url, issues_url,
+         open_issues, contents_url, name, statuses_url, assignees_url,
+         forks_count, updated_at, issue_events_url, ssh_url, subscribers_url,
+         mirror_url, ___public, has_wiki, git_commits_url, downloads_url, id,
+         pulls_url, has_downloads, issue_comment_url, watchers_count, homepage,
+         hooks_url, subscription_url, milestones_url, events_url, svn_url,
+         git_tags_url, teams_url, comments_url, open_issues_count, keys_url,
+         contributors_url, size, watchers, git_url, compare_url);
 
 struct issue_t {
   user_t user;
@@ -393,9 +393,9 @@ struct issue_t {
   std::string events_url;
   std::string comments_url;
 };
-REFLECTION(issue_t, user, url, labels, html_url, labels_url, pull_request,
-           created_at, closed_at, milestone, title, body, updated_at, number,
-           state, assignee, id, comments, events_url, comments_url);
+YLT_REFL(issue_t, user, url, labels, html_url, labels_url, pull_request,
+         created_at, closed_at, milestone, title, body, updated_at, number,
+         state, assignee, id, comments, events_url, comments_url);
 
 struct comment_t {
   user_t user;
@@ -406,7 +406,7 @@ struct comment_t {
   std::string updated_at;
   int id;
 };
-REFLECTION(comment_t, user, url, issue_url, created_at, body, updated_at, id);
+YLT_REFL(comment_t, user, url, issue_url, created_at, body, updated_at, id);
 
 struct actor_org_t {
   std::string gravatar_id;
@@ -415,20 +415,20 @@ struct actor_org_t {
   std::string url;
   int id;
 };
-REFLECTION(actor_org_t, gravatar_id, login, avatar_url, url, id);
+YLT_REFL(actor_org_t, gravatar_id, login, avatar_url, url, id);
 
 struct repo_t {
   std::string url;
   int id;
   std::string name;
 };
-REFLECTION(repo_t, url, id, name);
+YLT_REFL(repo_t, url, id, name);
 
 struct author_t {
   std::string email;
   std::string name;
 };
-REFLECTION(author_t, email, name);
+YLT_REFL(author_t, email, name);
 
 struct commit_t {
   std::string url;
@@ -437,7 +437,7 @@ struct commit_t {
   std::string sha;
   author_t author;
 };
-REFLECTION(commit_t, url, message, distinct, sha, author);
+YLT_REFL(commit_t, url, message, distinct, sha, author);
 
 struct payload_t {
   std::optional<std::vector<commit_t>> commits;
@@ -457,9 +457,9 @@ struct payload_t {
 
   std::optional<std::string> ref_type;
 };
-REFLECTION(payload_t, commits, distinct_size, ref, push_id, head, before, size,
-           forkee, pages, action, comment, issue, description, master_branch,
-           ref_type);
+YLT_REFL(payload_t, commits, distinct_size, ref, push_id, head, before, size,
+         forkee, pages, action, comment, issue, description, master_branch,
+         ref_type);
 
 struct event_t {
   std::string type;
@@ -471,10 +471,10 @@ struct event_t {
   payload_t payload;
   std::string id;
 };
-REFLECTION(event_t, type, created_at, actor, repo, ___public, org, payload, id);
+YLT_REFL(event_t, type, created_at, actor, repo, ___public, org, payload, id);
 
 using events_t = std::vector<event_t>;
-} // namespace githubEvents
+}  // namespace githubEvents
 
 namespace marine_ik {
 struct image_element_t {
@@ -482,14 +482,14 @@ struct image_element_t {
   std::string uuid;
   std::string name;
 };
-REFLECTION(image_element_t, url, uuid, name);
+YLT_REFL(image_element_t, url, uuid, name);
 
 struct item_t {
   std::string name;
   std::string type;
   std::string uuid;
 };
-REFLECTION(item_t, name, type, uuid);
+YLT_REFL(item_t, name, type, uuid);
 
 struct key_element_t {
   std::array<float, 4> rot;
@@ -497,13 +497,13 @@ struct key_element_t {
   std::array<float, 3> scl;
   std::array<float, 3> pos;
 };
-REFLECTION(key_element_t, rot, time, scl, pos);
+YLT_REFL(key_element_t, rot, time, scl, pos);
 
 struct hierarchy_element_t {
   int parent;
   std::vector<key_element_t> keys;
 };
-REFLECTION(hierarchy_element_t, parent, keys);
+YLT_REFL(hierarchy_element_t, parent, keys);
 
 struct geo_anim_element_t {
   std::vector<hierarchy_element_t> hierarchy;
@@ -511,7 +511,7 @@ struct geo_anim_element_t {
   int fps{};
   std::string name;
 };
-REFLECTION(geo_anim_element_t, hierarchy, length, fps, name);
+YLT_REFL(geo_anim_element_t, hierarchy, length, fps, name);
 
 struct bone_element_t {
   int parent;
@@ -520,7 +520,7 @@ struct bone_element_t {
   std::array<int, 3> scl;
   std::string name;
 };
-REFLECTION(bone_element_t, parent, pos, rotq, scl, name);
+YLT_REFL(bone_element_t, parent, pos, rotq, scl, name);
 
 struct geo_meta_data_t {
   int uvs;
@@ -531,8 +531,8 @@ struct geo_meta_data_t {
   int bones;
   int vertices;
 };
-REFLECTION(geo_meta_data_t, uvs, version, faces, generator, normals, bones,
-           vertices);
+YLT_REFL(geo_meta_data_t, uvs, version, faces, generator, normals, bones,
+         vertices);
 
 struct geo_data_t {
   std::vector<std::vector<float>> uvs;
@@ -547,15 +547,15 @@ struct geo_data_t {
   std::vector<bone_element_t> bones;
   std::vector<int> faces;
 };
-REFLECTION(geo_data_t, uvs, animations, vertices, metadata, name, skinWeights,
-           skinIndices, influencesPerVertex, normals, bones, faces);
+YLT_REFL(geo_data_t, uvs, animations, vertices, metadata, name, skinWeights,
+         skinIndices, influencesPerVertex, normals, bones, faces);
 
 struct geometry_element_t {
   std::string type;
   std::string uuid;
   geo_data_t data;
 };
-REFLECTION(geometry_element_t, type, uuid, data);
+YLT_REFL(geometry_element_t, type, uuid, data);
 
 struct texture_element_t {
   std::array<int, 2> repeat;
@@ -568,8 +568,8 @@ struct texture_element_t {
   std::string uuid;
   int magFilter{};
 };
-REFLECTION(texture_element_t, repeat, wrap, anisotropy, image, name, mapping,
-           minFilter, uuid, magFilter);
+YLT_REFL(texture_element_t, repeat, wrap, anisotropy, image, name, mapping,
+         minFilter, uuid, magFilter);
 
 struct meta_data_t {
   std::string sourceFile;
@@ -577,7 +577,7 @@ struct meta_data_t {
   std::string type;
   float version{};
 };
-REFLECTION(meta_data_t, sourceFile, generator, type, version);
+YLT_REFL(meta_data_t, sourceFile, generator, type, version);
 
 struct material_element_t : item_t {
   int vertexColors{};
@@ -591,9 +591,9 @@ struct material_element_t : item_t {
   bool depthWrite{};
   int specular{};
 };
-REFLECTION(material_element_t, vertexColors, name, type, uuid, blending, map,
-           transparent, depthTest, color, shininess, emissive, depthWrite,
-           specular);
+YLT_REFL(material_element_t, vertexColors, name, type, uuid, blending, map,
+         transparent, depthTest, color, shininess, emissive, depthWrite,
+         specular);
 
 struct obj_child_t : item_t {
   std::array<float, 16> matrix;
@@ -603,8 +603,8 @@ struct obj_child_t : item_t {
   bool receiveShadow{};
   std::string geometry;
 };
-REFLECTION(obj_child_t, name, uuid, matrix, visible, type, material, castShadow,
-           receiveShadow, geometry);
+YLT_REFL(obj_child_t, name, uuid, matrix, visible, type, material, castShadow,
+         receiveShadow, geometry);
 
 struct object_t {
   std::vector<obj_child_t> children;
@@ -612,14 +612,14 @@ struct object_t {
   std::array<float, 16> matrix;
   std::string uuid;
 };
-REFLECTION(object_t, children, type, matrix, uuid);
+YLT_REFL(object_t, children, type, matrix, uuid);
 
 struct animation_element_t {
   std::vector<int> tracks;
   int fps;
   std::string name;
 };
-REFLECTION(animation_element_t, tracks, fps, name);
+YLT_REFL(animation_element_t, tracks, fps, name);
 
 struct marine_ik_t {
   std::vector<image_element_t> images;
@@ -630,9 +630,9 @@ struct marine_ik_t {
   object_t object;
   std::vector<animation_element_t> animations;
 };
-REFLECTION(marine_ik_t, images, geometries, textures, metadata, materials,
-           object, animations);
-} // namespace marine_ik
+YLT_REFL(marine_ik_t, images, geometries, textures, metadata, materials, object,
+         animations);
+}  // namespace marine_ik
 
 // instruments.json
 struct sample_element {
@@ -652,9 +652,9 @@ struct sample_element {
   int vibrato_type;
   int volume;
 };
-REFLECTION(sample_element, c5_samplerate, global_volume, legacy_filename,
-           length, loop_end, loop_start, name, pan, sustain_end, sustain_start,
-           vibrato_depth, vibrato_rate, vibrato_sweep, vibrato_type, volume);
+YLT_REFL(sample_element, c5_samplerate, global_volume, legacy_filename, length,
+         loop_end, loop_start, name, pan, sustain_end, sustain_start,
+         vibrato_depth, vibrato_rate, vibrato_sweep, vibrato_type, volume);
 
 struct data_t {
   int channel;
@@ -666,7 +666,7 @@ struct data_t {
   int volcmd;
   int volval;
 };
-REFLECTION(data_t, channel, fxcmd, fxparam, instr, note, row, volcmd, volval);
+YLT_REFL(data_t, channel, fxcmd, fxparam, instr, note, row, volcmd, volval);
 
 struct pattern_element {
   std::optional<std::vector<data_t>> data;
@@ -675,13 +675,13 @@ struct pattern_element {
   int rows_per_beat;
   int rows_per_measure;
 };
-REFLECTION(pattern_element, data, name, rows, rows_per_beat, rows_per_measure);
+YLT_REFL(pattern_element, data, name, rows, rows_per_beat, rows_per_measure);
 
 struct node_t {
   int tick;
   int value;
 };
-REFLECTION(node_t, tick, value);
+YLT_REFL(node_t, tick, value);
 
 struct panning_envelope_t {
   int loop_end;
@@ -691,8 +691,8 @@ struct panning_envelope_t {
   int sustain_end;
   int sustain_start;
 };
-REFLECTION(panning_envelope_t, loop_end, loop_start, nodes, release_node,
-           sustain_end, sustain_start);
+YLT_REFL(panning_envelope_t, loop_end, loop_start, nodes, release_node,
+         sustain_end, sustain_start);
 
 struct instrument_element {
   int default_filter_cutoff;
@@ -731,17 +731,16 @@ struct instrument_element {
   int volume_ramp_down;
   int volume_ramp_up;
 };
-REFLECTION(instrument_element, default_filter_cutoff,
-           default_filter_cutoff_enabled, default_filter_mode,
-           default_filter_resonance, default_filter_resonance_enabled,
-           default_pan, duplicate_check_type, duplicate_note_action, fadeout,
-           global_volume, graph_insert, legacy_filename, midi_bank,
-           midi_channel, midi_drum_set, midi_program, name, new_note_action,
-           note_map, panning_envelope, pitch_envelope, pitch_pan_center,
-           pitch_pan_separation, pitch_to_tempo_lock, random_cutoff_weight,
-           random_pan_weight, random_resonance_weight, random_volume_weight,
-           sample_map, tuning, volume_envelope, volume_ramp_down,
-           volume_ramp_up);
+YLT_REFL(instrument_element, default_filter_cutoff,
+         default_filter_cutoff_enabled, default_filter_mode,
+         default_filter_resonance, default_filter_resonance_enabled,
+         default_pan, duplicate_check_type, duplicate_note_action, fadeout,
+         global_volume, graph_insert, legacy_filename, midi_bank, midi_channel,
+         midi_drum_set, midi_program, name, new_note_action, note_map,
+         panning_envelope, pitch_envelope, pitch_pan_center,
+         pitch_pan_separation, pitch_to_tempo_lock, random_cutoff_weight,
+         random_pan_weight, random_resonance_weight, random_volume_weight,
+         sample_map, tuning, volume_envelope, volume_ramp_down, volume_ramp_up);
 
 struct instruments_t {
   std::optional<int> graphstate;
@@ -754,5 +753,5 @@ struct instruments_t {
   std::vector<sample_element> samples;
   int version;
 };
-REFLECTION(instruments_t, graphstate, instruments, message, name, orderlist,
-           patterns, pluginstate, samples, version);
+YLT_REFL(instruments_t, graphstate, instruments, message, name, orderlist,
+         patterns, pluginstate, samples, version);
diff --git a/test/test_json_files.cpp b/test/test_json_files.cpp
index 1cf61a10..035c5b48 100644
--- a/test/test_json_files.cpp
+++ b/test/test_json_files.cpp
@@ -2,7 +2,6 @@
 #include <stdexcept>
 #include <vector>
 
-#include "iguana/reflection.hpp"
 #include "iguana/value.hpp"
 #define DOCTEST_CONFIG_IMPLEMENT
 #include <filesystem>
diff --git a/test/test_pb.cpp b/test/test_pb.cpp
index 7e85aa1b..0b9b2d8e 100644
--- a/test/test_pb.cpp
+++ b/test/test_pb.cpp
@@ -4,6 +4,7 @@
 #include <memory>
 #include <optional>
 
+#include "iguana/dynamic.hpp"
 #include "iguana/pb_writer.hpp"
 
 #define DOCTEST_CONFIG_IMPLEMENT
@@ -28,7 +29,7 @@ struct point_t {
   int x;
   double y;
 };
-REFLECTION(point_t, x, y);
+YLT_REFL(point_t, x, y);
 
 namespace my_space {
 struct inner_struct {
@@ -39,10 +40,10 @@ struct inner_struct {
   int z;
 };
 
-constexpr inline auto get_members_impl(inner_struct *) {
-  return std::make_tuple(iguana::field_t{&inner_struct::x, 7, "a"},
-                         iguana::field_t{&inner_struct::y, 9, "b"},
-                         iguana::field_t{&inner_struct::z, 12, "c"});
+inline auto get_members_impl(inner_struct *) {
+  return std::make_tuple(iguana::build_pb_field<&inner_struct::x, 7>("a"),
+                         iguana::build_pb_field<&inner_struct::y, 9>("b"),
+                         iguana::build_pb_field<&inner_struct::z, 12>("c"));
 }
 }  // namespace my_space
 
@@ -54,14 +55,14 @@ struct test_pb_st1 {
   iguana::sint32_t y;
   iguana::sint64_t z;
 };
-REFLECTION(test_pb_st1, x, y, z);
+YLT_REFL(test_pb_st1, x, y, z);
 
 struct test_pb_sts PUBLIC(test_pb_sts) {
   test_pb_sts() = default;
   test_pb_sts(std::vector<test_pb_st1> l) : list(std::move(l)) {}
   std::vector<test_pb_st1> list;
 };
-REFLECTION(test_pb_sts, list);
+YLT_REFL(test_pb_sts, list);
 
 struct test_pb_st2 {
   test_pb_st2() = default;
@@ -71,7 +72,7 @@ struct test_pb_st2 {
   iguana::fixed32_t y;
   iguana::fixed64_t z;
 };
-REFLECTION(test_pb_st2, x, y, z);
+YLT_REFL(test_pb_st2, x, y, z);
 
 struct test_pb_st3 {
   test_pb_st3() = default;
@@ -81,7 +82,7 @@ struct test_pb_st3 {
   iguana::sfixed32_t y;
   iguana::sfixed64_t z;
 };
-REFLECTION(test_pb_st3, x, y, z);
+YLT_REFL(test_pb_st3, x, y, z);
 
 struct test_pb_st4 {
   test_pb_st4() = default;
@@ -89,7 +90,7 @@ struct test_pb_st4 {
   int x;
   std::string y;
 };
-REFLECTION(test_pb_st4, x, y);
+YLT_REFL(test_pb_st4, x, y);
 
 struct test_pb_st5 {
   test_pb_st5() = default;
@@ -97,7 +98,7 @@ struct test_pb_st5 {
   int x;
   std::string_view y;
 };
-REFLECTION(test_pb_st5, x, y);
+YLT_REFL(test_pb_st5, x, y);
 
 struct test_pb_st6 {
   test_pb_st6() = default;
@@ -106,15 +107,18 @@ struct test_pb_st6 {
   std::optional<int> x;
   std::optional<std::string> y;
 };
-REFLECTION(test_pb_st6, x, y);
+YLT_REFL(test_pb_st6, x, y);
 
-struct pair_t : public iguana::base_impl<pair_t, iguana::ENABLE_ALL> {
+struct pair_t
+    : public iguana::base_impl<pair_t, iguana::ENABLE_XML | iguana::ENABLE_PB |
+                                           iguana::ENABLE_YAML |
+                                           iguana::ENABLE_JSON> {
   pair_t() = default;
   pair_t(int a, int b) : x(a), y(b) {}
   int x;
   int y;
 };
-REFLECTION(pair_t, x, y);
+YLT_REFL(pair_t, x, y);
 
 struct message_t PUBLIC(message_t) {
   message_t() = default;
@@ -122,7 +126,7 @@ struct message_t PUBLIC(message_t) {
   int id;
   pair_t t;
 };
-REFLECTION(message_t, id, t);
+YLT_REFL(message_t, id, t);
 
 struct test_pb_st8 {
   test_pb_st8() = default;
@@ -132,7 +136,7 @@ struct test_pb_st8 {
   pair_t y;
   message_t z;
 };
-REFLECTION(test_pb_st8, x, y, z);
+YLT_REFL(test_pb_st8, x, y, z);
 
 struct test_pb_st9 {
   test_pb_st9() = default;
@@ -142,7 +146,7 @@ struct test_pb_st9 {
   std::vector<int> y;
   std::string z;
 };
-REFLECTION(test_pb_st9, x, y, z);
+YLT_REFL(test_pb_st9, x, y, z);
 
 struct test_pb_st10 {
   test_pb_st10() = default;
@@ -152,7 +156,7 @@ struct test_pb_st10 {
   std::vector<message_t> y;
   std::string z;
 };
-REFLECTION(test_pb_st10, x, y, z);
+YLT_REFL(test_pb_st10, x, y, z);
 
 struct test_pb_st11 PUBLIC(test_pb_st11) {
   test_pb_st11() = default;
@@ -163,7 +167,7 @@ struct test_pb_st11 PUBLIC(test_pb_st11) {
   std::vector<std::optional<message_t>> y;
   std::vector<std::string> z;
 };
-REFLECTION(test_pb_st11, x, y, z);
+YLT_REFL(test_pb_st11, x, y, z);
 
 struct test_pb_st12 {
   test_pb_st12() = default;
@@ -175,7 +179,7 @@ struct test_pb_st12 {
   std::map<int, std::string> y;
   std::map<std::string, int> z;
 };
-REFLECTION(test_pb_st12, x, y, z);
+YLT_REFL(test_pb_st12, x, y, z);
 
 struct test_pb_st13 {
   test_pb_st13() = default;
@@ -186,7 +190,7 @@ struct test_pb_st13 {
   std::map<int, message_t> y;
   std::string z;
 };
-REFLECTION(test_pb_st13, x, y, z);
+YLT_REFL(test_pb_st13, x, y, z);
 
 enum class colors_t { red, black };
 
@@ -199,7 +203,7 @@ struct test_pb_st14 {
   colors_t y;
   level_t z;
 };
-REFLECTION(test_pb_st14, x, y, z);
+YLT_REFL(test_pb_st14, x, y, z);
 
 namespace client {
 struct person {
@@ -209,10 +213,12 @@ struct person {
   int64_t age;
 };
 
-REFLECTION(person, name, age);
+YLT_REFL(person, name, age);
 }  // namespace client
 
-struct my_struct {
+struct my_struct PUBLIC(my_struct) {
+  my_struct() = default;
+  my_struct(int a, bool b, iguana::fixed64_t c) : x(a), y(b), z(c) {}
   int x;
   bool y;
   iguana::fixed64_t z;
@@ -220,7 +226,7 @@ struct my_struct {
     return x == other.x && y == other.y && z == other.z;
   }
 };
-REFLECTION(my_struct, x, y, z);
+YLT_REFL(my_struct, x, y, z);
 
 struct nest1 PUBLIC(nest1) {
   nest1() = default;
@@ -231,7 +237,7 @@ struct nest1 PUBLIC(nest1) {
   int var;
   std::variant<int, double> mv;
 };
-REFLECTION(nest1, name, value, var, mv);
+YLT_REFL(nest1, name, value, var, mv);
 
 struct numer_st PUBLIC(numer_st) {
   numer_st() = default;
@@ -240,7 +246,7 @@ struct numer_st PUBLIC(numer_st) {
   double b;
   float c;
 };
-REFLECTION(numer_st, a, b, c);
+YLT_REFL(numer_st, a, b, c);
 
 struct MyPerson : public iguana::base_impl<MyPerson, iguana::ENABLE_JSON> {
   MyPerson() = default;
@@ -252,7 +258,7 @@ struct MyPerson : public iguana::base_impl<MyPerson, iguana::ENABLE_JSON> {
   }
 };
 
-REFLECTION(MyPerson, name, age);
+YLT_REFL(MyPerson, name, age);
 struct person PUBLIC(person) {
   person() = default;
   person(int32_t a, std::string b, int c, double d)
@@ -262,7 +268,7 @@ struct person PUBLIC(person) {
   int age;
   double salary;
 };
-REFLECTION(person, id, name, age, salary);
+YLT_REFL(person, id, name, age, salary);
 
 enum Color { Red = 0, Black = 2, Green = 4 };
 
@@ -284,7 +290,7 @@ struct vector_t {
   std::string name;
   std::optional<int> op_val;
 };
-REFLECTION(vector_t, id, color, variant, ids, pairs, strs, map, name, op_val);
+YLT_REFL(vector_t, id, color, variant, ids, pairs, strs, map, name, op_val);
 
 #if defined(__clang__) || defined(_MSC_VER) || \
     (defined(__GNUC__) && __GNUC__ > 8)
@@ -348,8 +354,31 @@ TEST_CASE("struct to proto") {
 }
 #endif
 
-TEST_CASE("test reflection") {
+TEST_CASE("test YLT_REFL") {
   {
+    my_struct temp_my{1, false, {3}};
+    nest1 t{"Hi", temp_my, 5};
+
+    auto const temp_variant = std::variant<int, double>{1};
+    t.set_field_value("mv", temp_variant);
+
+    // dynamic any
+    auto const &any_name = t.get_field_any("name");
+    assert(std::any_cast<std::string>(any_name) == "Hi");
+
+    auto const &any_value = t.get_field_any("value");
+    assert(std::any_cast<my_struct>(any_value) == temp_my);
+
+    auto const &any_var = t.get_field_any("var");
+    assert(std::any_cast<int>(any_var) == 5);
+
+    auto const &mvariant_any = t.get_field_any("mv");
+    auto const &mvariant =
+        std::any_cast<std::variant<int, double>>(mvariant_any);
+    assert(mvariant == temp_variant);
+  }
+  {
+    std::cout << "test\n";
     auto t = iguana::create_instance("nest1");
     std::vector<std::string_view> fields_name = t->get_fields_name();
     CHECK(fields_name ==
@@ -375,28 +404,7 @@ TEST_CASE("test reflection") {
 
     CHECK_THROWS_AS(t->set_field_value<int>("name", 42), std::invalid_argument);
   }
-  {
-    my_struct temp_my{1, false, {3}};
-    nest1 t{"Hi", temp_my, 5};
-
-    auto const temp_variant = std::variant<int, double>{1};
-    t.set_field_value("mv", temp_variant);
-
-    // dynamic any
-    auto const &any_name = t.get_field_any("name");
-    assert(std::any_cast<std::string>(any_name) == "Hi");
-
-    auto const &any_value = t.get_field_any("value");
-    assert(std::any_cast<my_struct>(any_value) == temp_my);
-
-    auto const &any_var = t.get_field_any("var");
-    assert(std::any_cast<int>(any_var) == 5);
 
-    auto const &mvariant_any = t.get_field_any("mv");
-    auto const &mvariant =
-        std::any_cast<std::variant<int, double>>(mvariant_any);
-    assert(mvariant == temp_variant);
-  }
   {
     // to_json is an const member_function now
     MyPerson const p1{"xiaoming", 10};
@@ -437,15 +445,15 @@ TEST_CASE("test reflection") {
     CHECK(st->x == s.x);
     CHECK(st->y == s.y);
 
-    std::string json;
-    t->to_json(json);
-    std::cout << json << "\n";
+    // std::string json;
+    // t->to_json(json);
+    // std::cout << json << "\n";
 
-    s = {};
-    s.from_json(json);
-    std::cout << s.x << " " << s.y << "\n";
-    CHECK(st->x == s.x);
-    CHECK(st->y == s.y);
+    // s = {};
+    // s.from_json(json);
+    // std::cout << s.x << " " << s.y << "\n";
+    // CHECK(st->x == s.x);
+    // CHECK(st->y == s.y);
 
     std::string yaml;
     t->to_yaml(yaml);
@@ -485,18 +493,18 @@ TEST_CASE("test reflection") {
 }
 
 TEST_CASE("test struct_pb") {
-  {
-    my_space::inner_struct inner{41, 42, 43};
+  // {
+  //   my_space::inner_struct inner{41, 42, 43};
 
-    std::string str;
-    iguana::to_pb(inner, str);
+  //   std::string str;
+  //   iguana::to_pb(inner, str);
 
-    my_space::inner_struct inner1;
-    iguana::from_pb(inner1, str);
-    CHECK(inner.x == inner1.x);
-    CHECK(inner.y == inner1.y);
-    CHECK(inner.z == inner1.z);
-  }
+  //   my_space::inner_struct inner1;
+  //   iguana::from_pb(inner1, str);
+  //   CHECK(inner.x == inner1.x);
+  //   CHECK(inner.y == inner1.y);
+  //   CHECK(inner.z == inner1.z);
+  // }
 
   {
     test_pb_sts p{};
@@ -736,7 +744,7 @@ TEST_CASE("test members") {
   using namespace iguana::detail;
 
   my_space::inner_struct inner{41, 42, 43};
-  const auto &map = iguana::get_members<my_space::inner_struct>();
+  const auto &map = detail::get_members(inner);
   std::visit(
       [&inner](auto &member) mutable {
         CHECK(member.field_no == 9);
@@ -746,7 +754,7 @@ TEST_CASE("test members") {
       map.at(9));
 
   point_t pt{2, 3};
-  const auto &arr1 = iguana::get_members<point_t>();
+  const auto &arr1 = detail::get_members(pt);
   auto &val = arr1.at(1);
   std::visit(
       [&pt](auto &member) mutable {
@@ -765,38 +773,38 @@ struct test_variant {
   std::variant<double, std::string, int> y;
   double z;
 };
-REFLECTION(test_variant, x, y, z);
+YLT_REFL(test_variant, x, y, z);
 
 TEST_CASE("test variant") {
-  {
-    constexpr auto tp = iguana::get_members_tuple<test_variant>();
-    static_assert(std::get<0>(tp).field_no == 1);
-    static_assert(std::get<1>(tp).field_no == 2);
-    static_assert(std::get<2>(tp).field_no == 3);
-    static_assert(std::get<3>(tp).field_no == 4);
-    static_assert(std::get<4>(tp).field_no == 5);
-  }
-  {
-    constexpr static auto map = iguana::get_members<test_variant>();
-    static_assert(map.find(1) != map.end());
-    static_assert(map.find(2) != map.end());
-    static_assert(map.find(3) != map.end());
-    static_assert(map.find(4) != map.end());
-    auto val1 = map.find(2);
-    auto val2 = map.find(3);
-    std::visit(
-        [](auto &member) mutable {
-          CHECK(member.field_no == 2);
-          CHECK(member.field_name == "y");
-        },
-        val1->second);
-    std::visit(
-        [](auto &member) mutable {
-          CHECK(member.field_no == 3);
-          CHECK(member.field_name == "y");
-        },
-        val2->second);
-  }
+  // {
+  //   constexpr auto tp = detail::get_members_tuple<test_variant>();
+  //   static_assert(std::get<0>(tp).field_no == 1);
+  //   static_assert(std::get<1>(tp).field_no == 2);
+  //   static_assert(std::get<2>(tp).field_no == 3);
+  //   static_assert(std::get<3>(tp).field_no == 4);
+  //   static_assert(std::get<4>(tp).field_no == 5);
+  // }
+  // {
+  //   constexpr static auto map = detail::get_members<test_variant>();
+  //   static_assert(map.find(1) != map.end());
+  //   static_assert(map.find(2) != map.end());
+  //   static_assert(map.find(3) != map.end());
+  //   static_assert(map.find(4) != map.end());
+  //   auto val1 = map.find(2);
+  //   auto val2 = map.find(3);
+  //   std::visit(
+  //       [](auto &member) mutable {
+  //         CHECK(member.field_no == 2);
+  //         CHECK(member.field_name == "y");
+  //       },
+  //       val1->second);
+  //   std::visit(
+  //       [](auto &member) mutable {
+  //         CHECK(member.field_no == 3);
+  //         CHECK(member.field_name == "y");
+  //       },
+  //       val2->second);
+  // }
   {
     test_variant st1 = {5, "Hello, variant!", 3.14};
     std::string str;
diff --git a/test/test_reflection.cpp b/test/test_reflection.cpp
index cc3c2c32..f4f44478 100644
--- a/test/test_reflection.cpp
+++ b/test/test_reflection.cpp
@@ -45,7 +45,7 @@ TEST_CASE("test member names") {
   CHECK(tp_size == 5);
 
 #if __has_include(<concetps>)
-  constexpr auto arr = member_names<person>;
+  constexpr auto arr = get_member_names<person>();
   for (auto name : arr) {
     std::cout << name << ", ";
   }
@@ -94,7 +94,7 @@ void test_pt() {
 TEST_CASE("test member value") {
   simple p{.color = 2, .id = 10, .str = "hello reflection", .age = 6};
   auto ref_tp = object_to_tuple(p);
-  constexpr auto arr = member_names<simple>;
+  constexpr auto arr = get_member_names<simple>();
   std::stringstream out;
   [&]<size_t... Is>(std::index_sequence<Is...>) {
     ((out << "name: " << arr[Is] << ", value: " << std::get<Is>(ref_tp)
@@ -308,7 +308,13 @@ YLT_REFL(simple2, color, id, str, age);
 TEST_CASE("test macros") {
   static_assert(!std::is_aggregate_v<simple2>);
   simple2 t{2, 10, "hello reflection", 6};
-  constexpr auto arr = member_names<simple2>;
+#ifdef __GNUC__
+  constexpr auto idx = index_of<&simple2::age>();
+  static_assert(idx == 3);
+  constexpr auto idx2 = index_of<&simple2::id>();
+  static_assert(idx2 == 1);
+#endif
+  constexpr auto arr = get_member_names<simple2>();
   static_assert(arr.size() == 4);
   constexpr auto map = member_names_map<simple2>;
   constexpr size_t index = map.at("age");
diff --git a/test/test.cpp b/test/test_some.cpp
similarity index 84%
rename from test/test.cpp
rename to test/test_some.cpp
index e45fe7f4..97c4f0a8 100644
--- a/test/test.cpp
+++ b/test/test_some.cpp
@@ -1,10 +1,4 @@
-#include <cstddef>
-#include <string>
-#include <vector>
-
-#include "iguana/reflection.hpp"
 #define DOCTEST_CONFIG_IMPLEMENT
-#include <iguana/json_util.hpp>
 #include <iguana/json_writer.hpp>
 #include <iostream>
 #include <optional>
@@ -18,7 +12,7 @@ struct point_t {
   int x;
   double y;
 };
-REFLECTION(point_t, x, y);
+YLT_REFL(point_t, x, y);
 
 struct person {
   std::string name;
@@ -27,74 +21,74 @@ struct person {
     return name == rhs.name && ok == rhs.ok;
   }
 };
-REFLECTION(person, name, ok);
+YLT_REFL(person, name, ok);
 
 struct bool_t {
   bool ok;
 };
-REFLECTION(bool_t, ok);
+YLT_REFL(bool_t, ok);
 
 struct optional_t {
   std::optional<bool> p;
 };
-REFLECTION(optional_t, p);
+YLT_REFL(optional_t, p);
 
 struct char_t {
   char ch;
 };
-REFLECTION(char_t, ch);
+YLT_REFL(char_t, ch);
 
 // nested object
 struct simple_nested_t {
   int id;
   person p;
 };
-REFLECTION(simple_nested_t, id, p);
+YLT_REFL(simple_nested_t, id, p);
 
 // c array
 struct arr_t {
   int arr[2];
 };
-REFLECTION(arr_t, arr);
+YLT_REFL(arr_t, arr);
 
 // std array
 struct std_array_t {
   std::array<int, 2> arr;
 };
-REFLECTION(std_array_t, arr);
+YLT_REFL(std_array_t, arr);
 
 // vector
 struct vector_t {
   std::vector<int> arr;
 };
-REFLECTION(vector_t, arr);
+YLT_REFL(vector_t, arr);
 
 struct two_fields_t {
   std::array<int, 2> a;
   std::vector<std::string> v;
 };
-REFLECTION(two_fields_t, a, v);
+YLT_REFL(two_fields_t, a, v);
 
 struct map_t {
   std::map<int, std::string> map1;
   std::unordered_map<int, std::string> map2;
 };
-REFLECTION(map_t, map1, map2);
+YLT_REFL(map_t, map1, map2);
 
 struct list_t {
   std::list<int> lst;
 };
-REFLECTION(list_t, lst);
+YLT_REFL(list_t, lst);
 
 struct forward_list_t {
   std::forward_list<int> lst;
 };
-REFLECTION(forward_list_t, lst);
+YLT_REFL(forward_list_t, lst);
 
 struct deque_t {
   std::deque<int> lst;
 };
-REFLECTION(deque_t, lst);
+YLT_REFL(deque_t, lst);
 
 struct fixed_name_object_t {
   std::string name0{};
@@ -103,13 +97,13 @@ struct fixed_name_object_t {
   std::string name3{};
   std::string name4{};
 };
-REFLECTION(fixed_name_object_t, name0, name1, name2, name3, name4);
+YLT_REFL(fixed_name_object_t, name0, name1, name2, name3, name4);
 
 struct nested_object_t {
   std::vector<std::array<double, 3>> v3s{};
   std::string id{};
 };
-REFLECTION(nested_object_t, v3s, id);
+YLT_REFL(nested_object_t, v3s, id);
 
 struct another_object_t {
   std::string string{};
@@ -117,7 +111,7 @@ struct another_object_t {
   bool boolean{};
   nested_object_t nested_object{};
 };
-REFLECTION(another_object_t, string, another_string, boolean, nested_object);
+YLT_REFL(another_object_t, string, another_string, boolean, nested_object);
 
 struct json0_obj_t {
   //   fixed_object_t fixed_object{};
@@ -129,21 +123,21 @@ struct json0_obj_t {
   bool boolean{};
   bool another_bool{};
 };
-REFLECTION(json0_obj_t, fixed_name_object, another_object, string_array, string,
-           number, boolean, another_bool);
+YLT_REFL(json0_obj_t, fixed_name_object, another_object, string_array, string,
+         number, boolean, another_bool);
 
 struct tuple_t {
   std::tuple<int, double, std::string> tp;
 };
-REFLECTION(tuple_t, tp);
+YLT_REFL(tuple_t, tp);
 
 struct test_double_t {
   double val;
 };
-REFLECTION(test_double_t, val);
+YLT_REFL(test_double_t, val);
 
 struct test_empty_t {};
-REFLECTION_EMPTY(test_empty_t);
+YLT_REFL(test_empty_t);
 
 struct test {
   std::string username;
@@ -151,7 +145,7 @@ struct test {
   long long id;
   bool error;
 };
-REFLECTION(test, username, password, id, error);
+YLT_REFL(test, username, password, id, error);
 
 template <typename T>
 void get_value_test_helper(const std::string &json_str, const T &expect) {
@@ -170,11 +164,11 @@ struct inner_struct {
   int z;
 };
 
-inline auto get_members_impl(inner_struct *) {
-  return std::make_tuple(iguana::field_t{&inner_struct::x, 7, "a"},
-                         iguana::field_t{&inner_struct::y, 9, "b"},
-                         iguana::field_t{&inner_struct::z, 12, "c"});
-}
+// inline auto get_members_impl(inner_struct *) {
+//   return std::make_tuple(iguana::field_t{&inner_struct::x, 7, "a"},
+//                          iguana::field_t{&inner_struct::y, 9, "b"},
+//                          iguana::field_t{&inner_struct::z, 12, "c"});
+// }
 
 inline constexpr size_t iguana_member_count(inner_struct *) { return 3; }
 
@@ -188,7 +182,7 @@ struct nest_t {
   std::variant<int, std::string, double> var;
   std::variant<int, std::string, my_space::inner_struct> var2;
 };
-REFLECTION(nest_t, name, value, var, var2);
+YLT_REFL(nest_t, name, value, var, var2);
 
 TEST_CASE("test throw while parsing an illegal number") {
 #if defined(__clang__) || defined(_MSC_VER) || \
@@ -227,7 +221,7 @@ struct my_variant_t {
   std::string name;
   std::variant<int, std::string> var;
 };
-REFLECTION(my_variant_t, name, var);
+YLT_REFL(my_variant_t, name, var);
 
 TEST_CASE("test variant") {
   std::variant<int, std::string> var;
@@ -456,7 +450,7 @@ TEST_CASE("test dom parse") {
 TEST_CASE("test simple object") {
   {
     //    test_double_t d{.val = 1.4806532964699196e-22};
-    //    iguana::string_stream ss;
+    //    std::string ss;
     //    iguana::to_json(d, ss);
     //
     //    test_double_t p{};
@@ -485,7 +479,7 @@ TEST_CASE("test simple object") {
 
 TEST_CASE("test two_fields object") {
   two_fields_t obj{{1, 2}, {"aa", "bb"}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(obj, ss);
 
   two_fields_t p{};
@@ -496,7 +490,7 @@ TEST_CASE("test two_fields object") {
 TEST_CASE("test simple nested object") {
   person o{"tom", false};
   simple_nested_t t{1, o};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(t, ss);
 
   simple_nested_t p{};
@@ -509,7 +503,7 @@ TEST_CASE("test simple nested object") {
 
 TEST_CASE("test c array and std::array") {
   arr_t arr{{1, 2}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(arr, ss);
   arr_t arr1{};
 
@@ -575,7 +569,7 @@ TEST_CASE("test bool, null, char, int, float") {
 
 TEST_CASE("test vector") {
   vector_t arr{{1, 2}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(arr, ss);
 
   vector_t p{};
@@ -587,7 +581,7 @@ TEST_CASE("test map") {
   map_t map{};
   map.map1 = {{1, "hello"}, {2, "iguana"}};
   map.map2 = {{3, "this"}, {4, "hashmap"}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(map, ss);
 
   map_t p{};
@@ -612,7 +606,7 @@ TEST_CASE("test nested object") {
 TEST_CASE("test tuple") {
   tuple_t t;
   t.tp = std::make_tuple(2, 3.14, "hello iguana");
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(t, ss);
 
   tuple_t p{};
@@ -625,7 +619,7 @@ TEST_CASE("test tuple") {
 
 TEST_CASE("test list") {
   list_t list{{1, 2, 3}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(list, ss);
 
   list_t p{};
@@ -635,7 +629,7 @@ TEST_CASE("test list") {
 
 TEST_CASE("test deque_t") {
   deque_t list{{1, 2, 3}};
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(list, ss);
 
   deque_t p{};
@@ -703,7 +697,7 @@ TEST_CASE("test unique_ptr object") {
 TEST_CASE("test empty object") {
   test_empty_t empty_obj;
 
-  iguana::string_stream ss;
+  std::string ss;
   iguana::to_json(empty_obj, ss);
   CHECK(ss == "{}");
 }
@@ -712,7 +706,7 @@ TEST_CASE("test non-reflectable object") {
   {
     std::tuple<int, double, std::string> t{1, 3.14, std::string("iguana")};
 
-    iguana::string_stream ss;
+    std::string ss;
     iguana::to_json(t, ss);
 
     std::tuple<int, double, std::string> p{};
@@ -855,103 +849,106 @@ struct some_test_t {
   int id1;
   std::string name;
 };
-REFLECTION(some_test_t, id1, name);
+YLT_REFL(some_test_t, id1, name);
 
 struct dummy_nest_t {
   int id;
   some_test_t t;
 };
-REFLECTION(dummy_nest_t, id, t);
+YLT_REFL(dummy_nest_t, id, t);
 
 struct some_test_t1 {
   int id;
   std::string name;
 };
-REFLECTION(some_test_t1, id, name);
+YLT_REFL(some_test_t1, id, name);
 
 struct dummy_nest_t1 {
   int id;
   some_test_t1 t;
 };
-REFLECTION(dummy_nest_t1, id, t);
-
-TEST_CASE("partial from json") {
-  constexpr size_t count1 =
-      iguana::duplicate_count<dummy_nest_t,
-                              &some_test_t::name>();  // field + name == 2
-  static_assert(count1 == 2);
-  constexpr size_t count2 =
-      iguana::duplicate_count<dummy_nest_t, &dummy_nest_t::t>();
-  static_assert(count2 == 2);
-  constexpr size_t count3 =
-      iguana::duplicate_count<dummy_nest_t, &dummy_nest_t::id>();
-  static_assert(count3 == 2);
-
-  constexpr size_t count5 = iguana::duplicate_count<
-      dummy_nest_t1, &dummy_nest_t1::id>();  // has duplicate field "id": 1 id
-                                             // field + more than one name "id"
-  static_assert(count5 == 3);
-  constexpr size_t count4 =
-      iguana::duplicate_count<dummy_nest_t,
-                              &person::name>();  // &person::name is not belong
-                                                 // to dummy_nest_t
-  static_assert(count4 == 1);
-
-  dummy_nest_t t{42, {43, "tom"}};
-  std::string str;
-  iguana::to_json(t, str);
-
-  {
-    dummy_nest_t t1;
-    iguana::from_json<&dummy_nest_t::id>(t1, str);
-    CHECK(t1.id == 42);
-  }
-  {
-    dummy_nest_t t1;
-    iguana::from_json<&dummy_nest_t::t>(t1, str);
-    CHECK(t1.t.name == "tom");
-  }
-
-  {
-    some_test_t t1;
-    iguana::from_json<&some_test_t::name, dummy_nest_t>(t1, str);
-    CHECK(t1.name == "tom");
-  }
-}
-
-TEST_CASE("index_of name_of") {
-  constexpr size_t idx1 = iguana::index_of<&point_t::y>();
-  static_assert(idx1 == 1);
-  constexpr size_t idx2 = iguana::index_of<&person::name>();
-  static_assert(idx2 == 0);
-
-  CHECK(idx1 == 1);
-  CHECK(idx2 == 0);
-
-  constexpr auto index_arr = iguana::indexs_of<&point_t::x, &point_t::y>();
-  constexpr auto name_arr = iguana::names_of<&point_t::x, &point_t::y>();
-
-  CHECK(index_arr == std::array<size_t, 2>{0, 1});
-  CHECK(name_arr == std::array<std::string_view, 2>{"x", "y"});
-
-  constexpr auto s1 = iguana::name_of<&point_t::y>();
-  static_assert(s1 == "y");
-  constexpr auto s2 = iguana::name_of<&person::name>();
-  static_assert(s2 == "name");
-
-  CHECK(s1 == "y");
-  CHECK(s2 == "name");
-}
-
-TEST_CASE("check some types") {
-  using value_type = std::variant<int point_t::*, double point_t::*>;
-  constexpr auto map = iguana::get_iguana_struct_map<point_t>();
-  static_assert(map.size() == 2);
-  static_assert(map.at("x") ==
-                value_type{std::in_place_index_t<0>{}, &point_t::x});
-  static_assert(map.at("y") ==
-                value_type{std::in_place_index_t<1>{}, &point_t::y});
-}
+YLT_REFL(dummy_nest_t1, id, t);
+
+// TEST_CASE("partial from json") {
+//   constexpr size_t count1 =
+//       iguana::duplicate_count<dummy_nest_t,
+//                               &some_test_t::name>();  // field + name == 2
+//   static_assert(count1 == 2);
+//   constexpr size_t count2 =
+//       iguana::duplicate_count<dummy_nest_t, &dummy_nest_t::t>();
+//   static_assert(count2 == 2);
+//   constexpr size_t count3 =
+//       iguana::duplicate_count<dummy_nest_t, &dummy_nest_t::id>();
+//   static_assert(count3 == 2);
+
+//   constexpr size_t count5 = iguana::duplicate_count<
+//       dummy_nest_t1, &dummy_nest_t1::id>();  // has duplicate field "id": 1
+//       id
+//                                              // field + more than one name
+//                                              "id"
+//   static_assert(count5 == 3);
+//   constexpr size_t count4 =
+//       iguana::duplicate_count<dummy_nest_t,
+//                               &person::name>();  // &person::name is not
+//                               belong
+//                                                  // to dummy_nest_t
+//   static_assert(count4 == 1);
+
+//   dummy_nest_t t{42, {43, "tom"}};
+//   std::string str;
+//   iguana::to_json(t, str);
+
+//   {
+//     dummy_nest_t t1;
+//     iguana::from_json<&dummy_nest_t::id>(t1, str);
+//     CHECK(t1.id == 42);
+//   }
+//   {
+//     dummy_nest_t t1;
+//     iguana::from_json<&dummy_nest_t::t>(t1, str);
+//     CHECK(t1.t.name == "tom");
+//   }
+
+//   {
+//     some_test_t t1;
+//     iguana::from_json<&some_test_t::name, dummy_nest_t>(t1, str);
+//     CHECK(t1.name == "tom");
+//   }
+// }
+
+// TEST_CASE("index_of name_of") {
+//   constexpr size_t idx1 = iguana::index_of<&point_t::y>();
+//   static_assert(idx1 == 1);
+//   constexpr size_t idx2 = iguana::index_of<&person::name>();
+//   static_assert(idx2 == 0);
+
+//   CHECK(idx1 == 1);
+//   CHECK(idx2 == 0);
+
+//   constexpr auto index_arr = iguana::indexs_of<&point_t::x, &point_t::y>();
+//   constexpr auto name_arr = iguana::names_of<&point_t::x, &point_t::y>();
+
+//   CHECK(index_arr == std::array<size_t, 2>{0, 1});
+//   CHECK(name_arr == std::array<std::string_view, 2>{"x", "y"});
+
+//   constexpr auto s1 = iguana::name_of<&point_t::y>();
+//   static_assert(s1 == "y");
+//   constexpr auto s2 = iguana::name_of<&person::name>();
+//   static_assert(s2 == "name");
+
+//   CHECK(s1 == "y");
+//   CHECK(s2 == "name");
+// }
+
+// TEST_CASE("check some types") {
+//   using value_type = std::variant<int point_t::*, double point_t::*>;
+//   constexpr auto map = iguana::get_iguana_struct_map<point_t>();
+//   static_assert(map.size() == 2);
+//   static_assert(map.at("x") ==
+//                 value_type{std::in_place_index_t<0>{}, &point_t::x});
+//   static_assert(map.at("y") ==
+//                 value_type{std::in_place_index_t<1>{}, &point_t::y});
+// }
 
 enum class Status { STOP = 10, START };
 namespace iguana {
@@ -1039,6 +1036,8 @@ struct my_struct {
   }
 };
 
+void ylt_custom_reflect(my_struct *) {}
+
 template <bool Is_writing_escape, typename Stream>
 inline void to_json_impl(Stream &s, const my_struct &t) {
   iguana::to_json(*(int(*)[3]) & t, s);
@@ -1059,7 +1058,7 @@ struct nest {
   }
 };
 
-REFLECTION(nest, name, value);
+YLT_REFL(nest, name, value);
 
 void example1() {
   my_space::my_struct v{1, 2, 3}, v2;
diff --git a/test/test_xml.cpp b/test/test_xml.cpp
index 86881d32..cdc63833 100644
--- a/test/test_xml.cpp
+++ b/test/test_xml.cpp
@@ -17,7 +17,7 @@ struct Owner_t {
     return ID == rhs.ID && DisplayName == rhs.DisplayName;
   }
 };
-REFLECTION(Owner_t, ID, DisplayName);
+YLT_REFL(Owner_t, ID, DisplayName);
 struct Contents {
   std::string Key;
   std::string LastModified;
@@ -33,7 +33,7 @@ struct Contents {
            StorageClass == rhs.StorageClass && Owner == rhs.Owner;
   }
 };
-REFLECTION(Contents, Key, LastModified, ETag, Type, Size, StorageClass, Owner);
+YLT_REFL(Contents, Key, LastModified, ETag, Type, Size, StorageClass, Owner);
 
 TEST_CASE("simple test") {
   Contents contents{"key", "ddd", "ccc", "aaa", 123, "aaa", {"bbb", "sss"}};
@@ -62,13 +62,13 @@ struct optional_t {
   bool d;
   char e;
 };
-REFLECTION(optional_t, a, b, c, d, e);
+YLT_REFL(optional_t, a, b, c, d, e);
 
 struct list_t {
   std::vector<optional_t> list;
   int id;
 };
-REFLECTION(list_t, list, id);
+YLT_REFL(list_t, list, id);
 
 TEST_CASE("test vector") {
   auto validator = [](list_t l) {
@@ -109,7 +109,7 @@ TEST_CASE("test vector") {
 struct test_arr_t {
   std::vector<iguana::xml_attr_t<int, std::map<std::string_view, int>>> item;
 };
-REFLECTION(test_arr_t, item);
+YLT_REFL(test_arr_t, item);
 
 TEST_CASE("test vector with attr") {
   auto validator = [](test_arr_t &array) {
@@ -159,7 +159,7 @@ struct child_t {
   int key1;
   int key2;
 };
-REFLECTION(child_t, key1, key2);
+YLT_REFL(child_t, key1, key2);
 struct some_type_t {
   std::vector<float> price;
   std::optional<std::string> description;
@@ -171,8 +171,8 @@ struct some_type_t {
   std::string_view addr;
   enum_status status;
 };
-REFLECTION(some_type_t, price, description, child, hasdescription, c, d_v, name,
-           addr, status);
+YLT_REFL(some_type_t, price, description, child, hasdescription, c, d_v, name,
+         addr, status);
 
 TEST_CASE("test parse_done") {
   std::string str = R"(
@@ -247,11 +247,11 @@ struct book_t {
   std::string title;
   std::string author;
 };
-REFLECTION(book_t, title, author);
+YLT_REFL(book_t, title, author);
 struct library {
   iguana::xml_attr_t<book_t> book;
 };
-REFLECTION(library, book);
+YLT_REFL(library, book);
 TEST_CASE("test library with attr") {
   auto validator = [](library lib) {
     CHECK(lib.book.attr()["id"] == "1234");
@@ -303,7 +303,7 @@ struct package_t {
   iguana::xml_attr_t<std::optional<std::string_view>> version;
   iguana::xml_attr_t<std::string_view> changelog;
 };
-REFLECTION(package_t, version, changelog);
+YLT_REFL(package_t, version, changelog);
 TEST_CASE("test example package") {
   auto validator = [](iguana::xml_attr_t<package_t> package) {
     CHECK(package.attr()["name"] == "apr-util-ldap");
@@ -347,13 +347,13 @@ TEST_CASE("test example package") {
 struct description_t {
   iguana::xml_cdata_t<std::string> cdata;
 };
-REFLECTION(description_t, cdata);
+YLT_REFL(description_t, cdata);
 struct node_t {
   std::string title;
   description_t description;
   iguana::xml_cdata_t<> cdata;
 };
-REFLECTION(node_t, title, description, cdata);
+YLT_REFL(node_t, title, description, cdata);
 TEST_CASE("test example cdata") {
   auto validator = [](node_t node) {
     CHECK(node.title == "what's the cdata");
@@ -403,7 +403,7 @@ struct test_exception_t {
   bool b;
   char c;
 };
-REFLECTION(test_exception_t, a, b, c);
+YLT_REFL(test_exception_t, a, b, c);
 TEST_CASE("test exception") {
   {
     std::string str = "<root> <a>d3</a> </root>";
@@ -439,18 +439,18 @@ struct city_t {
   iguana::xml_cdata_t<> cd;
   std::string name;
 };
-REFLECTION(city_t, area, cd, name);
+YLT_REFL(city_t, area, cd, name);
 struct cities_t {
   std::vector<city_t> city;
 };
-REFLECTION(cities_t, city);
+YLT_REFL(cities_t, city);
 struct province {
   iguana::xml_attr_t<long> area;
   iguana::xml_cdata_t<> cd;
   std::unique_ptr<cities_t> cities;
   std::string capital;
 };
-REFLECTION(province, area, cd, cities, capital);
+YLT_REFL(province, area, cd, cities, capital);
 
 TEST_CASE("test province example") {
   auto validator = [](province &p) {
@@ -519,7 +519,7 @@ struct some_book {
   std::string_view title;
   std::string_view author;
 };
-REFLECTION(some_book, title, author);
+YLT_REFL(some_book, title, author);
 REQUIRED(some_book, title, author);
 
 TEST_CASE("test required filed") {
@@ -567,7 +567,7 @@ struct test_enum_t {
   Color g;
   Color h;
 };
-REFLECTION(test_enum_t, a, b, c, d, e, f, g, h);
+YLT_REFL(test_enum_t, a, b, c, d, e, f, g, h);
 
 #if defined(__clang__) || defined(_MSC_VER) || \
     (defined(__GNUC__) && __GNUC__ > 8)
@@ -620,7 +620,7 @@ struct enum_exception_t {
   State a;
   State b;
 };
-REFLECTION(enum_exception_t, a, b);
+YLT_REFL(enum_exception_t, a, b);
 
 TEST_CASE("enum exception") {
   std::string str = R"(
@@ -652,7 +652,7 @@ class some_object {
   some_object(int i, std::string str) : id(i), name(str) {}
   int get_id() const { return id; }
   std::string get_name() const { return name; }
-  REFLECTION(some_object, id, name);
+  YLT_REFL(some_object, id, name);
 };
 
 TEST_CASE("test inner reflection") {
@@ -672,7 +672,7 @@ struct Contents_t {
   std::shared_ptr<std::vector<std::unique_ptr<int>>> vec_s;
   std::string b;
 };
-REFLECTION(Contents_t, vec, vec_s, b);
+YLT_REFL(Contents_t, vec, vec_s, b);
 
 TEST_CASE("test smart_ptr") {
   std::string str = R"(
@@ -732,16 +732,31 @@ struct next_obj_t {
   int x;
   int y;
 };
-REFLECTION_ALIAS(next_obj_t, "next", FLDALIAS(&next_obj_t::x, "w"),
-                 FLDALIAS(&next_obj_t::y, "h"));
+YLT_REFL(next_obj_t, x, y);
+
+template <>
+struct ylt::reflection::ylt_alias_struct<next_obj_t> {
+  static constexpr std::string_view get_alias_struct_name() { return "next"; }
+
+  static constexpr auto get_alias_field_names() {
+    return std::make_tuple(field_alias_t<0>{"w"}, field_alias_t<1>{"h"});
+  }
+};
 
 struct out_object {
   std::unique_ptr<int> id;
   std::string_view name;
   next_obj_t obj;
-  REFLECTION_ALIAS(out_object, "qi", FLDALIAS(&out_object::id, "i"),
-                   FLDALIAS(&out_object::name, "na"),
-                   FLDALIAS(&out_object::obj, "obj"));
+  YLT_REFL(out_object, id, name, obj);
+};
+
+template <>
+struct ylt::reflection::ylt_alias_struct<out_object> {
+  static constexpr std::string_view get_alias_struct_name() { return "qi"; }
+
+  static constexpr auto get_alias_field_names() {
+    return std::make_tuple(field_alias_t<0>{"w"}, field_alias_t<1>{"h"});
+  }
 };
 
 TEST_CASE("test alias") {
@@ -762,7 +777,7 @@ struct text_t {
   escape_attr_t ID;
   std::string DisplayName;
 };
-REFLECTION(text_t, ID, DisplayName);
+YLT_REFL(text_t, ID, DisplayName);
 TEST_CASE("test escape") {
   using text_attr_type =
       iguana::xml_attr_t<text_t, std::map<std::string_view, std::string>>;
diff --git a/test/test_xml_nothrow.cpp b/test/test_xml_nothrow.cpp
index 684596ee..107d3a5f 100644
--- a/test/test_xml_nothrow.cpp
+++ b/test/test_xml_nothrow.cpp
@@ -21,7 +21,7 @@ struct order_t {
   enum_status status;
   float total;
 };
-REFLECTION(order_t, status, total);
+YLT_REFL(order_t, status, total);
 
 TEST_CASE("test unkonwn key") {
   auto validator = [](order_t od) {
@@ -91,7 +91,7 @@ struct text_t {
   escape_attr_t ID;
   std::string DisplayName;
 };
-REFLECTION(text_t, ID, DisplayName);
+YLT_REFL(text_t, ID, DisplayName);
 TEST_CASE("test escape") {
   {
     std::string str = R"(
diff --git a/test/test_yaml.cpp b/test/test_yaml.cpp
index 80832b58..4cb2c402 100644
--- a/test/test_yaml.cpp
+++ b/test/test_yaml.cpp
@@ -94,7 +94,7 @@ struct plain_type_t {
   std::optional<float> num;
   std::optional<int> price;
 };
-REFLECTION(plain_type_t, isok, status, c, hasprice, num, price);
+YLT_REFL(plain_type_t, isok, status, c, hasprice, num, price);
 TEST_CASE("test plain_type") {
   plain_type_t p{false, enum_status::stop, 'a', true};
   p.price = 20;
@@ -231,7 +231,7 @@ TEST_CASE("test exception") {
 struct test_string_t {
   std::vector<std::string> txt;
 };
-REFLECTION(test_string_t, txt);
+YLT_REFL(test_string_t, txt);
 TEST_CASE("test block string") {
   std::string str = R"(
 txt:
@@ -263,7 +263,7 @@ TEST_CASE("test block string") {
 struct arr_t {
   std::vector<std::string_view> arr;
 };
-REFLECTION(arr_t, arr);
+YLT_REFL(arr_t, arr);
 TEST_CASE("test array") {
   std::string str = R"(
   arr : [
@@ -304,7 +304,7 @@ TEST_CASE("test array") {
 struct nest_arr_t {
   std::vector<std::vector<std::string_view>> arr;
 };
-REFLECTION(nest_arr_t, arr);
+YLT_REFL(nest_arr_t, arr);
 TEST_CASE("test nest arr ") {
   std::string str = R"(
   arr : [[
@@ -357,7 +357,7 @@ TEST_CASE("test nest arr ") {
 struct nest_float_arr_t {
   std::vector<std::vector<float>> arr;
 };
-REFLECTION(nest_float_arr_t, arr);
+YLT_REFL(nest_float_arr_t, arr);
 TEST_CASE("test arr with float") {
   std::string str = R"(
   arr :
@@ -377,7 +377,7 @@ TEST_CASE("test arr with float") {
 struct map_t {
   std::unordered_map<std::string_view, std::string_view> map;
 };
-REFLECTION(map_t, map);
+YLT_REFL(map_t, map);
 TEST_CASE("test map") {
   std::string str = R"(
   map : {
@@ -402,7 +402,7 @@ TEST_CASE("test map") {
 struct map_arr_t {
   std::unordered_map<std::string_view, std::vector<std::string_view>> map;
 };
-REFLECTION(map_arr_t, map);
+YLT_REFL(map_arr_t, map);
 TEST_CASE("test map") {
   std::string str = R"(
   map : {
@@ -440,7 +440,7 @@ TEST_CASE("test map") {
 struct test_str_t {
   std::string_view str;
 };
-REFLECTION(test_str_t, str);
+YLT_REFL(test_str_t, str);
 TEST_CASE("test str type") {
   std::string str = R"(
   str :
@@ -470,8 +470,8 @@ struct some_type_t {
   std::string_view addr;
   enum_status status;
 };
-REFLECTION(some_type_t, price, description, child, hasdescription, c, d_v, name,
-           addr, status);
+YLT_REFL(some_type_t, price, description, child, hasdescription, c, d_v, name,
+         addr, status);
 TEST_CASE("test some_type") {
   auto validator_some_type = [](some_type_t s) {
     CHECK(s.price[0] == 1.23f);
@@ -518,19 +518,19 @@ struct address_t {
   std::string_view state;
   std::string_view country;
 };
-REFLECTION(address_t, street, city, state, country);
+YLT_REFL(address_t, street, city, state, country);
 struct contact_t {
   std::string_view type;
   std::string_view value;
 };
-REFLECTION(contact_t, type, value);
+YLT_REFL(contact_t, type, value);
 struct person_t {
   std::string_view name;
   int age;
   address_t address;
   std::vector<contact_t> contacts;
 };
-REFLECTION(person_t, name, age, address, contacts);
+YLT_REFL(person_t, name, age, address, contacts);
 TEST_CASE("test person_t") {
   auto validator_person = [](const person_t &p) {
     CHECK(p.name == "John Doe");
@@ -577,17 +577,17 @@ struct product_t {
   float price;
   std::optional<std::string> description;
 };
-REFLECTION(product_t, name, price, description);
+YLT_REFL(product_t, name, price, description);
 struct store_t {
   std::string name;
   std::string_view location;
   std::vector<product_t> products;
 };
-REFLECTION(store_t, name, location, products);
+YLT_REFL(store_t, name, location, products);
 struct store_example_t {
   store_t store;
 };
-REFLECTION(store_example_t, store);
+YLT_REFL(store_example_t, store);
 TEST_CASE("test example store") {
   std::string str = R"(
 store:
@@ -630,17 +630,17 @@ struct book_t {
   std::optional<std::string_view> title;
   std::vector<std::string_view> categories;
 };
-REFLECTION(book_t, title, categories);
+YLT_REFL(book_t, title, categories);
 struct library_t {
   std::unique_ptr<std::string_view> name;
   std::string location;
   std::vector<std::unique_ptr<book_t>> books;
 };
-REFLECTION(library_t, name, location, books);
+YLT_REFL(library_t, name, location, books);
 struct library_example_t {
   std::vector<library_t> libraries;
 };
-REFLECTION(library_example_t, libraries);
+YLT_REFL(library_example_t, libraries);
 
 TEST_CASE("test example books") {
   std::vector<book_t> books;
@@ -726,7 +726,7 @@ struct movie_t {
   std::optional<int> year;
   std::vector<std::string> actors;
 };
-REFLECTION(movie_t, title, year, actors);
+YLT_REFL(movie_t, title, year, actors);
 TEST_CASE("test_tuple_example") {
   std::string str = R"(
 # this is a movie
@@ -797,7 +797,7 @@ struct test_enum_t {
   Color g;
   Color h;
 };
-REFLECTION(test_enum_t, a, b, c, d, e, f, g, h);
+YLT_REFL(test_enum_t, a, b, c, d, e, f, g, h);
 
 #if defined(__clang__) || defined(_MSC_VER) || \
     (defined(__GNUC__) && __GNUC__ > 8)
@@ -849,7 +849,7 @@ struct enum_exception_t {
   State a;
   State b;
 };
-REFLECTION(enum_exception_t, a, b);
+YLT_REFL(enum_exception_t, a, b);
 
 #if defined(__clang__) || defined(_MSC_VER) || \
     (defined(__GNUC__) && __GNUC__ > 8)
@@ -883,10 +883,10 @@ class some_object {
   some_object(int i, std::string str) : id(i), name(str) {}
   int get_id() const { return id; }
   std::string get_name() const { return name; }
-  REFLECTION(some_object, id, name);
+  YLT_REFL(some_object, id, name);
 };
 
-TEST_CASE("test inner reflection") {
+TEST_CASE("test inner YLT_REFL") {
   some_object obj{20, "tom"};
   std::string str;
   iguana::to_yaml(obj, str);
@@ -903,7 +903,7 @@ struct Contents_t {
   std::shared_ptr<std::vector<std::unique_ptr<int>>> vec_s;
   std::string b;
 };
-REFLECTION(Contents_t, vec, vec_s, b);
+YLT_REFL(Contents_t, vec, vec_s, b);
 
 TEST_CASE("test smart_ptr") {
   std::string str = R"(
diff --git a/test/test_yaml_bech.cpp b/test/test_yaml_bech.cpp
index 58885b33..8495977c 100644
--- a/test/test_yaml_bech.cpp
+++ b/test/test_yaml_bech.cpp
@@ -1,6 +1,3 @@
-#include "doctest.h"
-#include "iguana/yaml_reader.hpp"
-#include "iguana/yaml_writer.hpp"
 #include <deque>
 #include <iostream>
 #include <iterator>
@@ -8,6 +5,10 @@
 #include <optional>
 #include <vector>
 
+#include "doctest.h"
+#include "iguana/yaml_reader.hpp"
+#include "iguana/yaml_writer.hpp"
+
 std::string yaml_file_content(const std::string &filename) {
   std::error_code ec;
   uint64_t size = std::filesystem::file_size(filename, ec);
@@ -29,24 +30,24 @@ struct matrix_t {
   std::string_view generator;
   std::string_view configuration;
 };
-REFLECTION(matrix_t, compiler, generator, configuration);
+YLT_REFL(matrix_t, compiler, generator, configuration);
 struct environment_t {
   std::vector<matrix_t> matrix;
 };
-REFLECTION(environment_t, matrix);
+YLT_REFL(environment_t, matrix);
 struct ex_matrix_t {
   std::string_view fast_finish;
 };
-REFLECTION(ex_matrix_t, fast_finish);
+YLT_REFL(ex_matrix_t, fast_finish);
 struct artifact_t {
   std::string_view path;
   std::string_view name;
 };
-REFLECTION(artifact_t, path, name);
+YLT_REFL(artifact_t, path, name);
 struct skip_commit_t {
   std::vector<std::string_view> files;
 };
-REFLECTION(skip_commit_t, files);
+YLT_REFL(skip_commit_t, files);
 struct appveyor_t {
   std::string_view version;
   std::string_view image;
@@ -58,8 +59,8 @@ struct appveyor_t {
   std::vector<artifact_t> artifacts;
   skip_commit_t skip_commits;
 };
-REFLECTION(appveyor_t, version, image, environment, matrix, install,
-           build_script, test_script, artifacts, skip_commits);
+YLT_REFL(appveyor_t, version, image, environment, matrix, install, build_script,
+         test_script, artifacts, skip_commits);
 
 void validator(appveyor_t app) {
   CHECK(app.version == "{build}");
@@ -151,26 +152,26 @@ TEST_CASE("test deserialize appveyor.yml") {
 struct apt_t {
   std::vector<std::string_view> sources;
 };
-REFLECTION(apt_t, sources);
+YLT_REFL(apt_t, sources);
 struct addon_t {
   apt_t apt;
 };
-REFLECTION(addon_t, apt);
+YLT_REFL(addon_t, apt);
 
 struct env_t {
   std::vector<std::string_view> global;
 };
-REFLECTION(env_t, global);
+YLT_REFL(env_t, global);
 
 struct in_env_t {
   std::string_view env;
 };
-REFLECTION(in_env_t, env);
+YLT_REFL(in_env_t, env);
 
 struct mat_t {
   std::vector<in_env_t> include;
 };
-REFLECTION(mat_t, include);
+YLT_REFL(mat_t, include);
 
 struct travis_t {
   std::string_view sudo;
@@ -183,8 +184,8 @@ struct travis_t {
   std::vector<std::string_view> script;
   std::vector<std::string_view> after_success;
 };
-REFLECTION(travis_t, sudo, dist, language, addons, env, matrix, install, script,
-           after_success);
+YLT_REFL(travis_t, sudo, dist, language, addons, env, matrix, install, script,
+         after_success);
 
 void validator(travis_t tra) {
   CHECK(tra.sudo == "required");
diff --git a/test/test_yaml_nothrow.cpp b/test/test_yaml_nothrow.cpp
index 76d06a7a..89e686f4 100644
--- a/test/test_yaml_nothrow.cpp
+++ b/test/test_yaml_nothrow.cpp
@@ -1,8 +1,6 @@
 #define DOCTEST_CONFIG_IMPLEMENT
 #include "doctest.h"
 #undef THROW_UNKNOWN_KEY
-#include "iguana/yaml_reader.hpp"
-#include "iguana/yaml_writer.hpp"
 #include <deque>
 #include <iostream>
 #include <iterator>
@@ -10,22 +8,25 @@
 #include <optional>
 #include <vector>
 
+#include "iguana/yaml_reader.hpp"
+#include "iguana/yaml_writer.hpp"
+
 struct product_t {
   std::string_view name;
   float price;
   std::optional<std::string> description;
 };
-REFLECTION(product_t, name, price, description);
+YLT_REFL(product_t, name, price, description);
 struct store_t {
   std::string name;
   std::string_view location;
   std::vector<product_t> products;
 };
-REFLECTION(store_t, name, location, products);
+YLT_REFL(store_t, name, location, products);
 struct store_example_t {
   store_t store;
 };
-REFLECTION(store_example_t, store);
+YLT_REFL(store_example_t, store);
 TEST_CASE("test nothrow unknown key") {
   std::string str = R"(
 unkonwnkey: aabb
diff --git a/test/unit_test.cpp b/test/unit_test.cpp
index ca58851d..92d265b4 100644
--- a/test/unit_test.cpp
+++ b/test/unit_test.cpp
@@ -3,8 +3,8 @@
 #include <list>
 #include <vector>
 
-#include "iguana/reflection.hpp"
 #define DOCTEST_CONFIG_IMPLEMENT
+// #define SEQUENTIAL_PARSE
 #include <iguana/json_util.hpp>
 #include <iguana/json_writer.hpp>
 #include <iostream>
@@ -243,7 +243,7 @@ struct test_enum_t {
   Color g;
   Color h;
 };
-REFLECTION(test_enum_t, a, b, c, d, e, f, g, h);
+YLT_REFL(test_enum_t, a, b, c, d, e, f, g, h);
 
 #if defined(__clang__) || defined(_MSC_VER) || \
     (defined(__GNUC__) && __GNUC__ > 8)
@@ -303,10 +303,11 @@ TEST_CASE("test parse item char") {
     CHECK(test == 'c');
   }
   {
-      // std::string str{"\""};
-      // char test{};
-      // CHECK_THROWS(iguana::from_json(test, str.begin(), str.end()));
-  } {
+    std::string str{"\""};
+    char test{};
+    CHECK_THROWS(iguana::from_json(test, str.begin(), str.end()));
+  }
+  {
     std::string str{R"("\)"};
     char test{};
     CHECK_THROWS_WITH(iguana::from_json(test, str.begin(), str.end()),
@@ -405,22 +406,22 @@ TEST_CASE("test parse item optional") {
 struct optional_t {
   std::optional<bool> p;
 };
-REFLECTION(optional_t, p);
+YLT_REFL(optional_t, p);
 
 struct struct_test_t {
   int32_t value;
 };
-REFLECTION(struct_test_t, value);
+YLT_REFL(struct_test_t, value);
 
 struct struct_container_t {
   std::vector<struct_test_t> values;
 };
-REFLECTION(struct_container_t, values);
+YLT_REFL(struct_container_t, values);
 
 struct struct_container_1_t {
   std::optional<struct_container_t> val;
 };  // entities_t
-REFLECTION(struct_container_1_t, val);
+YLT_REFL(struct_container_1_t, val);
 
 TEST_CASE("test optional") {
   {
@@ -472,7 +473,7 @@ TEST_CASE("test optional") {
 }
 
 struct empty_t {};
-REFLECTION_EMPTY(empty_t);
+YLT_REFL(empty_t);
 
 TEST_CASE("test empty struct") {
   empty_t t;
@@ -489,7 +490,7 @@ struct keyword_t {
   std::string ___protected;
   std::string ___class;
 };
-REFLECTION(keyword_t, ___private, ___protected, ___public, ___class);
+YLT_REFL(keyword_t, ___private, ___protected, ___public, ___class);
 
 TEST_CASE("test keyword") {
   std::string ss =
@@ -507,7 +508,7 @@ struct config_actor_type {
   std::string make;
   std::string config;
 };
-REFLECTION(config_actor_type, id, make, config);
+YLT_REFL(config_actor_type, id, make, config);
 
 struct config_app_json_type {
   long id = 0;
@@ -515,7 +516,7 @@ struct config_app_json_type {
   std::string loglevel;
   std::vector<config_actor_type> actors;
 };
-REFLECTION(config_app_json_type, id, threads, loglevel, actors);
+YLT_REFL(config_app_json_type, id, threads, loglevel, actors);
 
 TEST_CASE("test long") {
   config_app_json_type app{1234};
@@ -686,7 +687,7 @@ struct book_t {
   std::optional<std::string_view> edition;
   std::vector<std::string_view> author;
 };
-REFLECTION(book_t, title, edition, author);
+YLT_REFL(book_t, title, edition, author);
 TEST_CASE("test the string_view") {
   {
     std::string str = R"("C++ \ntemplates")";
@@ -773,7 +774,7 @@ struct st_char_t {
   char b[5];
   char c[5];
 };
-REFLECTION(st_char_t, a, b, c);
+YLT_REFL(st_char_t, a, b, c);
 TEST_CASE("test char") {
   std::string str = R"(
   {
@@ -816,7 +817,7 @@ TEST_CASE("test char") {
 struct fixed_vector_arr_t {
   std::vector<int> a[4];
 };
-REFLECTION(fixed_vector_arr_t, a);
+YLT_REFL(fixed_vector_arr_t, a);
 TEST_CASE("test fixed array") {
   std::string str = R"(
 {
@@ -854,7 +855,7 @@ struct vector_bool_t {
   std::vector<bool> a;
   bool b;
 };
-REFLECTION(vector_bool_t, a, b);
+YLT_REFL(vector_bool_t, a, b);
 TEST_CASE("test vector<bool>") {
   std::string str = R"({
   "a": [true, false],
@@ -880,7 +881,7 @@ struct test_numeric_t {
   std::vector<iguana::numeric_str> arr;
   iguana::numeric_str num;
 };
-REFLECTION(test_numeric_t, arr, num);
+YLT_REFL(test_numeric_t, arr, num);
 TEST_CASE("test numeric string") {
   std::string str = R"(
 { "arr": [1.5 , 2.4 , 3.7],
@@ -909,7 +910,7 @@ struct test_uint8_t {
   int8_t b;
   char c;
 };
-REFLECTION(test_uint8_t, a, b, c);
+YLT_REFL(test_uint8_t, a, b, c);
 TEST_CASE("test uint8 and int8") {
   std::string str = R"(
 { 
@@ -944,10 +945,10 @@ class some_object {
   some_object(int i, std::string str) : id(i), name(str) {}
   int get_id() const { return id; }
   std::string get_name() const { return name; }
-  REFLECTION(some_object, id, name);
+  YLT_REFL(some_object, id, name);
 };
 
-TEST_CASE("test inner reflection") {
+TEST_CASE("test inner YLT_REFL") {
   some_object obj{20, "tom"};
   std::string str;
   iguana::to_json(obj, str);
@@ -964,7 +965,7 @@ struct Contents_t {
   std::shared_ptr<std::vector<std::unique_ptr<int>>> vec_s;
   std::string b;
 };
-REFLECTION(Contents_t, vec, vec_s, b);
+YLT_REFL(Contents_t, vec, vec_s, b);
 
 TEST_CASE("test smart_ptr") {
   std::string str = R"(
@@ -993,7 +994,7 @@ struct person1 {
   std::shared_ptr<std::string> name;
   std::shared_ptr<int64_t> age;
 };
-REFLECTION(person1, name, age);
+YLT_REFL(person1, name, age);
 
 TEST_CASE("test smart point issue 223") {
   person1 p{std::make_shared<std::string>("tom"),