From 10239f01bb0b81f0f802a952932c498a9835d0ed Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 11:13:39 -0600
Subject: [PATCH 1/6] tuple cleanup

---
 include/glaze/tuplet/tuple.hpp | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/include/glaze/tuplet/tuple.hpp b/include/glaze/tuplet/tuple.hpp
index 0f54a4141c..9e8eab04c1 100644
--- a/include/glaze/tuplet/tuple.hpp
+++ b/include/glaze/tuplet/tuple.hpp
@@ -51,8 +51,6 @@ namespace glz
 
       template <class Tup>
       using base_list_t = typename std::decay_t<Tup>::base_list;
-      template <class Tup>
-      using element_list_t = typename std::decay_t<Tup>::element_list;
 
       template <class Tuple>
       concept base_list_tuple = requires() { typename std::decay_t<Tuple>::base_list; };
@@ -140,9 +138,9 @@ namespace glz
    template <class T>
    using unwrap_ref_decay_t = typename std::unwrap_ref_decay<T>::type;
 
-   // tuplet::detail::get_tuple_base implementation
-   // tuplet::detail::apply_impl
-   namespace tuplet::detail
+   // tuplet::get_tuple_base implementation
+   // tuplet::apply_impl
+   namespace tuplet
    {
       template <class A, class... T>
       struct get_tuple_base;
@@ -186,13 +184,13 @@ namespace glz
       {
          return {{{static_cast<type_t<Outer>&&>(tup.identity_t<Outer>::value).identity_t<Inner>::value}...}};
       }
-   } // namespace tuplet::detail
+   }
 
    // tuple implementation
    namespace tuplet
    {
       template <class... T>
-      using tuple_base_t = typename detail::get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
+      using tuple_base_t = typename get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
    } // namespace tuplet
 
    template <class... T>
@@ -203,7 +201,6 @@ namespace glz
       using super = tuplet::tuple_base_t<T...>;
       using super::operator[];
       using base_list = typename super::base_list;
-      using element_list = tuplet::type_list<T...>;
       using super::decl_elem;
 
       template <tuplet::other_than<tuple> U> // Preserves default assignments
@@ -360,7 +357,6 @@ namespace glz
       constexpr static size_t N = 0;
       using super = tuplet::tuple_base_t<>;
       using base_list = tuplet::type_list<>;
-      using element_list = tuplet::type_list<>;
 
       template <tuplet::other_than<tuple> U> // Preserves default assignments
          requires tuplet::stateless<U> // Check that U is similarly stateless
@@ -456,7 +452,7 @@ namespace glz
    template <class F, tuplet::base_list_tuple Tup>
    constexpr decltype(auto) apply(F&& func, Tup&& tup)
    {
-      return tuplet::detail::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
+      return tuplet::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
                                         typename std::decay_t<Tup>::base_list());
    }
 
@@ -494,9 +490,9 @@ namespace glz
             using big_tuple = tuple<std::decay_t<T>...>;
 #endif
             using outer_bases = base_list_t<big_tuple>;
-            constexpr auto outer = detail::get_outer_bases(outer_bases{});
-            constexpr auto inner = detail::get_inner_bases(outer_bases{});
-            return detail::cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
+            constexpr auto outer = get_outer_bases(outer_bases{});
+            constexpr auto inner = get_inner_bases(outer_bases{});
+            return cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
          }
       }
 

From 7359227133ae9c2993b28526fe0fb2b79c0cecc0 Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 11:20:58 -0600
Subject: [PATCH 2/6] field_t

