diff --git a/include/ylt/struct_pack/calculate_size.hpp b/include/ylt/struct_pack/calculate_size.hpp
index a89f3d1ff..93124b62e 100644
--- a/include/ylt/struct_pack/calculate_size.hpp
+++ b/include/ylt/struct_pack/calculate_size.hpp
@@ -45,6 +45,9 @@ constexpr size_info inline calculate_one_size(const T &item) {
   size_info ret{};
   if constexpr (id == type_id::monostate_t) {
   }
+  else if constexpr (id == type_id::user_defined_type) {
+    ret.total = sp_get_needed_size(item);
+  }
   else if constexpr (detail::varint_t<type, parent_tag>) {
     if constexpr (is_enable_fast_varint_coding(parent_tag)) {
       // skip it. It has been calculated in parent.
@@ -105,7 +108,7 @@ constexpr size_info inline calculate_one_size(const T &item) {
     if (item) {
       if constexpr (is_base_class<typename type::element_type>) {
         ret.total += sizeof(uint32_t);
-        bool is_ok;
+        bool is_ok = false;
         auto index = search_type_by_md5<typename type::element_type>(
             item->get_struct_pack_id(), is_ok);
         if SP_UNLIKELY (!is_ok) {
diff --git a/include/ylt/struct_pack/endian_wrapper.hpp b/include/ylt/struct_pack/endian_wrapper.hpp
index 0b4037cf5..578df95e5 100644
--- a/include/ylt/struct_pack/endian_wrapper.hpp
+++ b/include/ylt/struct_pack/endian_wrapper.hpp
@@ -19,10 +19,12 @@
 #include <type_traits>
 
 #include "reflection.hpp"
+#include "ylt/struct_pack/error_code.hpp"
 #include "ylt/struct_pack/marco.h"
 #include "ylt/struct_pack/util.h"
 
-namespace struct_pack::detail {
+namespace struct_pack {
+namespace detail {
 #if __cpp_lib_endian >= 201907L
 constexpr inline bool is_system_little_endian =
     (std::endian::little == std::endian::native);
@@ -132,7 +134,8 @@ inline uint64_t bswap64(uint64_t raw) {
 };
 
 template <std::size_t block_size, typename writer_t>
-void write_wrapper(writer_t& writer, const char* SP_RESTRICT data) {
+STRUCT_PACK_INLINE void write_wrapper(writer_t& writer,
+                                      const char* SP_RESTRICT data) {
   if constexpr (is_system_little_endian || block_size == 1) {
     writer.write(data, block_size);
   }
@@ -159,14 +162,16 @@ void write_wrapper(writer_t& writer, const char* SP_RESTRICT data) {
   }
 }
 template <typename writer_t>
-void write_bytes_array(writer_t& writer, const char* data, std::size_t length) {
+STRUCT_PACK_INLINE void write_bytes_array(writer_t& writer, const char* data,
+                                          std::size_t length) {
   if SP_UNLIKELY (length >= PTRDIFF_MAX)
     unreachable();
   else
     writer.write(data, length);
 }
 template <std::size_t block_size, typename writer_t, typename T>
-void low_bytes_write_wrapper(writer_t& writer, const T& elem) {
+STRUCT_PACK_INLINE void low_bytes_write_wrapper(writer_t& writer,
+                                                const T& elem) {
   static_assert(sizeof(T) >= block_size);
   if constexpr (is_system_little_endian) {
     const char* data = (const char*)&elem;
@@ -194,7 +199,7 @@ void low_bytes_write_wrapper(writer_t& writer, const T& elem) {
   }
 }
 template <std::size_t block_size, typename reader_t>
-bool read_wrapper(reader_t& reader, char* SP_RESTRICT data) {
+STRUCT_PACK_INLINE bool read_wrapper(reader_t& reader, char* SP_RESTRICT data) {
   if constexpr (is_system_little_endian || block_size == 1) {
     return static_cast<bool>(reader.read(data, block_size));
   }
@@ -225,12 +230,13 @@ bool read_wrapper(reader_t& reader, char* SP_RESTRICT data) {
   }
 }
 template <typename reader_t>
-bool read_bytes_array(reader_t& reader, char* SP_RESTRICT data,
-                      std::size_t length) {
+STRUCT_PACK_INLINE bool read_bytes_array(reader_t& reader,
+                                         char* SP_RESTRICT data,
+                                         std::size_t length) {
   return static_cast<bool>(reader.read(data, length));
 }
 template <std::size_t block_size, typename reader_t, typename T>
-bool low_bytes_read_wrapper(reader_t& reader, T& elem) {
+STRUCT_PACK_INLINE bool low_bytes_read_wrapper(reader_t& reader, T& elem) {
   static_assert(sizeof(T) >= block_size);
   if constexpr (is_system_little_endian) {
     char* data = (char*)&elem;
@@ -263,4 +269,170 @@ bool low_bytes_read_wrapper(reader_t& reader, T& elem) {
     }
   }
 }
-};  // namespace struct_pack::detail
\ No newline at end of file
+}  // namespace detail
+template <typename Writer, typename T>
+STRUCT_PACK_INLINE void write(Writer& writer, const T& t) {
+  if constexpr (std::is_fundamental_v<T>) {
+    detail::write_wrapper<sizeof(T)>(writer, (const char*)&t);
+  }
+  else if constexpr (detail::array<T>) {
+    if constexpr (detail::is_little_endian_copyable<sizeof(t[0])> &&
+                  std::is_fundamental_v<decltype(t[0])>) {
+      writer_bytes_array(writer, (const char*)&t.data(), sizeof(T));
+    }
+    else {
+      for (auto& e : t) write(writer, e);
+    }
+  }
+  else if constexpr (detail::string<T> || detail::container<T>) {
+    std::uint64_t len = t.size();
+    detail::write_wrapper<sizeof(std::size_t)>(writer, (char*)&len);
+    if constexpr (detail::continuous_container<T> &&
+                  detail::is_little_endian_copyable<sizeof(t[0])>) {
+      writer_bytes_array(writer, (const char*)&t.data(), len * sizeof(t[0]));
+    }
+    else {
+      for (auto& e : t) write(writer, e);
+    }
+  }
+  else {
+    static_assert(!sizeof(T), "not support type");
+  }
+}
+template <typename Writer, typename T>
+STRUCT_PACK_INLINE void write(Writer& writer, const T* t, std::size_t length) {
+  if constexpr (std::is_fundamental_v<T>) {
+    if constexpr (detail::is_little_endian_copyable<sizeof(T)>) {
+      write_bytes_array(writer, (const char*)t, sizeof(T) * length);
+    }
+    else {
+      for (std::size_t i = 0; i < length; ++i) write(writer, t[i]);
+    }
+  }
+  else {
+    static_assert(!sizeof(T), "not support type");
+  }
+}
+template <typename T>
+STRUCT_PACK_INLINE constexpr std::size_t get_write_size(const T& t) {
+  if constexpr (std::is_fundamental_v<T>) {
+    return sizeof(T);
+  }
+  else if constexpr (detail::array<T>) {
+    if constexpr (std::is_fundamental_v<decltype(t[0])>) {
+      return sizeof(T);
+    }
+    else {
+      std::size_t ret = 0;
+      for (auto& e : t) ret += get_write_size(e);
+      return ret;
+    }
+  }
+  else if constexpr (detail::string<T> || detail::container<T>) {
+    std::size_t ret = 8;
+    if constexpr (detail::continuous_container<T> &&
+                  detail::is_little_endian_copyable<sizeof(t[0])>) {
+      ret += t.size() * sizeof(t[0]);
+    }
+    else {
+      for (auto& e : t) ret += write(e);
+    }
+    return ret;
+  }
+  else {
+    static_assert(!sizeof(T), "not support type");
+  }
+}
+template <typename T>
+STRUCT_PACK_INLINE constexpr std::size_t get_write_size(const T* t,
+                                                        std::size_t length) {
+  return sizeof(T) * length;
+}
+template <typename Reader, typename T>
+STRUCT_PACK_INLINE struct_pack::errc read(Reader& reader, T& t) {
+  if constexpr (std::is_fundamental_v<T>) {
+    if (!detail::read_wrapper<sizeof(T)>(reader, (char*)&t)) {
+      return struct_pack::errc::no_buffer_space;
+    }
+    else {
+      return {};
+    }
+  }
+  else if constexpr (detail::array<T>) {
+    if constexpr (std::is_fundamental_v<decltype(t[0])> &&
+                  detail::is_little_endian_copyable<sizeof(t[0])>) {
+      return read_bytes_array(reader, (char*)&t.data(), sizeof(T));
+    }
+    else {
+      struct_pack::errc ec;
+      for (auto& e : t) {
+        ec = read(reader, e);
+        if SP_UNLIKELY (ec != struct_pack::errc{}) {
+          return ec;
+        }
+      }
+      return struct_pack::errc{};
+    }
+  }
+  else if constexpr (detail::string<T> || detail::container<T>) {
+    std::uint64_t sz;
+    auto ec = read(reader, sz);
+    if SP_UNLIKELY (ec != struct_pack::errc{}) {
+      return ec;
+    }
+    if constexpr (detail::continuous_container<T> &&
+                  std::is_fundamental_v<decltype(t[0])> &&
+                  detail::is_little_endian_copyable<sizeof(t[0])> &&
+                  checkable_reader_t<Reader>) {
+      if SP_UNLIKELY (sz > UINT64_MAX / sizeof(t[0]) || sz > SIZE_MAX) {
+        return struct_pack::errc::invalid_buffer;
+      }
+      std::size_t mem_size = sz * sizeof(t[0]);
+      if SP_UNLIKELY (!reader.check(mem_size)) {
+        return struct_pack::errc::no_buffer_space;
+      }
+      detail::resize(t, mem_size);
+      return read_bytes_array(reader, (char*)&t.data(), mem_size);
+    }
+    else {
+      for (std::size_t i = 0; i < sz; ++i) {
+        t.emplace_back();
+        ec = read(reader, t.back());
+        if SP_UNLIKELY (ec != struct_pack::errc{}) {
+          return ec;
+        }
+      }
+      return struct_pack::errc{};
+    }
+  }
+  else {
+    static_assert(!sizeof(T), "not support type");
+  }
+}
+template <typename Reader, typename T>
+struct_pack::errc read(Reader& reader, T* t, std::size_t length) {
+  if constexpr (std::is_fundamental_v<T>) {
+    if constexpr (detail::is_little_endian_copyable<sizeof(T)>) {
+      if (!read_bytes_array(reader, (char*)t, sizeof(T) * length)) {
+        return struct_pack::errc::no_buffer_space;
+      }
+      else {
+        return {};
+      }
+    }
+    else {
+      struct_pack::errc ec{};
+      for (std::size_t i = 0; i < length; ++i) {
+        ec = read(reader, t[i]);
+        if SP_UNLIKELY (ec != struct_pack::errc{}) {
+          return ec;
+        }
+      };
+      return ec;
+    }
+  }
+  else {
+    static_assert(!sizeof(T), "not support type");
+  }
+}
+};  // namespace struct_pack
\ No newline at end of file
diff --git a/include/ylt/struct_pack/md5_constexpr.hpp b/include/ylt/struct_pack/md5_constexpr.hpp
index 40e328b97..cf353f825 100644
--- a/include/ylt/struct_pack/md5_constexpr.hpp
+++ b/include/ylt/struct_pack/md5_constexpr.hpp
@@ -27,7 +27,12 @@ namespace struct_pack {
 template <typename CharType, std::size_t Size>
 struct string_literal {
   constexpr string_literal() = default;
-
+  constexpr string_literal(std::string_view str) : ar{} {
+    for (size_t i = 0; i < Size; ++i) {
+      ar[i] = str[i];
+    }
+    ar[Size] = '\0';
+  }
   constexpr string_literal(const CharType (&value)[Size + 1]) : ar{} {
     for (size_t i = 0; i <= Size; ++i) {
       ar[i] = value[i];
diff --git a/include/ylt/struct_pack/packer.hpp b/include/ylt/struct_pack/packer.hpp
index c3d996dde..7ee110b52 100644
--- a/include/ylt/struct_pack/packer.hpp
+++ b/include/ylt/struct_pack/packer.hpp
@@ -22,6 +22,7 @@
 #include "calculate_size.hpp"
 #include "endian_wrapper.hpp"
 #include "reflection.hpp"
+#include "ylt/struct_pack/type_id.hpp"
 #include "ylt/struct_pack/util.h"
 #include "ylt/struct_pack/varint.hpp"
 namespace struct_pack::detail {
@@ -248,6 +249,9 @@ class packer {
       else if constexpr (std::is_same_v<type, std::monostate>) {
         // do nothing
       }
+      else if constexpr (id == type_id::user_defined_type) {
+        sp_serialize_to(writer_, item);
+      }
       else if constexpr (detail::varint_t<type, parent_tag>) {
         if constexpr (is_enable_fast_varint_coding(parent_tag)) {
           // do nothing
diff --git a/include/ylt/struct_pack/reflection.hpp b/include/ylt/struct_pack/reflection.hpp
index e45719dbb..482e0135e 100644
--- a/include/ylt/struct_pack/reflection.hpp
+++ b/include/ylt/struct_pack/reflection.hpp
@@ -36,6 +36,10 @@
 #include "marco.h"
 #include "util.h"
 
+#if __cpp_concepts >= 201907L
+#include <concepts>
+#endif
+
 namespace struct_pack {
 
 enum sp_config : uint64_t {
@@ -146,11 +150,6 @@ constexpr bool view_reader_t = reader_t<T> &&view_reader_t_impl<T>::value;
 
 #if __cpp_concepts >= 201907L
 
-template <typename T>
-concept check_reader_t = reader_t<T> && requires(T t) {
-  t.check(std::size_t{});
-};
-
 template <typename T>
 concept can_reserve = requires(T t) {
   t.reserve(std::size_t{});
@@ -163,17 +162,6 @@ concept can_shrink_to_fit = requires(T t) {
 
 #else
 
-template <typename T, typename = void>
-struct check_reader_t_impl : std::false_type {};
-
-template <typename T>
-struct check_reader_t_impl<
-    T, std::void_t<decltype(std::declval<T>().check(std::size_t{}))>>
-    : std::true_type {};
-
-template <typename T>
-constexpr bool check_reader_t = reader_t<T> &&check_reader_t_impl<T>::value;
-
 template <typename T, typename = void>
 struct can_reserve_impl : std::false_type {};
 
@@ -614,6 +602,46 @@ template <typename T, typename = void>
   constexpr bool user_defined_config = user_defined_config_impl<T>::value;
 #endif
 
+struct memory_reader;
+
+#if __cpp_concepts >= 201907L
+  template <typename Type>
+  concept user_defined_serialization = requires (Type& t) {
+    sp_serialize_to(std::declval<struct_pack::detail::memory_writer&>(),(const Type&)t);
+    {sp_deserialize_to(std::declval<struct_pack::detail::memory_reader&>(),t)} -> std::same_as<struct_pack::errc>;
+    {sp_get_needed_size((const Type&)t)}->std::same_as<std::size_t>;
+  };
+  template <typename Type>
+  concept user_defined_type_name = requires {
+    { sp_set_type_name((Type*)nullptr) } -> std::same_as<std::string_view>;
+  };
+#else
+
+  template <typename T, typename = void>
+  struct user_defined_serialization_impl : std::false_type {};
+
+  template <typename T>
+  struct user_defined_serialization_impl<T, std::void_t<
+    decltype(sp_serialize_to(std::declval<struct_pack::detail::memory_writer&>(),std::declval<const T&>())),
+    std::enable_if<std::is_same_v<decltype(sp_deserialize_to(std::declval<struct_pack::detail::memory_reader&>(),std::declval<T&>())), struct_pack::errc>,
+    std::enable_if<std::is_same_v<decltype(sp_get_needed_size(std::declval<const T&>())), std::string_view>>>>>
+      : std::true_type {};
+
+  template <typename Type>
+  constexpr bool user_defined_serialization = user_defined_serialization_impl<Type>::value;
+
+  template <typename T, typename = void>
+  struct user_defined_type_name_impl : std::false_type {};
+
+  template <typename T>
+  struct user_defined_type_name_impl<T, std::void_t<
+    std::enable_if<std::is_same_v<decltype(sp_set_type_name((T*)nullptr)), std::string_view>>>>
+      : std::true_type {};
+
+  template <typename Type>
+  constexpr bool user_defined_type_name = user_defined_type_name_impl<Type>::value;
+#endif
+
 #if __cpp_concepts >= 201907L
   template <typename Type>
   concept tuple_size = requires(Type tuple) {
@@ -810,7 +838,10 @@ template <typename T, typename = void>
                     ...);
       }
       static constexpr bool solve() {
-        if constexpr (std::is_same_v<T,std::monostate>) {
+        if constexpr (user_defined_serialization<T>) {
+          return false;
+        }
+        else if constexpr (std::is_same_v<T,std::monostate>) {
           return true;
         }
         else if constexpr (std::is_abstract_v<T>) {
@@ -2218,6 +2249,26 @@ constexpr decltype(auto) STRUCT_PACK_INLINE template_switch(std::size_t index,
   }
 }  // namespace detail
 }  // namespace detail
+#if __cpp_concepts >= 201907L
+
+template <typename T>
+concept checkable_reader_t = reader_t<T> && requires(T t) {
+  t.check(std::size_t{});
+};
+
+#else
+
+template <typename T, typename = void>
+struct checkable_reader_t_impl : std::false_type {};
+
+template <typename T>
+struct checkable_reader_t_impl<
+    T, std::void_t<decltype(std::declval<T>().check(std::size_t{}))>>
+    : std::true_type {};
+
+template <typename T>
+constexpr bool checkable_reader_t = reader_t<T> &&checkable_reader_t_impl<T>::value;
+#endif
 }  // namespace struct_pack
 
 // clang-format off
diff --git a/include/ylt/struct_pack/type_calculate.hpp b/include/ylt/struct_pack/type_calculate.hpp
index 86c93d23c..3991bd857 100644
--- a/include/ylt/struct_pack/type_calculate.hpp
+++ b/include/ylt/struct_pack/type_calculate.hpp
@@ -187,6 +187,22 @@ constexpr decltype(auto) get_type_literal() {
   if constexpr (is_trivial_view_v<Arg>) {
     return get_type_literal<typename Arg::value_type, ParentArgs...>();
   }
+  else if constexpr (user_defined_serialization<Arg>) {
+    constexpr auto begin = string_literal<char, 1>{
+        {static_cast<char>(type_id::user_defined_type)}};
+    constexpr auto end =
+        string_literal<char, 1>{{static_cast<char>(type_id::type_end_flag)}};
+    if constexpr (user_defined_type_name<Arg>) {
+      constexpr auto type_name = sp_set_type_name((Arg *)nullptr);
+      string_literal<char, type_name.size()> ret{type_name};
+      return begin + ret + end;
+    }
+    else {
+      constexpr auto type_name = type_string<Arg>();
+      string_literal<char, type_name.size()> ret{type_name};
+      return begin + ret + end;
+    }
+  }
   else {
     constexpr std::size_t has_cycle = check_circle<Arg, ParentArgs...>();
     if constexpr (has_cycle != 0) {
@@ -307,6 +323,22 @@ constexpr decltype(auto) get_types_literal() {
   if constexpr (is_trivial_view_v<T>) {
     return get_types_literal<T::value_type, Args...>();
   }
+  else if constexpr (user_defined_serialization<T>) {
+    constexpr auto begin = string_literal<char, 1>{
+        {static_cast<char>(type_id::user_defined_type)}};
+    constexpr auto end =
+        string_literal<char, 1>{{static_cast<char>(type_id::type_end_flag)}};
+    if constexpr (user_defined_type_name<T>) {
+      constexpr auto type_name = sp_set_type_name((T *)nullptr);
+      string_literal<char, type_name.size()> ret{type_name};
+      return begin + ret + end;
+    }
+    else {
+      constexpr auto type_name = type_string<T>();
+      string_literal<char, type_name.size()> ret{type_name};
+      return begin + ret + end;
+    }
+  }
   else {
     constexpr auto root_id = get_type_id<remove_cvref_t<T>>();
     if constexpr (root_id == type_id::struct_t) {
@@ -835,13 +867,17 @@ constexpr bool check_has_metainfo() {
 template <typename U>
 constexpr auto get_types() {
   using T = remove_cvref_t<U>;
-  if constexpr (std::is_fundamental_v<T> || std::is_enum_v<T> || varint_t<T> ||
-                string<T> || container<T> || optional<T> || unique_ptr<T> ||
-                is_variant_v<T> || expected<T> || array<T> || c_array<T> ||
-                std::is_same_v<std::monostate, T> || bitset<T>
+  if constexpr (user_defined_serialization<T>) {
+    return declval<std::tuple<T>>();
+  }
+  else if constexpr (std::is_fundamental_v<T> || std::is_enum_v<T> ||
+                     varint_t<T> || string<T> || container<T> || optional<T> ||
+                     unique_ptr<T> || is_variant_v<T> || expected<T> ||
+                     array<T> || c_array<T> ||
+                     std::is_same_v<std::monostate, T> || bitset<T>
 #if (__GNUC__ || __clang__) && defined(STRUCT_PACK_ENABLE_INT128)
-                || std::is_same_v<__int128, T> ||
-                std::is_same_v<unsigned __int128, T>
+                     || std::is_same_v<__int128, T> ||
+                     std::is_same_v<unsigned __int128, T>
 #endif
   ) {
     return declval<std::tuple<T>>();
diff --git a/include/ylt/struct_pack/type_id.hpp b/include/ylt/struct_pack/type_id.hpp
index a25701774..a518b4629 100644
--- a/include/ylt/struct_pack/type_id.hpp
+++ b/include/ylt/struct_pack/type_id.hpp
@@ -66,6 +66,8 @@ enum class type_id {
   expected_t,
   bitset_t,
   polymorphic_unique_ptr_t,
+  // flag for user-defined type
+  user_defined_type = 249,
   // monostate, or void
   monostate_t = 250,
   // circle_flag
@@ -274,7 +276,10 @@ template <typename T, std::size_t parent_tag = 0>
 constexpr type_id get_type_id() {
   static_assert(CHAR_BIT == 8);
   // compatible member, which should be ignored in MD5 calculated.
-  if constexpr (optional<T> && is_compatible_v<T>) {
+  if constexpr (user_defined_serialization<T>) {
+    return type_id::user_defined_type;
+  }
+  else if constexpr (optional<T> && is_compatible_v<T>) {
     return type_id::compatible_t;
   }
   else if constexpr (detail::varint_t<T, parent_tag>) {
diff --git a/include/ylt/struct_pack/unpacker.hpp b/include/ylt/struct_pack/unpacker.hpp
index a2d92e5f8..751b3df6d 100644
--- a/include/ylt/struct_pack/unpacker.hpp
+++ b/include/ylt/struct_pack/unpacker.hpp
@@ -778,6 +778,14 @@ class unpacker {
       else if constexpr (std::is_same_v<type, std::monostate>) {
         // do nothing
       }
+      else if constexpr (id == type_id::user_defined_type) {
+        if constexpr (NotSkip) {
+          sp_deserialize_to(reader_, item);
+        }
+        else {
+          sp_deserialize_to_with_skip(reader_, item);
+        }
+      }
       else if constexpr (detail::varint_t<type, parent_tag>) {
         if constexpr (is_enable_fast_varint_coding(parent_tag)) {
           // do nothing, we have deserialized it in parent.
@@ -1002,7 +1010,7 @@ class unpacker {
                 item = {(value_type *)(view), (std::size_t)size};
               }
               else {
-                if constexpr (check_reader_t<Reader>) {
+                if constexpr (checkable_reader_t<Reader>) {
                   if SP_UNLIKELY (!reader_.check(mem_sz)) {
                     return struct_pack::errc::no_buffer_space;
                   }
diff --git a/include/ylt/struct_pack/util.h b/include/ylt/struct_pack/util.h
index 87d86321e..25cc12c56 100644
--- a/include/ylt/struct_pack/util.h
+++ b/include/ylt/struct_pack/util.h
@@ -17,6 +17,7 @@
 #include <array>
 #include <cstddef>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -24,6 +25,41 @@
 
 namespace struct_pack::detail {
 
+template <typename T>
+constexpr std::string_view get_raw_name() {
+#ifdef _MSC_VER
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+template <auto T>
+constexpr std::string_view get_raw_name() {
+#ifdef _MSC_VER
+  return __FUNCSIG__;
+#else
+  return __PRETTY_FUNCTION__;
+#endif
+}
+
+template <typename T>
+inline constexpr std::string_view type_string() {
+  constexpr std::string_view sample = get_raw_name<int>();
+  constexpr size_t pos = sample.find("int");
+  constexpr std::string_view str = get_raw_name<T>();
+  constexpr auto next1 = str.rfind(sample[pos + 3]);
+#if defined(_MSC_VER)
+  constexpr std::size_t npos = str.find_first_of(" ", pos);
+  if (npos != std::string_view::npos)
+    return str.substr(npos + 1, next1 - npos - 1);
+  else
+    return str.substr(pos, next1 - pos);
+#else
+  return str.substr(pos, next1 - pos);
+#endif
+}
+
 #if __cpp_concepts >= 201907L
 constexpr bool is_string_reserve_shrink = requires { std::string{}.reserve(); };
 #else
diff --git a/include/ylt/thirdparty/iguana/enum_reflection.hpp b/include/ylt/thirdparty/iguana/enum_reflection.hpp
index 1e0d2ebe6..2f5ea98d1 100644
--- a/include/ylt/thirdparty/iguana/enum_reflection.hpp
+++ b/include/ylt/thirdparty/iguana/enum_reflection.hpp
@@ -31,11 +31,14 @@ inline constexpr std::string_view type_string() {
   constexpr std::string_view str = get_raw_name<T>();
   constexpr auto next1 = str.rfind(sample[pos + 3]);
 #if defined(_MSC_VER)
-  constexpr auto s1 = str.substr(pos + 6, next1 - pos - 6);
+  constexpr std::size_t npos = str.find_first_of(" ", pos);
+  if (npos != std::string_view::npos)
+    return str.substr(npos + 1, next1 - npos - 1);
+  else
+    return str.substr(pos, next1 - pos);
 #else
-  constexpr auto s1 = str.substr(pos, next1 - pos);
+  return str.substr(pos, next1 - pos);
 #endif
-  return s1;
 }
 
 template <auto T>
diff --git a/src/struct_pack/examples/BUILD.bazel b/src/struct_pack/examples/BUILD.bazel
index 0cd5740f2..4b535caad 100644
--- a/src/struct_pack/examples/BUILD.bazel
+++ b/src/struct_pack/examples/BUILD.bazel
@@ -2,7 +2,7 @@ load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 
 cc_binary(
     name = "serialize_example",
-    srcs = ["basic_usage.cpp","main.cpp","non_aggregated_type.cpp"],
+    srcs = ["basic_usage.cpp","main.cpp","non_aggregated_type.cpp","serialize_config.cpp","user_defined_serialization.cpp"],
     copts = ["-std=c++20"],
     deps = [
         "//:ylt"
diff --git a/src/struct_pack/examples/CMakeLists.txt b/src/struct_pack/examples/CMakeLists.txt
index dafe28f08..89d30df93 100644
--- a/src/struct_pack/examples/CMakeLists.txt
+++ b/src/struct_pack/examples/CMakeLists.txt
@@ -18,4 +18,4 @@ else()
   # include_directories(include)
   # include_directories(include/ylt/thirdparty)
 endif()
-add_executable(struct_pack_example basic_usage.cpp non_aggregated_type.cpp serialize_config.cpp main.cpp)
\ No newline at end of file
+add_executable(struct_pack_example basic_usage.cpp non_aggregated_type.cpp serialize_config.cpp user_defined_serialization.cpp main.cpp)
\ No newline at end of file
diff --git a/src/struct_pack/examples/main.cpp b/src/struct_pack/examples/main.cpp
index d43e44c55..bacc07834 100644
--- a/src/struct_pack/examples/main.cpp
+++ b/src/struct_pack/examples/main.cpp
@@ -17,9 +17,11 @@
 void basic_usage();
 void non_aggregated_type();
 void serialize_config();
-
+void user_defined_serialization();
 int main() {
   basic_usage();
   non_aggregated_type();
+  serialize_config();
+  user_defined_serialization();
   return 0;
 }
diff --git a/src/struct_pack/examples/user_defined_serialization.cpp b/src/struct_pack/examples/user_defined_serialization.cpp
new file mode 100644
index 000000000..6e5d17990
--- /dev/null
+++ b/src/struct_pack/examples/user_defined_serialization.cpp
@@ -0,0 +1,93 @@
+#include <cstdlib>
+
+#include "ylt/struct_pack.hpp"
+namespace my_name_space {
+
+struct array2D {
+  unsigned int x;
+  unsigned int y;
+  float* p;
+  array2D(unsigned int x, unsigned int y) : x(x), y(y) {
+    p = (float*)calloc(1ull * x * y, sizeof(float));
+  }
+  array2D(const array2D&) = delete;
+  array2D(array2D&& o) : x(o.x), y(o.y), p(o.p) { o.p = nullptr; };
+  array2D& operator=(const array2D&) = delete;
+  array2D& operator=(array2D&& o) {
+    x = o.x;
+    y = o.y;
+    p = o.p;
+    o.p = nullptr;
+    return *this;
+  }
+  float& operator()(std::size_t i, std::size_t j) { return p[i * y + j]; }
+  bool operator==(const array2D& o) const {
+    return x == o.x && y == o.y &&
+           memcmp(p, o.p, 1ull * x * y * sizeof(float)) == 0;
+  }
+  array2D() : x(0), y(0), p(nullptr) {}
+  ~array2D() { free(p); }
+};
+
+// If you want to add a new type for struct_pack which is not in the struct_pack
+// type system. You need add those functions:
+
+// 1. sp_get_needed_size: calculate length of serialization
+std::size_t sp_get_needed_size(const array2D& ar) {
+  return 2 * struct_pack::get_write_size(ar.x) +
+         struct_pack::get_write_size(ar.p, 1ull * ar.x * ar.y);
+}
+// 2. sp_serialize_to: serilize object to writer
+template </*struct_pack::writer_t*/ typename Writer>
+void sp_serialize_to(Writer& writer, const array2D& ar) {
+  struct_pack::write(writer, ar.x);
+  struct_pack::write(writer, ar.y);
+  struct_pack::write(writer, ar.p, 1ull * ar.x * ar.y);
+}
+// 3. sp_deserialize_to: deserilize object from reader
+template </*struct_pack::reader_t*/ typename Reader>
+struct_pack::errc sp_deserialize_to(Reader& reader, array2D& ar) {
+  if (auto ec = struct_pack::read(reader, ar.x); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  if (auto ec = struct_pack::read(reader, ar.y); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  auto length = 1ull * ar.x * ar.y * sizeof(float);
+  if constexpr (struct_pack::checkable_reader_t<Reader>) {
+    if (!reader.check(length)) {  // some input(such as memory) allow us check
+                                  // length before read data.
+      return struct_pack::errc::no_buffer_space;
+    }
+  }
+  ar.p = (float*)malloc(length);
+  auto ec = struct_pack::read(reader, ar.p, 1ull * ar.x * ar.y);
+  if (ec != struct_pack::errc{}) {
+    free(ar.p);
+  }
+  return ec;
+}
+
+// 4. The default name for type checking is it's literal type name. You can also
+// config it by:
+
+// constexpr std::string_view sp_set_type_name(test*) { return "myarray2D"; }
+
+// 5. If you want to use struct_pack::get_field/struct_pack::get_field_to, you
+// need also define this function to skip deserialization of your type:
+
+// template <typename Reader>
+// struct_pack::errc sp_deserialize_to_with_skip(Reader& reader, array2D& ar);
+}  // namespace my_name_space
+
+void user_defined_serialization() {
+  std::vector<my_name_space::array2D> ar;
+  ar.emplace_back(11, 22);
+  ar.emplace_back(114, 514);
+  ar[0](1, 6) = 3.14;
+  ar[1](87, 111) = 2.71;
+  auto buffer = struct_pack::serialize(ar);
+  auto result = struct_pack::deserialize<decltype(ar)>(buffer);
+  assert(result.has_value());
+  assert(ar == result);
+}
\ No newline at end of file
diff --git a/src/struct_pack/tests/test_user_defined_type.cpp b/src/struct_pack/tests/test_user_defined_type.cpp
new file mode 100644
index 000000000..51e1effcb
--- /dev/null
+++ b/src/struct_pack/tests/test_user_defined_type.cpp
@@ -0,0 +1,180 @@
+#include <cstdlib>
+#include <vector>
+
+#include "doctest.h"
+#include "ylt/struct_pack.hpp"
+#include "ylt/struct_pack/error_code.hpp"
+#include "ylt/struct_pack/type_id.hpp"
+namespace my_name_space {
+
+struct array2D {
+  unsigned int x;
+  unsigned int y;
+  float* p;
+  array2D(unsigned int x, unsigned int y) : x(x), y(y) {
+    p = (float*)calloc(1ull * x * y, sizeof(float));
+  }
+  array2D(const array2D&) = delete;
+  array2D(array2D&& o) : x(o.x), y(o.y), p(o.p) { o.p = nullptr; };
+  array2D& operator=(const array2D&) = delete;
+  array2D& operator=(array2D&& o) {
+    x = o.x;
+    y = o.y;
+    p = o.p;
+    o.p = nullptr;
+    return *this;
+  }
+  float& operator()(std::size_t i, std::size_t j) { return p[i * y + j]; }
+  bool operator==(const array2D& o) const {
+    return x == o.x && y == o.y &&
+           memcmp(p, o.p, 1ull * x * y * sizeof(float)) == 0;
+  }
+  array2D() : x(0), y(0), p(nullptr) {}
+  ~array2D() { free(p); }
+};
+
+std::size_t sp_get_needed_size(const array2D& ar) {
+  return 2 * struct_pack::get_write_size(ar.x) +
+         struct_pack::get_write_size(ar.p, 1ull * ar.x * ar.y);
+}
+template <typename Writer>
+void sp_serialize_to(Writer& writer, const array2D& ar) {
+  struct_pack::write(writer, ar.x);
+  struct_pack::write(writer, ar.y);
+  struct_pack::write(writer, ar.p, 1ull * ar.x * ar.y);
+}
+
+template <typename Reader>
+struct_pack::errc sp_deserialize_to(Reader& reader, array2D& ar) {
+  if (auto ec = struct_pack::read(reader, ar.x); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  if (auto ec = struct_pack::read(reader, ar.y); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  auto length = 1ull * ar.x * ar.y * sizeof(float);
+  if constexpr (struct_pack::checkable_reader_t<Reader>) {
+    if (!reader.check(length)) {  // some input(such as memory) allow us check
+                                  // length before read data.
+      return struct_pack::errc::no_buffer_space;
+    }
+  }
+  ar.p = (float*)malloc(length);
+  auto ec = struct_pack::read(reader, ar.p, 1ull * ar.x * ar.y);
+  if (ec != struct_pack::errc{}) {
+    free(ar.p);
+  }
+  return ec;
+}
+
+template <typename Reader>
+struct_pack::errc sp_deserialize_to_with_skip(Reader& reader, array2D& ar) {
+  if (auto ec = struct_pack::read(reader, ar.x); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  if (auto ec = struct_pack::read(reader, ar.y); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  auto length = 1ull * ar.x * ar.y * sizeof(float);
+  if (!reader.ignore(length)) {
+    return struct_pack::errc::no_buffer_space;
+  }
+  return {};
+}
+
+}  // namespace my_name_space
+
+TEST_CASE("test user-defined_type") {
+  my_name_space::array2D ar(114, 514);
+  ar(1, 6) = 3.14;
+  ar(87, 111) = 2.71;
+  auto buffer = struct_pack::serialize(ar);
+  auto result = struct_pack::deserialize<my_name_space::array2D>(buffer);
+  CHECK(result.has_value());
+  auto& ar2 = result.value();
+  CHECK(ar == result.value());
+}
+
+TEST_CASE("test user-defined_type nested") {
+  std::vector<my_name_space::array2D> ar;
+  ar.emplace_back(11, 22);
+  ar.emplace_back(114, 514);
+  ar[0](1, 6) = 3.14;
+  ar[1](87, 111) = 2.71;
+  auto buffer = struct_pack::serialize(ar);
+  auto result = struct_pack::deserialize<decltype(ar)>(buffer);
+  CHECK(result.has_value());
+  CHECK(ar == result);
+}
+
+TEST_CASE("test user-defined_type get_field") {
+  std::pair<my_name_space::array2D, int> o;
+  o.first = {114, 514};
+  o.first(1, 6) = 3.14;
+  o.first(87, 111) = 2.71;
+  o.second = 114514;
+  auto buffer = struct_pack::serialize(o);
+  auto result = struct_pack::get_field<decltype(o), 1>(buffer);
+  CHECK(result.has_value());
+  auto& i = result.value();
+  CHECK(o.second == i);
+}
+
+TEST_CASE("test auto type name") {
+  {
+    auto name = struct_pack::get_type_literal<my_name_space::array2D>();
+    std::string_view sv{name.data(), name.size()};
+    CHECK(sv == (char)struct_pack::detail::type_id::user_defined_type +
+                    std::string{"my_name_space::array2D"} +
+                    (char)struct_pack::detail::type_id::type_end_flag);
+  }
+  {
+    auto name =
+        struct_pack::get_type_literal<std::vector<my_name_space::array2D>>();
+    std::string_view sv{name.data(), name.size()};
+    CHECK(sv == std::string{(char)struct_pack::detail::type_id::container_t} +
+                    (char)struct_pack::detail::type_id::user_defined_type +
+                    std::string{"my_name_space::array2D"} +
+                    (char)struct_pack::detail::type_id::type_end_flag);
+  }
+}
+
+namespace my_name_space {
+
+struct test {
+  unsigned int x;
+};
+
+std::size_t sp_get_needed_size(const test& t) {
+  return struct_pack::get_write_size(t.x);
+}
+template <typename Writer>
+void sp_serialize_to(Writer& writer, const test& t) {
+  struct_pack::write(writer, t.x);
+}
+
+template <typename Reader>
+struct_pack::errc sp_deserialize_to(Reader& reader, test& ar) {
+  return struct_pack::read(reader, ar.x);
+}
+constexpr std::string_view sp_set_type_name(test*) { return "myint"; }
+}  // namespace my_name_space
+
+TEST_CASE("test user-defined type name") {
+  {
+    auto name = struct_pack::get_type_literal<my_name_space::test>();
+    std::string_view sv{name.data(), name.size()};
+    CHECK(sv == (char)struct_pack::detail::type_id::user_defined_type +
+                    std::string{"myint"} +
+                    (char)struct_pack::detail::type_id::type_end_flag);
+  }
+  {
+    auto name =
+        struct_pack::get_type_literal<std::vector<my_name_space::test>>();
+    std::string_view sv{name.data(), name.size()};
+    CHECK(sv == std::string{(char)struct_pack::detail::type_id::container_t} +
+                    (char)struct_pack::detail::type_id::user_defined_type +
+                    std::string{"myint"} +
+                    (char)struct_pack::detail::type_id::type_end_flag);
+  }
+}
diff --git a/website/docs/en/struct_pack/struct_pack_intro.md b/website/docs/en/struct_pack/struct_pack_intro.md
index 47935e4de..27e22f5a0 100644
--- a/website/docs/en/struct_pack/struct_pack_intro.md
+++ b/website/docs/en/struct_pack/struct_pack_intro.md
@@ -252,7 +252,9 @@ The member function registed must return a reference, and this function must hav
 
 ### custom type
 
-In addition, struct_pack supports serialization and deserialization on custom containers, as below:
+#### The type cannot be abstracted to a type already in the type system
+
+For example, let's say we need to serialise a map type from a third-party library (absl, boost...): we just need to make sure that it conforms to the constraints of the struct_pack type system for maps:
 
 ```cpp
 // We should not inherit from stl container, this case just for testing.
@@ -272,6 +274,105 @@ auto buffer2 = serialize(map2);
 
 For more detail, See [struct_pack type system](https://alibaba.github.io/yalantinglibs/en/struct_pack/struct_pack_type_system.html)
 
+#### The type cannot be abstracted to a type already in the type system
+
+At this time, we also support custom serialisation, the user only needs to customise the following three functions:
+
+1. sp_get_needed_size
+2. sp_serialize_to
+3. sp_deserialize_to
+
+For example, the following is an example of support for serialisation/deserialisation of a custom 2D array type.
+
+```cpp
+struct array2D {
+  unsigned int x;
+  unsigned int y;
+  float* p;
+  array2D(unsigned int x, unsigned int y) : x(x), y(y) {
+    p = (float*)calloc(1ull * x * y, sizeof(float));
+  }
+  array2D(const array2D&) = delete;
+  array2D(array2D&& o) : x(o.x), y(o.y), p(o.p) { o.p = nullptr; };
+  array2D& operator=(const array2D&) = delete;
+  array2D& operator=(array2D&& o) {
+    x = o.x;
+    y = o.y;
+    p = o.p;
+    o.p = nullptr;
+    return *this;
+  }
+  float& operator()(std::size_t i, std::size_t j) { return p[i * y + j]; }
+  bool operator==(const array2D& o) const {
+    return x == o.x && y == o.y &&
+           memcmp(p, o.p, 1ull * x * y * sizeof(float)) == 0;
+  }
+  array2D() : x(0), y(0), p(nullptr) {}
+  ~array2D() { free(p); }
+};
+
+// You need add those functions:
+
+// 1. sp_get_needed_size: calculate length of serialization
+std::size_t sp_get_needed_size(const array2D& ar) {
+  return 2 * struct_pack::get_write_size(ar.x) +
+         struct_pack::get_write_size(ar.p, 1ull * ar.x * ar.y);
+}
+// 2. sp_serialize_to: serilize object to writer
+template </*struct_pack::writer_t*/ typename Writer>
+void sp_serialize_to(Writer& writer, const array2D& ar) {
+  struct_pack::write(writer, ar.x);
+  struct_pack::write(writer, ar.y);
+  struct_pack::write(writer, ar.p, 1ull * ar.x * ar.y);
+}
+// 3. sp_deserialize_to: deserilize object from reader
+template </*struct_pack::reader_t*/ typename Reader>
+struct_pack::errc sp_deserialize_to(Reader& reader, array2D& ar) {
+  if (auto ec = struct_pack::read(reader, ar.x); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  if (auto ec = struct_pack::read(reader, ar.y); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  auto length = 1ull * ar.x * ar.y * sizeof(float);
+  if constexpr (struct_pack::checkable_reader_t<Reader>) {
+    if (!reader.check(length)) {  // some input(such as memory) allow us check
+                                  // length before read data.
+      return struct_pack::errc::no_buffer_space;
+    }
+  }
+  ar.p = (float*)malloc(length);
+  auto ec = struct_pack::read(reader, ar.p, 1ull * ar.x * ar.y);
+  if (ec != struct_pack::errc{}) {
+    free(ar.p);
+  }
+  return ec;
+
+// 4. The default name for type checking is it's literal type name. You can also
+// config it by:
+
+// constexpr std::string_view sp_set_type_name(test*) { return "myarray2D"; }
+
+// 5. If you want to use struct_pack::get_field/struct_pack::get_field_to, you
+// need also define this function to skip deserialization of your type:
+
+// template <typename Reader>
+// struct_pack::errc sp_deserialize_to_with_skip(Reader& reader, array2D& ar);
+
+}
+
+void user_defined_serialization() {
+  std::vector<my_name_space::array2D> ar;
+  ar.emplace_back(11, 22);
+  ar.emplace_back(114, 514);
+  ar[0](1, 6) = 3.14;
+  ar[1](87, 111) = 2.71;
+  auto buffer = struct_pack::serialize(ar);
+  auto result = struct_pack::deserialize<decltype(ar)>(buffer);
+  assert(result.has_value());
+  assert(ar == result);
+}
+
 ### custom output stream
 
 Except std::ostream/std::sstream struct_pack also support serialize to custom output stream.
diff --git a/website/docs/zh/struct_pack/struct_pack_intro.md b/website/docs/zh/struct_pack/struct_pack_intro.md
index c5ba233ff..3a82ef7d3 100644
--- a/website/docs/zh/struct_pack/struct_pack_intro.md
+++ b/website/docs/zh/struct_pack/struct_pack_intro.md
@@ -259,6 +259,10 @@ STRUCT_PACK_REFL(person, age(), name());
 
 struct_pack支持序列化自定义类型。
 
+#### 该类型可以被抽象为类型系统中已有的类型
+
+例如，假如我们需要序列化一个第三方库的map类型(absl , boost...)：我们只需要保证其符合struct_pack类型系统中对于map的约束即可。
+
 ```cpp
 // We should not inherit from stl container, this case just for testing.
 template <typename Key, typename Value>
@@ -279,6 +283,104 @@ auto buffer2 = serialize(map2);
 
 [struct_pack的类型系统](https://alibaba.github.io/yalantinglibs/zh/struct_pack/struct_pack_type_system.html)
 
+#### 该类型不能被抽象为类型系统中已有的类型
+
+此时，我们也支持自定义的序列化，用户只需要自定义以下三个函数即可：
+
+1. sp_get_needed_size
+2. sp_serialize_to
+3. sp_deserialize_to
+
+例如，下面是一个支持自定义二维数组类型的序列化/反序列化的例子。
+
+```cpp
+struct array2D {
+  unsigned int x;
+  unsigned int y;
+  float* p;
+  array2D(unsigned int x, unsigned int y) : x(x), y(y) {
+    p = (float*)calloc(1ull * x * y, sizeof(float));
+  }
+  array2D(const array2D&) = delete;
+  array2D(array2D&& o) : x(o.x), y(o.y), p(o.p) { o.p = nullptr; };
+  array2D& operator=(const array2D&) = delete;
+  array2D& operator=(array2D&& o) {
+    x = o.x;
+    y = o.y;
+    p = o.p;
+    o.p = nullptr;
+    return *this;
+  }
+  float& operator()(std::size_t i, std::size_t j) { return p[i * y + j]; }
+  bool operator==(const array2D& o) const {
+    return x == o.x && y == o.y &&
+           memcmp(p, o.p, 1ull * x * y * sizeof(float)) == 0;
+  }
+  array2D() : x(0), y(0), p(nullptr) {}
+  ~array2D() { free(p); }
+};
+
+// 你需要自定义以下函数
+
+// 1. sp_get_needed_size: 预计算序列化长度
+std::size_t sp_get_needed_size(const array2D& ar) {
+  return 2 * struct_pack::get_write_size(ar.x) +
+         struct_pack::get_write_size(ar.p, 1ull * ar.x * ar.y);
+}
+// 2. sp_serialize_to: 将对象序列化到writer
+template </*struct_pack::writer_t*/ typename Writer>
+void sp_serialize_to(Writer& writer, const array2D& ar) {
+  struct_pack::write(writer, ar.x);
+  struct_pack::write(writer, ar.y);
+  struct_pack::write(writer, ar.p, 1ull * ar.x * ar.y);
+}
+// 3. sp_deserialize_to: 从reader反序列化对象
+template </*struct_pack::reader_t*/ typename Reader>
+struct_pack::errc sp_deserialize_to(Reader& reader, array2D& ar) {
+  if (auto ec = struct_pack::read(reader, ar.x); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  if (auto ec = struct_pack::read(reader, ar.y); ec != struct_pack::errc{}) {
+    return ec;
+  }
+  auto length = 1ull * ar.x * ar.y * sizeof(float);
+  if constexpr (struct_pack::checkable_reader_t<Reader>) {
+    if (!reader.check(length)) {  
+      //checkable_reader_t允许我们在读取数据前先检查是否超出长度限制
+      return struct_pack::errc::no_buffer_space;
+    }
+  }
+  ar.p = (float*)malloc(length);
+  auto ec = struct_pack::read(reader, ar.p, 1ull * ar.x * ar.y);
+  if (ec != struct_pack::errc{}) {
+    free(ar.p);
+  }
+  return ec;
+
+// 4. 默认用于类型检查的字符串就是该类型的名字. 你也可以通过下面的函数来配置
+
+// constexpr std::string_view sp_set_type_name(test*) { return "myarray2D"; }
+
+// 5. 如果你想使用 struct_pack::get_field/struct_pack::get_field_to, 还需要定义下面的函数以跳过自定义类型的反序列化。
+
+// template <typename Reader>
+// struct_pack::errc sp_deserialize_to_with_skip(Reader& reader, array2D& ar);
+
+}
+
+void user_defined_serialization() {
+  std::vector<my_name_space::array2D> ar;
+  ar.emplace_back(11, 22);
+  ar.emplace_back(114, 514);
+  ar[0](1, 6) = 3.14;
+  ar[1](87, 111) = 2.71;
+  auto buffer = struct_pack::serialize(ar);
+  auto result = struct_pack::deserialize<decltype(ar)>(buffer);
+  assert(result.has_value());
+  assert(ar == result);
+}
+```
+
 ### 序列化到自定义的输出流
 
 该流需要满足以下约束条件：