style: format virtual_schema.h

Remove decorative separator comments (=== and ---), redundant doc
comments, and inline comments that restate the code. Simplify
kind_of() if-constexpr chain to use consistent else-if style.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: 16bit-ykiko

include/eventide/serde/schema/field_info.h

@@ -20,12 +20,6 @@ namespace eventide::serde::schema {
 
 struct field_info;
 
-// ---------------------------------------------------------------------------
-// type_kind — unified type classification
-// ---------------------------------------------------------------------------
-
-/// Unified type classification replacing the old type_kind + scalar_kind pair.
-/// Scalars use fine-grained values; compound types use broad categories.
 enum class type_kind : std::uint8_t {
     // Scalars (fine-grained)
     null = 0,
@@ -60,23 +54,13 @@ enum class type_kind : std::uint8_t {
     any = 255,      // future: runtime dynamic type
 };
 
-// ---------------------------------------------------------------------------
-// tag_mode — variant tagging strategy
-// ---------------------------------------------------------------------------
-
 enum class tag_mode : std::uint8_t {
     none,
     external,
     internal,
     adjacent,
 };
 
-// ---------------------------------------------------------------------------
-// type_info — base class and subtypes
-// ---------------------------------------------------------------------------
-
-/// Base type descriptor. Scalars use this directly; compound types downcast
-/// to the appropriate subclass via `kind`.
 struct type_info {
     type_kind kind;
     std::string_view type_name;
@@ -106,30 +90,25 @@ struct type_info {
     }
 };
 
-/// array / set
 struct array_type_info : type_info {
     const type_info* element;
 };
 
-/// map
 struct map_type_info : type_info {
     const type_info* key;
     const type_info* value;
 };
 
-/// enum — runtime-accessible enum metadata
 struct enum_type_info : type_info {
     std::span<const std::string_view> member_names;
     std::span<const std::int64_t> member_values;
     type_kind underlying_kind;
 };
 
-/// tuple / pair
 struct tuple_type_info : type_info {
     std::span<const type_info* const> elements;
 };
 
-/// variant — includes tagging metadata
 struct variant_type_info : type_info {
     std::span<const type_info* const> alternatives;
     tag_mode tagging = tag_mode::none;
@@ -138,52 +117,33 @@ struct variant_type_info : type_info {
     std::span<const std::string_view> alt_names;
 };
 
-/// optional / smart_ptr — wraps the inner type
 struct optional_type_info : type_info {
     const type_info* inner;
 };
 
-// ---------------------------------------------------------------------------
-// field_info
-// ---------------------------------------------------------------------------
-
 struct field_info {
-    std::string_view name;                      // canonical wire name
-    std::span<const std::string_view> aliases;  // alias names
-    std::size_t offset;                         // byte offset from struct start
-    std::size_t physical_index;                 // original C++ struct field index
-    const type_info* type;                      // recursive type descriptor (wire view)
-
-    // Level 1 flags
-    bool has_default;   // schema::default_value
-    bool is_literal;    // schema::literal
-    bool has_skip_if;   // behavior::skip_if present
-    bool has_behavior;  // with/as/enum_string present
+    std::string_view name;
+    std::span<const std::string_view> aliases;
+    std::size_t offset;
+    std::size_t physical_index;
+    const type_info* type;
+
+    bool has_default;
+    bool is_literal;
+    bool has_skip_if;
+    bool has_behavior;
 };
 
-/// struct — placed after field_info so that std::span<const field_info> sees a complete type.
 struct struct_type_info : type_info {
     std::span<const field_info> fields;
     bool is_trivial_layout;
 };
 
-// ---------------------------------------------------------------------------
-// schema_opaque — opt-out from recursive type decomposition
-// ---------------------------------------------------------------------------
-
-/// Types marked schema_opaque are treated as opaque by the schema system.
-/// They get kind=unknown and are not recursively decomposed in type_info_instance.
-/// Backend-specific serialize/deserialize hooks handle these types directly.
 template <typename T>
 constexpr inline bool schema_opaque = false;
 
-// ---------------------------------------------------------------------------
-// kind_of<T>() — map C++ types to type_kind values
-// ---------------------------------------------------------------------------
-
 namespace detail {
 
-/// Map signed integer types to their exact-width type_kind.
 template <typename T>
 consteval type_kind signed_int_kind() {
     if constexpr(sizeof(T) == 1) {
@@ -198,7 +158,6 @@ consteval type_kind signed_int_kind() {
     }
 }
 
-/// Map unsigned integer types to their exact-width type_kind.
 template <typename T>
 consteval type_kind unsigned_int_kind() {
     if constexpr(sizeof(T) == 1) {
@@ -213,7 +172,6 @@ consteval type_kind unsigned_int_kind() {
     }
 }
 
-/// Map floating-point types to their type_kind.
 template <typename T>
 consteval type_kind floating_kind() {
     if constexpr(sizeof(T) <= 4) {
@@ -225,82 +183,42 @@ consteval type_kind floating_kind() {
 
 }  // namespace detail
 
-/// Map a C++ type to its type_kind value.
-///
-/// Scalars yield fine-grained kinds (int8, float64, etc.);
-/// compound types yield broad categories (array, map, structure, etc.).
-///
-/// The ordering of checks mirrors the dispatch chain in serde.h:
-///   annotated_type -> enum -> bool -> int -> uint -> float -> char ->
-///   str -> bytes -> null -> optional -> pointer -> variant -> tuple ->
-///   range -> reflectable_class
 template <typename T>
 consteval type_kind kind_of() {
     using V = std::remove_cvref_t<T>;
 
-    // Unwrap annotation to get the underlying type
     if constexpr(serde::annotated_type<V>) {
         return kind_of<typename V::annotated_type>();
-    }
-    // Opaque types with custom hooks — do not decompose
-    else if constexpr(schema_opaque<V>) {
+    } else if constexpr(schema_opaque<V>) {
         return type_kind::unknown;
-    }
-    // Enum -> enumeration
-    else if constexpr(std::is_enum_v<V>) {
+    } else if constexpr(std::is_enum_v<V>) {
         return type_kind::enumeration;
-    }
-    // Bool
-    else if constexpr(serde::bool_like<V>) {
+    } else if constexpr(serde::bool_like<V>) {
         return type_kind::boolean;
-    }
-    // Signed integers — size-based dispatch
-    else if constexpr(serde::int_like<V>) {
+    } else if constexpr(serde::int_like<V>) {
         return detail::signed_int_kind<V>();
-    }
-    // Unsigned integers — size-based dispatch
-    else if constexpr(serde::uint_like<V>) {
+    } else if constexpr(serde::uint_like<V>) {
         return detail::unsigned_int_kind<V>();
-    }
-    // Floating-point
-    else if constexpr(serde::floating_like<V>) {
+    } else if constexpr(serde::floating_like<V>) {
         return detail::floating_kind<V>();
-    }
-    // Character
-    else if constexpr(serde::char_like<V>) {
+    } else if constexpr(serde::char_like<V>) {
         return type_kind::character;
-    }
-    // String
-    else if constexpr(serde::str_like<V>) {
+    } else if constexpr(serde::str_like<V>) {
         return type_kind::string;
-    }
-    // Bytes
-    else if constexpr(serde::bytes_like<V>) {
+    } else if constexpr(serde::bytes_like<V>) {
         return type_kind::bytes;
-    }
-    // Null
-    else if constexpr(serde::null_like<V>) {
+    } else if constexpr(serde::null_like<V>) {
         return type_kind::null;
-    }
-    // Optional
-    else if constexpr(is_optional_v<V>) {
+    } else if constexpr(is_optional_v<V>) {
         return type_kind::optional;
-    }
-    // Smart pointers
-    else if constexpr(is_specialization_of<std::unique_ptr, V> ||
-                      is_specialization_of<std::shared_ptr, V>) {
+    } else if constexpr(is_specialization_of<std::unique_ptr, V> ||
+                        is_specialization_of<std::shared_ptr, V>) {
         return type_kind::pointer;
-    }
-    // Variant
-    else if constexpr(is_specialization_of<std::variant, V>) {
+    } else if constexpr(is_specialization_of<std::variant, V>) {
         return type_kind::variant;
-    }
-    // Tuple / pair (before range, since some tuples might satisfy range)
-    else if constexpr(serde::tuple_like<V>) {
+    } else if constexpr(serde::tuple_like<V>) {
         return type_kind::tuple;
-    }
-    // Range types: map / set / sequence
-    else if constexpr(std::ranges::input_range<V>) {
+    } else if constexpr(std::ranges::input_range<V>) {
         constexpr auto fmt = format_kind<V>;
         if constexpr(fmt == range_format::map) {
             return type_kind::map;
@@ -309,13 +227,9 @@ consteval type_kind kind_of() {
         } else {
             return type_kind::array;
         }
-    }
-    // Reflectable struct
-    else if constexpr(refl::reflectable_class<V>) {
+    } else if constexpr(refl::reflectable_class<V>) {
         return type_kind::structure;
-    }
-    // Unknown — no matching category
-    else {
+    } else {
         return type_kind::unknown;
     }
 }

include/eventide/serde/schema/field_slot.h

@@ -7,15 +7,9 @@
 
 namespace eventide::serde::schema {
 
-// ---------------------------------------------------------------------------
-// type_list -- compile-time type sequence
-// ---------------------------------------------------------------------------
-
 template <typename... Ts>
 struct type_list {};
 
-// -- element access --
-
 template <std::size_t I, typename List>
 struct type_list_element;
 
@@ -31,8 +25,6 @@ struct type_list_element<0, type_list<First, Rest...>> {
 template <std::size_t I, typename List>
 using type_list_element_t = typename type_list_element<I, List>::type;
 
-// -- concatenation (binary) --
-
 template <typename A, typename B>
 struct type_list_cat_impl;
 
@@ -44,8 +36,6 @@ struct type_list_cat_impl<type_list<As...>, type_list<Bs...>> {
 template <typename A, typename B>
 using type_list_cat_t = typename type_list_cat_impl<A, B>::type;
 
-// -- variadic concatenation --
-
 template <typename... Lists>
 struct type_list_concat;
 
@@ -66,8 +56,6 @@ struct type_list_concat<First, Second, Rest...> :
 template <typename... Lists>
 using type_list_concat_t = typename type_list_concat<Lists...>::type;
 
-// -- size --
-
 template <typename List>
 struct type_list_size;
 
@@ -77,20 +65,6 @@ struct type_list_size<type_list<Ts...>> : std::integral_constant<std::size_t, si
 template <typename List>
 constexpr inline std::size_t type_list_size_v = type_list_size<List>::value;
 
-// ---------------------------------------------------------------------------
-// field_slot -- compile-time per-field descriptor
-// ---------------------------------------------------------------------------
-
-/// Describes one logical (non-skipped, possibly-flattened) field at the type
-/// level.  Carried inside a type_list so that virtual_schema can expose a
-/// `slots` typedef for per-field compile-time dispatch.
-///
-/// @tparam RawType      The C++ field type (annotation unwrapped).
-/// @tparam WireType     The type that actually hits the wire (after
-///                       as<>/with<>/enum_string<> resolution).
-///                       Defaults to RawType when no behavior attr is present.
-/// @tparam BehaviorAttrs A std::tuple<...> of the behavior attributes found
-///                       on this field (skip_if, with, as, enum_string, tagged).
 template <typename RawType, typename WireType = RawType, typename BehaviorAttrs = std::tuple<>>
 struct field_slot {
     using raw_type = RawType;