---
 include/glaze/beve/write.hpp   | 6 +++---
 include/glaze/core/reflect.hpp | 8 +++++++-
 include/glaze/json/write.hpp   | 6 +++---
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/include/glaze/beve/write.hpp b/include/glaze/beve/write.hpp
index 06d953ae83..9cba61b54a 100644
--- a/include/glaze/beve/write.hpp
+++ b/include/glaze/beve/write.hpp
@@ -677,7 +677,7 @@ namespace glz
          static constexpr size_t count_to_write = [] {
             size_t count{};
             invoke_table<N>([&]<size_t I>() {
-               using V = std::remove_cvref_t<refl_t<T, I>>;
+               using V = field_t<T, I>;
 
                if constexpr (std::same_as<V, hidden> || std::same_as<V, skip>) {
                   // do not serialize
@@ -707,7 +707,7 @@ namespace glz
             }();
 
             invoke_table<N>([&]<size_t I>() {
-               using val_t = std::remove_cvref_t<refl_t<T, I>>;
+               using val_t = field_t<T, I>;
 
                if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
@@ -745,7 +745,7 @@ namespace glz
             }();
 
             invoke_table<N>([&]<size_t I>() {
-               using val_t = std::remove_cvref_t<refl_t<T, I>>;
+               using val_t = field_t<T, I>;
 
                if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
diff --git a/include/glaze/core/reflect.hpp b/include/glaze/core/reflect.hpp
index b3dd789c34..06dc711411 100644
--- a/include/glaze/core/reflect.hpp
+++ b/include/glaze/core/reflect.hpp
@@ -207,11 +207,17 @@ namespace glz
       static constexpr auto size = 0;
    };
 
+   // The type of the field before get_member is applied
    template <class T, size_t I>
    using elem_t = reflect<T>::template elem<I>;
 
+   // The type of the field after get_member is applied
    template <class T, size_t I>
    using refl_t = reflect<T>::template type<I>;
+   
+   // The decayed type after get_member is called
+   template <class T, size_t I>
+   using field_t = std::remove_cvref_t<refl_t<T, I>>;
 
    // MSVC requires this specialization, otherwise it will try to instatiate dead `if constexpr` branches for N == 0
    template <opts Opts, class T>
@@ -234,7 +240,7 @@ namespace glz
          if constexpr (N > 0 && Opts.skip_null_members) {
             bool found_maybe_skipped{};
             for_each_short_circuit<N>([&](auto I) {
-               using V = std::remove_cvref_t<refl_t<T, I>>;
+               using V = field_t<T, I>;
 
                if constexpr (Opts.skip_null_members && detail::null_t<V>) {
                   found_maybe_skipped = true;
diff --git a/include/glaze/json/write.hpp b/include/glaze/json/write.hpp
index 17a050486f..2727903c08 100644
--- a/include/glaze/json/write.hpp
+++ b/include/glaze/json/write.hpp
@@ -1584,7 +1584,7 @@ namespace glz
          constexpr auto N = reflect<T>::size;
          std::optional<size_t> fixed = 2 + 16; // {} + extra padding
          for_each_short_circuit<N>([&](auto I) -> bool {
-            using val_t = std::remove_cvref_t<refl_t<T, I>>;
+            using val_t = field_t<T, I>;
             if constexpr (required_padding<val_t>()) {
                fixed.value() += required_padding<val_t>();
                fixed.value() += reflect<T>::keys[I].size() + 2; // key length
@@ -1680,7 +1680,7 @@ namespace glz
                if constexpr (object_info<Opts, T>::maybe_skipped) {
                   bool first = true;
                   invoke_table<N>([&]<size_t I>() {
-                     using val_t = std::remove_cvref_t<refl_t<T, I>>;
+                     using val_t = field_t<T, I>;
 
                      if constexpr (always_skipped<val_t>) {
                         return;
@@ -1784,7 +1784,7 @@ namespace glz
                      std::memcpy(&b[ix], quoted_key.data(), n);
                      ix += n;
 
-                     using val_t = std::remove_cvref_t<refl_t<T, I>>;
+                     using val_t = field_t<T, I>;
 
                      static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
                      if constexpr (reflectable<T>) {

From f4cefd048e5fbf3c1fee18dce52cbc330197bcdb Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 12:18:34 -0600
Subject: [PATCH 3/6] Fix maybe_skipped for always_null values

---
 include/glaze/core/reflect.hpp | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/include/glaze/core/reflect.hpp b/include/glaze/core/reflect.hpp
index 06dc711411..c957003f62 100644
--- a/include/glaze/core/reflect.hpp
+++ b/include/glaze/core/reflect.hpp
@@ -237,23 +237,19 @@ namespace glz
       static constexpr auto N = reflect<T>::size;
 
       static constexpr bool maybe_skipped = [] {
-         if constexpr (N > 0 && Opts.skip_null_members) {
-            bool found_maybe_skipped{};
-            for_each_short_circuit<N>([&](auto I) {
-               using V = field_t<T, I>;
-
-               if constexpr (Opts.skip_null_members && detail::null_t<V>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-
-               if constexpr (is_includer<V> || std::same_as<V, hidden> || std::same_as<V, skip>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-               return false; // continue
-            });
-            return found_maybe_skipped;
+         if constexpr (N > 0) {
+            if constexpr (Opts.skip_null_members) {
+               // if any type could be null then we might skip
+               return []<size_t... I>(std::index_sequence<I...>) {
+                  return ((detail::always_skipped<field_t<T, I>> || detail::null_t<field_t<T, I>>) || ...);
+               }(std::make_index_sequence<N>{});
+            }
+            else {
+               // if we have an always_skipped type then we return true
+               return []<size_t... I>(std::index_sequence<I...>) {
+                  return ((detail::always_skipped<field_t<T, I>>) || ...);
+               }(std::make_index_sequence<N>{});
+            }
          }
          else {
             return false;

From 7f3fd9fa1546810b6bd1165375ae7d8c5a498a28 Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 12:34:40 -0600
Subject: [PATCH 4/6] maybe_skipped boolean

---
 include/glaze/core/reflect.hpp                | 53 +++++++------------
 include/glaze/json/write.hpp                  |  2 +-
 .../json_reflection_test.cpp                  |  2 +-
 3 files changed, 21 insertions(+), 36 deletions(-)

diff --git a/include/glaze/core/reflect.hpp b/include/glaze/core/reflect.hpp
index c957003f62..2d6ccf4121 100644
--- a/include/glaze/core/reflect.hpp
+++ b/include/glaze/core/reflect.hpp
@@ -218,44 +218,29 @@ namespace glz
    // The decayed type after get_member is called
    template <class T, size_t I>
    using field_t = std::remove_cvref_t<refl_t<T, I>>;
-
-   // MSVC requires this specialization, otherwise it will try to instatiate dead `if constexpr` branches for N == 0
-   template <opts Opts, class T>
-   struct object_info;
-
-   template <opts Opts, class T>
-      requires(reflect<T>::size == 0)
-   struct object_info<Opts, T>
-   {
-      static constexpr bool maybe_skipped = false;
-   };
-
+   
    template <opts Opts, class T>
-      requires(reflect<T>::size > 0)
-   struct object_info<Opts, T>
-   {
-      static constexpr auto N = reflect<T>::size;
-
-      static constexpr bool maybe_skipped = [] {
-         if constexpr (N > 0) {
-            if constexpr (Opts.skip_null_members) {
-               // if any type could be null then we might skip
-               return []<size_t... I>(std::index_sequence<I...>) {
-                  return ((detail::always_skipped<field_t<T, I>> || detail::null_t<field_t<T, I>>) || ...);
-               }(std::make_index_sequence<N>{});
-            }
-            else {
-               // if we have an always_skipped type then we return true
-               return []<size_t... I>(std::index_sequence<I...>) {
-                  return ((detail::always_skipped<field_t<T, I>>) || ...);
-               }(std::make_index_sequence<N>{});
-            }
+   inline constexpr bool maybe_skipped = [] {
+      if constexpr (reflect<T>::size > 0)
+      {
+         constexpr auto N = reflect<T>::size;
+         if constexpr (Opts.skip_null_members) {
+            // if any type could be null then we might skip
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((detail::always_skipped<field_t<T, I>> || detail::null_t<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
          }
          else {
-            return false;
+            // if we have an always_skipped type then we return true
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((detail::always_skipped<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
          }
-      }();
-   };
+      }
+      else {
+         return false;
+      }
+   }();
 }
 
 namespace glz::detail
diff --git a/include/glaze/json/write.hpp b/include/glaze/json/write.hpp
index 2727903c08..33ad9fbfe4 100644
--- a/include/glaze/json/write.hpp
+++ b/include/glaze/json/write.hpp
@@ -1677,7 +1677,7 @@ namespace glz
                }();
 
                static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
-               if constexpr (object_info<Opts, T>::maybe_skipped) {
+               if constexpr (maybe_skipped<Opts, T>) {
                   bool first = true;
                   invoke_table<N>([&]<size_t I>() {
                      using val_t = field_t<T, I>;
diff --git a/tests/json_reflection_test/json_reflection_test.cpp b/tests/json_reflection_test/json_reflection_test.cpp
index fa45d13385..9ac600ee20 100644
--- a/tests/json_reflection_test/json_reflection_test.cpp
+++ b/tests/json_reflection_test/json_reflection_test.cpp
@@ -454,7 +454,7 @@ struct empty_t
 {};
 
 static_assert(glz::reflect<empty_t>::size == 0);
-static_assert(not glz::object_info<glz::opts{}, empty_t>::maybe_skipped);
+static_assert(not glz::maybe_skipped<glz::opts{}, empty_t>);
 
 suite empty_test = [] {
    "empty_t"_test = [] {

From 8d6f72fc82c580bee26fafd19322fe1e29c5830c Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 12:48:23 -0600
Subject: [PATCH 5/6] Update tuple.hpp

---
 include/glaze/tuplet/tuple.hpp | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/include/glaze/tuplet/tuple.hpp b/include/glaze/tuplet/tuple.hpp
index 9e8eab04c1..467e40ea35 100644
--- a/include/glaze/tuplet/tuple.hpp
+++ b/include/glaze/tuplet/tuple.hpp
@@ -33,16 +33,12 @@ namespace glz
       template <class T>
       using identity_t = T;
 
-      // Obtains T::type
       template <class T>
       using type_t = typename T::type;
 
       template <size_t I>
       using tag = std::integral_constant<size_t, I>;
 
-      template <size_t I>
-      constexpr tag<I> tag_v{};
-
       template <size_t N>
       using tag_range = std::make_index_sequence<N>;
 
@@ -184,14 +180,10 @@ namespace glz
       {
          return {{{static_cast<type_t<Outer>&&>(tup.identity_t<Outer>::value).identity_t<Inner>::value}...}};
       }
-   }
-
-   // tuple implementation
-   namespace tuplet
-   {
+      
       template <class... T>
       using tuple_base_t = typename get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
-   } // namespace tuplet
+   }
 
    template <class... T>
    struct tuple : tuplet::tuple_base_t<T...>

From b08139a0cbc672fb3b8ea11b4ddfc624ebff708b Mon Sep 17 00:00:00 2001
From: Stephen Berry <stephenberry.developer@gmail.com>
Date: Tue, 31 Dec 2024 13:03:08 -0600
Subject: [PATCH 6/6] Update tuple.hpp

---
 include/glaze/tuplet/tuple.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/glaze/tuplet/tuple.hpp b/include/glaze/tuplet/tuple.hpp
index 467e40ea35..6d2a5b010d 100644
--- a/include/glaze/tuplet/tuple.hpp
+++ b/include/glaze/tuplet/tuple.hpp
@@ -189,7 +189,7 @@ namespace glz
    struct tuple : tuplet::tuple_base_t<T...>
    {
       static constexpr auto glaze_reflect = false;
-      constexpr static size_t N = sizeof...(T);
+      static constexpr size_t N = sizeof...(T);
       using super = tuplet::tuple_base_t<T...>;
       using super::operator[];
       using base_list = typename super::base_list;