From 45262dc9375d8e7e9d9034ee9937b3783285af20 Mon Sep 17 00:00:00 2001
From: StarQTius <dussautoirp@gmail.com>
Date: Sun, 15 Sep 2024 04:33:06 +0200
Subject: [PATCH] Add tuple classes

---
 example/dynamixel-protocol-2.0.cpp       |  95 ++-
 include/upd/basic_ibytestream.hpp        |   3 +-
 include/upd/description.hpp              | 260 ++++---
 include/upd/detail/is_instance_of.hpp    |   6 +
 include/upd/detail/variadic/diff.hpp     |  23 +-
 include/upd/detail/variadic/equals.hpp   |  10 +-
 include/upd/detail/variadic/filter.hpp   |  33 +
 include/upd/detail/variadic/find.hpp     |   3 +-
 include/upd/detail/variadic/leaf.hpp     |   2 +-
 include/upd/detail/variadic/map.hpp      |   4 +-
 include/upd/detail/variadic/to_array.hpp |   2 +-
 include/upd/integer.hpp                  | 109 ++-
 include/upd/named_tuple.hpp              |  12 +-
 include/upd/named_value.hpp              |   7 +-
 include/upd/tuple.hpp                    | 895 +++++++++++++----------
 test/CMakeLists.txt                      |   2 +-
 test/basic_ibytestream.cpp               |   5 +-
 test/integer.cpp                         |  11 +-
 18 files changed, 856 insertions(+), 626 deletions(-)
 create mode 100644 include/upd/detail/variadic/filter.hpp

diff --git a/example/dynamixel-protocol-2.0.cpp b/example/dynamixel-protocol-2.0.cpp
index 1318612..a011ac0 100644
--- a/example/dynamixel-protocol-2.0.cpp
+++ b/example/dynamixel-protocol-2.0.cpp
@@ -1,13 +1,13 @@
-#include <upd/integer.hpp>
-#include <upd/description.hpp>
-#include <iostream>
 #include <cinttypes>
+#include <climits>
+#include <iostream>
+
+#include <upd/description.hpp>
+#include <upd/integer.hpp>
 
 namespace std {
 
-ostream &operator<<(ostream &os, byte b) {
-  return os << static_cast<int>(b);
-}
+ostream &operator<<(ostream &os, byte b) { return os << static_cast<int>(b); }
 
 } // namespace std
 
@@ -16,12 +16,9 @@ constexpr auto description = [] {
   using namespace upd::literals;
   using namespace upd::descriptor;
 
-  return 
-    constant<"header"_h>(0xfdffff, width<32>) |
-    field<"id"_h > (unsigned_int, width<8>) |
-    field<"length"_h>(unsigned_int, width<16>) |
-    field<"instruction"_h>(unsigned_int, width<8>) |
-    field<"checksum"_h>(unsigned_int, width<16>);
+  return constant<"header"_h>(0xfdffff, width<32>) | field<"id"_h>(unsigned_int, width<8>) |
+         field<"length"_h>(unsigned_int, width<16>) | field<"instruction"_h>(unsigned_int, width<8>) |
+         field<"checksum"_h>(unsigned_int, width<16>);
 }();
 
 constexpr auto answer_description = [] {
@@ -29,15 +26,10 @@ constexpr auto answer_description = [] {
   using namespace upd::literals;
   using namespace upd::descriptor;
 
-  return 
-    constant<"header"_h>(0xfdffff, width<32>) |
-    field<"id"_h > (unsigned_int, width<8>) |
-    field<"length"_h>(unsigned_int, width<16>) |
-    field<"instruction"_h>(unsigned_int, width<8>) |
-    field<"error"_h>(unsigned_int, width<8>) |
-    field<"model_number"_h>(unsigned_int, width<16>) |
-    field<"firmware_version"_h>(unsigned_int, width<8>) |
-    field<"checksum"_h>(unsigned_int, width<16>);
+  return constant<"header"_h>(0xfdffff, width<32>) | field<"id"_h>(unsigned_int, width<8>) |
+         field<"length"_h>(unsigned_int, width<16>) | field<"instruction"_h>(unsigned_int, width<8>) |
+         field<"error"_h>(unsigned_int, width<8>) | field<"model_number"_h>(unsigned_int, width<16>) |
+         field<"firmware_version"_h>(unsigned_int, width<8>) | field<"checksum"_h>(unsigned_int, width<16>);
 }();
 
 struct serializer {
@@ -56,7 +48,7 @@ struct serializer {
   void serialize_signed(XInteger value, OutputIt output) {
     static_assert(upd::is_extended_integer_v<XInteger>, "`value` must be an instance of `extended_integer`");
     static_assert(upd::is_signed_v<XInteger>, "`value` must be signed");
- 
+
     auto sign = value.signbit();
     auto abs = value.abs().enlarge(upd::width<1>);
 
@@ -94,10 +86,10 @@ struct serializer {
     auto last_written = std::copy_n(input, size, byteseq.begin());
 
     UPD_ASSERT(last_written == byteseq.end());
-    
+
     auto raw = upd::recompose_into_xuint(byteseq);
     auto sign = (raw & upd::nth_bit<Bitsize> != 0);
-    auto abs = (raw & upd::nth_bit<Bitsize>) ? ~raw + 1: raw;
+    auto abs = (raw & upd::nth_bit<Bitsize>) ? ~raw + 1 : raw;
 
     return sign ? -abs : abs;
   }
@@ -106,12 +98,11 @@ struct serializer {
 template<std::size_t N>
 struct bytearray : std::array<std::byte, N> {
   template<typename... Bytes>
-  constexpr explicit bytearray(Bytes... bytes) noexcept: std::array<std::byte, N>{static_cast<std::byte>(bytes)...} {
-  }
+  constexpr explicit bytearray(Bytes... bytes) noexcept : std::array<std::byte, N>{static_cast<std::byte>(bytes)...} {}
 };
 
 template<typename... Bytes>
-explicit bytearray(Bytes...) noexcept -> bytearray<sizeof...(Bytes)>;
+explicit bytearray(Bytes...) noexcept->bytearray<sizeof...(Bytes)>;
 
 int main() {
   using namespace upd::literals;
@@ -121,50 +112,46 @@ int main() {
   std::cout << std::hex;
 
   auto ping_ex1 = description.instantiate(
-    upd::kw<"header"_h> = 0xfdffff,
-    upd::kw<"id"_h> = 1,
-    upd::kw<"length"_h> = 3,
-    upd::kw<"instruction"_h> = 1,
-    upd::kw<"checksum"_h> = 0x4e19);
+      upd::kw<"id"_h> = 1, upd::kw<"length"_h> = 3, upd::kw<"instruction"_h> = 1, upd::kw<"checksum"_h> = 0x4e19);
   if (!ping_ex1) {
-    return (int) ping_ex1.error();
+    return (int)ping_ex1.error();
   }
 
   std::printf("Ping: example 1\n");
   ping_ex1->serialize(ser, oit);
   std::printf("\n\n");
 
-  auto answer1_seq = bytearray {0xff, 0xff, 0xfd, 0x00, 0x01, 0x07, 0x00, 0x55, 0x00, 0x06, 0x04, 0x26, 0x65, 0x5d};
+  auto answer1_seq = bytearray{0xff, 0xff, 0xfd, 0x00, 0x01, 0x07, 0x00, 0x55, 0x00, 0x06, 0x04, 0x26, 0x65, 0x5d};
   auto answer1 = answer_description.decode(answer1_seq.begin(), ser);
   if (!answer1) {
-    return (int) answer1.error();
+    return (int)answer1.error();
   }
 
   std::printf("Answer 1: \n");
-  std::printf("- header: %" PRIx32 "\n", (std::uint32_t) (*answer1)[upd::kw<"header"_h>]);
-  std::printf("- id: %" PRIx8 "\n", (std::uint8_t) (*answer1)[upd::kw<"id"_h>]);
-  std::printf("- length: %" PRIx16 "\n", (std::uint16_t) (*answer1)[upd::kw<"length"_h>]);
-  std::printf("- instruction: %" PRIx8 "\n", (std::uint8_t) (*answer1)[upd::kw<"instruction"_h>]);
-  std::printf("- error: %" PRIx8 "\n", (std::uint8_t) (*answer1)[upd::kw<"error"_h>]);
-  std::printf("- model number: %" PRIx16 "\n", (std::uint16_t) (*answer1)[upd::kw<"model_number"_h>]);
-  std::printf("- firmware version: %" PRIx8 "\n", (std::uint8_t) (*answer1)[upd::kw<"firmware_version"_h>]);
-  std::printf("- checksum: %" PRIx16 "\n", (std::uint16_t) (*answer1)[upd::kw<"checksum"_h>]);
+  std::printf("- header: %" PRIx32 "\n", (std::uint32_t)(*answer1)[upd::kw<"header"_h>]);
+  std::printf("- id: %" PRIx8 "\n", (std::uint8_t)(*answer1)[upd::kw<"id"_h>]);
+  std::printf("- length: %" PRIx16 "\n", (std::uint16_t)(*answer1)[upd::kw<"length"_h>]);
+  std::printf("- instruction: %" PRIx8 "\n", (std::uint8_t)(*answer1)[upd::kw<"instruction"_h>]);
+  std::printf("- error: %" PRIx8 "\n", (std::uint8_t)(*answer1)[upd::kw<"error"_h>]);
+  std::printf("- model number: %" PRIx16 "\n", (std::uint16_t)(*answer1)[upd::kw<"model_number"_h>]);
+  std::printf("- firmware version: %" PRIx8 "\n", (std::uint8_t)(*answer1)[upd::kw<"firmware_version"_h>]);
+  std::printf("- checksum: %" PRIx16 "\n", (std::uint16_t)(*answer1)[upd::kw<"checksum"_h>]);
   std::printf("\n\n");
 
-  auto answer2_seq = bytearray {0xff, 0xff, 0xfd, 0x00, 0x02, 0x07, 0x00, 0x55, 0x00, 0x06, 0x04, 0x26, 0x6f, 0x6d};
+  auto answer2_seq = bytearray{0xff, 0xff, 0xfd, 0x00, 0x02, 0x07, 0x00, 0x55, 0x00, 0x06, 0x04, 0x26, 0x6f, 0x6d};
   auto answer2 = answer_description.decode(answer2_seq.begin(), ser);
   if (!answer2) {
-    return (int) answer2.error();
+    return (int)answer2.error();
   }
 
   std::printf("Answer 2: \n");
-  std::printf("- header: %" PRIx32 "\n", (std::uint32_t) (*answer2)[upd::kw<"header"_h>]);
-  std::printf("- id: %" PRIx8 "\n", (std::uint8_t) (*answer2)[upd::kw<"id"_h>]);
-  std::printf("- length: %" PRIx16 "\n", (std::uint16_t) (*answer2)[upd::kw<"length"_h>]);
-  std::printf("- instruction: %" PRIx8 "\n", (std::uint8_t) (*answer2)[upd::kw<"instruction"_h>]);
-  std::printf("- error: %" PRIx8 "\n", (std::uint8_t) (*answer2)[upd::kw<"error"_h>]);
-  std::printf("- model number: %" PRIx16 "\n", (std::uint16_t) (*answer2)[upd::kw<"model_number"_h>]);
-  std::printf("- firmware version: %" PRIx8 "\n", (std::uint8_t) (*answer2)[upd::kw<"firmware_version"_h>]);
-  std::printf("- checksum: %" PRIx16 "\n", (std::uint16_t) (*answer2)[upd::kw<"checksum"_h>]);
+  std::printf("- header: %" PRIx32 "\n", (std::uint32_t)(*answer2)[upd::kw<"header"_h>]);
+  std::printf("- id: %" PRIx8 "\n", (std::uint8_t)(*answer2)[upd::kw<"id"_h>]);
+  std::printf("- length: %" PRIx16 "\n", (std::uint16_t)(*answer2)[upd::kw<"length"_h>]);
+  std::printf("- instruction: %" PRIx8 "\n", (std::uint8_t)(*answer2)[upd::kw<"instruction"_h>]);
+  std::printf("- error: %" PRIx8 "\n", (std::uint8_t)(*answer2)[upd::kw<"error"_h>]);
+  std::printf("- model number: %" PRIx16 "\n", (std::uint16_t)(*answer2)[upd::kw<"model_number"_h>]);
+  std::printf("- firmware version: %" PRIx8 "\n", (std::uint8_t)(*answer2)[upd::kw<"firmware_version"_h>]);
+  std::printf("- checksum: %" PRIx16 "\n", (std::uint16_t)(*answer2)[upd::kw<"checksum"_h>]);
   std::printf("\n\n");
-}
\ No newline at end of file
+}
diff --git a/include/upd/basic_ibytestream.hpp b/include/upd/basic_ibytestream.hpp
index 2397afa..355acb1 100644
--- a/include/upd/basic_ibytestream.hpp
+++ b/include/upd/basic_ibytestream.hpp
@@ -34,7 +34,8 @@ class basic_ibytestream {
     } else if constexpr (std::is_enum_v<byte_t>) {
       return std::numeric_limits<std::underlying_type_t<byte_t>>::digits;
     } else {
-      static_assert(UPD_ALWAYS_FALSE, "Producers can only produce `extended_integer` values, integral values or enumerators");
+      static_assert(UPD_ALWAYS_FALSE,
+                    "Producers can only produce `extended_integer` values, integral values or enumerators");
     }
   }();
 
diff --git a/include/upd/description.hpp b/include/upd/description.hpp
index ee8e563..7177d2e 100644
--- a/include/upd/description.hpp
+++ b/include/upd/description.hpp
@@ -5,21 +5,33 @@
 #include <functional>
 #include <limits>
 #include <tuple>
-#include <variant>
 #include <type_traits>
+#include <variant>
 
-#include "detail/has_value_member.hpp"
 #include "detail/always_false.hpp"
+#include "detail/has_value_member.hpp"
 #include "detail/integral_constant.hpp"
+#include "detail/variadic/diff.hpp"
+#include "detail/variadic/equals.hpp"
+#include "detail/variadic/filter.hpp"
 #include "detail/variadic/map.hpp"
 #include "detail/variadic/product.hpp"
-#include "detail/variadic/diff.hpp"
 #include "detail/variadic/to_array.hpp"
-#include "detail/variadic/equals.hpp"
-#include "upd.hpp"
-#include "token.hpp"
-#include "named_value.hpp"
 #include "integer.hpp"
+#include "named_value.hpp"
+#include "token.hpp"
+#include "tuple.hpp"
+#include "upd.hpp"
+
+namespace upd::descriptor {
+
+template<auto, bool, std::size_t>
+struct field_t;
+
+template<auto, std::size_t>
+struct constant_t;
+
+} // namespace upd::descriptor
 
 namespace upd::detail {
 
@@ -33,24 +45,17 @@ class iterator_reference {
   using pointer = typename std::iterator_traits<Iter>::pointer;
   using reference = typename std::iterator_traits<Iter>::reference;
 
-  constexpr explicit iterator_reference(iterator_type &iter):
-    m_cache{*iter},
-    m_iter{iter}
-  {
-    ++iter;
-  }
+  constexpr explicit iterator_reference(iterator_type &iter) : m_cache{*iter}, m_iter{iter} { ++iter; }
 
-  [[nodiscard]] constexpr auto operator*() const -> value_type {
-    return m_cache;
-  }
+  [[nodiscard]] constexpr auto operator*() const -> value_type { return m_cache; }
 
-  [[nodiscard]] constexpr auto operator++() -> iterator_reference& {
+  [[nodiscard]] constexpr auto operator++() -> iterator_reference & {
     m_cache = *m_iter;
     ++m_iter.get();
     return *this;
   }
 
-  [[nodiscard]] constexpr auto operator++() const -> const iterator_reference& {
+  [[nodiscard]] constexpr auto operator++() const -> const iterator_reference & {
     m_cache = *m_iter;
     ++m_iter.get();
     return *this;
@@ -59,7 +64,6 @@ class iterator_reference {
 private:
   std::reference_wrapper<iterator_type> m_iter;
   value_type m_cache;
-
 };
 
 } // namespace upd::detail
@@ -73,13 +77,9 @@ enum class error {
 template<typename E>
 class unexpected {
 public:
-  constexpr explicit unexpected(E e) noexcept:
-    m_error{std::move(e)}
-  {}
-  
-  [[nodiscard]] constexpr auto error() noexcept -> E {
-    return m_error;
-  }
+  constexpr explicit unexpected(E e) noexcept : m_error{std::move(e)} {}
+
+  [[nodiscard]] constexpr auto error() noexcept -> E { return m_error; }
 
 private:
   E m_error;
@@ -88,95 +88,72 @@ class unexpected {
 template<typename T, typename E = error>
 class expected {
 public:
-  constexpr explicit expected(T x) noexcept:
-    m_value_or_error{std::in_place_index<0>, std::move(x)}
-  {}
-  
-  constexpr expected(unexpected<E> e) noexcept:
-    m_value_or_error{std::in_place_index<1>, e.error()}
-  {}
-
-  [[nodiscard]] constexpr operator bool() const noexcept {
-    return value_if() != nullptr;
-  }
+  constexpr explicit expected(T x) noexcept : m_value_or_error{std::in_place_index<0>, std::move(x)} {}
 
-  [[nodiscard]] constexpr auto operator*() noexcept -> T& {
-    return value();
-  }
+  constexpr expected(unexpected<E> e) noexcept : m_value_or_error{std::in_place_index<1>, e.error()} {}
 
-  [[nodiscard]] constexpr auto operator*() const noexcept -> const T& {
-    return value();
-  }
+  [[nodiscard]] constexpr operator bool() const noexcept { return value_if() != nullptr; }
 
-  [[nodiscard]] constexpr auto operator->() noexcept -> T* {
-    return &value();
-  }
+  [[nodiscard]] constexpr auto operator*() noexcept -> T & { return value(); }
 
-  [[nodiscard]] constexpr auto operator->() const noexcept -> const T* {
-    return &value();
-  }
+  [[nodiscard]] constexpr auto operator*() const noexcept -> const T & { return value(); }
+
+  [[nodiscard]] constexpr auto operator->() noexcept -> T * { return &value(); }
 
-  [[nodiscard]] constexpr auto value() & noexcept -> T& {
+  [[nodiscard]] constexpr auto operator->() const noexcept -> const T * { return &value(); }
+
+  [[nodiscard]] constexpr auto value() &noexcept -> T & {
     auto *v = value_if();
     UPD_ASSERT(v != nullptr);
-    
+
     return *v;
   }
 
-  [[nodiscard]] constexpr auto value() const & noexcept -> const T& {
+  [[nodiscard]] constexpr auto value() const &noexcept -> const T & {
     const auto *v = value_if();
     UPD_ASSERT(v != nullptr);
-    
+
     return *v;
   }
 
-  [[nodiscard]] constexpr auto value() && noexcept -> T&& {
+  [[nodiscard]] constexpr auto value() &&noexcept -> T && {
     auto *v = value_if();
     UPD_ASSERT(v != nullptr);
-    
+
     return std::move(*v);
   }
 
-  [[nodiscard]] constexpr auto error() & noexcept -> E& {
+  [[nodiscard]] constexpr auto error() &noexcept -> E & {
     auto *e = error_if();
     UPD_ASSERT(e != nullptr);
-    
+
     return *e;
   }
 
-  [[nodiscard]] constexpr auto error() const & noexcept -> const E& {
+  [[nodiscard]] constexpr auto error() const &noexcept -> const E & {
     const auto *e = error_if();
     UPD_ASSERT(e != nullptr);
-    
+
     return *e;
   }
 
-  [[nodiscard]] constexpr auto error() && noexcept -> E&& {
+  [[nodiscard]] constexpr auto error() &&noexcept -> E && {
     auto *e = error_if();
     UPD_ASSERT(e != nullptr);
-    
+
     return std::move(*e);
   }
 
-  [[nodiscard]] constexpr auto value_if() noexcept -> T* {
-    return std::get_if<0>(&m_value_or_error);
-  }
+  [[nodiscard]] constexpr auto value_if() noexcept -> T * { return std::get_if<0>(&m_value_or_error); }
 
-  [[nodiscard]] constexpr auto value_if() const noexcept -> const T* {
-    return std::get_if<0>(&m_value_or_error);
-  }
+  [[nodiscard]] constexpr auto value_if() const noexcept -> const T * { return std::get_if<0>(&m_value_or_error); }
 
-  [[nodiscard]] constexpr auto error_if() noexcept -> E* {
-    return std::get_if<1>(&m_value_or_error);
-  }
+  [[nodiscard]] constexpr auto error_if() noexcept -> E * { return std::get_if<1>(&m_value_or_error); }
 
-  [[nodiscard]] constexpr auto error_if() const noexcept -> const E* {
-    return std::get_if<1>(&m_value_or_error);
-  }
+  [[nodiscard]] constexpr auto error_if() const noexcept -> const E * { return std::get_if<1>(&m_value_or_error); }
 
 private:
   std::variant<T, E> m_value_or_error;
-
 };
 
 } // namespace upd
@@ -184,7 +161,10 @@ class expected {
 namespace upd::descriptor {
 
 template<auto, bool Is_Signed, std::size_t Width>
-constexpr auto field(signedness_t<Is_Signed>, width_t<Width>) noexcept;
+constexpr auto field(signedness_t<Is_Signed>, width_t<Width>) noexcept(release);
+
+template<auto, typename T, std::size_t Width>
+constexpr auto constant(T, width_t<Width>) noexcept(release);
 
 } // namespace upd::descriptor
 
@@ -192,7 +172,7 @@ namespace upd {
 
 template<typename Range>
 [[nodiscard]] constexpr auto all_of(const Range &range) noexcept -> bool {
-  for (const auto &e: range) {
+  for (const auto &e : range) {
     if (!e) {
       return false;
     }
@@ -201,88 +181,124 @@ template<typename Range>
   return true;
 }
 
+enum class field_tag {
+  pure_field,
+  constant,
+};
+
 template<typename... Ts>
 class description {
   template<typename... Ts_, typename... Us>
   friend constexpr auto operator|(description<Ts_...> lhs, description<Us...> rhs) noexcept;
 
   template<auto, bool Is_Signed, std::size_t Width>
-  friend constexpr auto descriptor::field(signedness_t<Is_Signed>, width_t<Width>) noexcept;
+  friend constexpr auto descriptor::field(signedness_t<Is_Signed>, width_t<Width>) noexcept(release);
 
-public:
-  constexpr static auto ids = [] { return std::tuple_cat(Ts::ids...); }();
-
-  [[nodiscard]] constexpr auto fields() const & -> std::tuple<Ts...> { return m_fields; }
-
-  [[nodiscard]] constexpr auto fields() && -> std::tuple<Ts...> { return std::move(m_fields); }
+  template<auto, typename T, std::size_t Width>
+  friend constexpr auto descriptor::constant(T, width_t<Width>) noexcept(release);
 
+public:
   template<typename... NamedValues>
   [[nodiscard]] constexpr auto instantiate(NamedValues... nvs) const noexcept {
-    using identifier_types = std::decay_t<decltype(ids)>;
-    using value_name_types = std::tuple<detail::integral_constant_t<nvs.identifier>...>;
+    static_assert((detail::is_instance_of_v<NamedValues, named_value> && ...),
+                  "`nvs` must be a pack of `named_value` instances");
+
+    auto named_args = (nvs, ...);
+    auto impl = [&](const auto &field) {
+      if constexpr (field.tag == field_tag::pure_field) {
+        constexpr auto width = field.width;
+        using representation = std::conditional_t<field.is_signed, xint<width>, xuint<width>>;
+        auto value = named_args[kw<field.identifier>];
+        return kw<field.identifier> = representation{value};
+      } else if constexpr (field.tag == field_tag::constant) {
+        return kw<field.identifier> = field.value;
+      } else {
+        static_assert(UPD_ALWAYS_FALSE, "`field` is not a field object");
+      }
+    };
 
-    static_assert((detail::is_instance_of_v<NamedValues, named_value> && ...), "`nvs` must be a pack of `named_value` instances");
-    static_assert(detail::variadic::equals_v<identifier_types, value_name_types>, "`nvs.identifier...` must match the content of `ids` in order");
+    auto make_named_tuple = [](auto &&...nvs) { return (nvs, ...); };
 
-    return expected{(std::move(nvs).map([](auto n){ return typename Ts::underlying{n}; }), ...)};
+    return expected{m_fields.transform(impl).apply(make_named_tuple)};
   }
 
   template<typename InputIt, typename Serializer>
-  [[nodiscard]] constexpr auto decode(InputIt src, Serializer &ser) const {
-    auto impl = [&](auto... identifiers) {
-      return ((kw<identifiers.value> = deserialize_into_xinteger<typename Ts::underlying>(detail::iterator_reference{src}, ser)), ...);
+  [[nodiscard]] constexpr auto decode(InputIt src, Serializer &ser) const noexcept(release) {
+    auto impl = [&](const auto &field) {
+      if constexpr (field.tag == field_tag::pure_field) {
+        constexpr auto width = field.width;
+        using representation = std::conditional_t<field.is_signed, xint<width>, xuint<width>>;
+        return kw<field.identifier> = deserialize_into_xinteger<representation>(detail::iterator_reference{src}, ser);
+      } else if constexpr (field.tag == field_tag::constant) {
+        return kw<field.identifier> = field.value;
+      } else {
+        static_assert(UPD_ALWAYS_FALSE, "`field` is not a field object");
+      }
     };
 
-    auto retval = std::apply(impl, ids);
+    auto make_named_tuple = [](auto &&...nvs) { return (nvs, ...); };
+
+    auto retval = m_fields.transform(impl).apply(make_named_tuple);
     return expected{std::move(retval)};
   }
 
 private:
-  explicit constexpr description(Ts... xs) : m_fields{UPD_FWD(xs)...} {}
+  explicit constexpr description(tuple<Ts...> fields) : m_fields{std::move(fields)} {}
 
-  std::tuple<Ts...> m_fields;
+  tuple<Ts...> m_fields;
 };
 
 template<typename... Ts, typename... Us>
 [[nodiscard]] constexpr inline auto operator|(description<Ts...> lhs, description<Us...> rhs) noexcept {
-  auto fields = std::tuple_cat(std::move(lhs.m_fields), std::move(rhs.m_fields));
-  auto get_ids = [](auto x) { return x.ids; };
-
-  using id_ts = detail::variadic::flatmapf_t<decltype(fields), decltype(get_ids)>;
-  using id_squared_ts = detail::variadic::product_t<id_ts, id_ts>;
-  using is_same_ts = detail::variadic::binmap_t<id_squared_ts, std::is_same>;
-  constexpr auto are_unique = detail::variadic::sum_v<is_same_ts> == std::tuple_size_v<id_ts>;
-
-  if constexpr (are_unique) {
-    auto make_description = [](auto... fields) { return description{std::move(fields)...}; };
-    return std::apply(make_description, std::move(fields));
-  } else {
-    static_assert(UPD_ALWAYS_FALSE, "Merging these descriptions would result in duplicate IDs");
-  }
+  auto fields = std::move(lhs.m_fields) + std::move(rhs.m_fields);
+  auto get_identifier = [](auto field_type) { return field_type->identifier; };
+
+  // For each identifier of the merged description, we count how often it
+  // appears. If the total is not equal to the number of fields, we know that
+  // there are duplicate identifiers.
+  auto self_comparison_count = fields.type_only()
+                                   .transform_const(get_identifier)
+                                   .square()
+                                   .transform(equal_to)
+                                   .fold_const(auto_constant<std::size_t{0}>{}, plus);
+
+  static_assert(self_comparison_count == fields.size(), "Merging these descriptions would result in duplicate IDs");
+
+  return description{std::move(fields)};
 }
 
 } // namespace upd
 
 namespace upd::descriptor {
 
-template<typename Id, typename Is_Signed, typename Width>
+template<auto Identifier, bool Signedness, std::size_t Width>
 struct field_t {
-  constexpr static auto id = Id::value;
-  constexpr static auto is_signed = Is_Signed::value;
-  constexpr static auto width = Width::value;
-  constexpr static auto ids = std::tuple<Id>{};
-
-  using underlying = xinteger<width, std::uintmax_t>;
+  constexpr static auto tag = field_tag::pure_field;
+  constexpr static auto identifier = Identifier;
+  constexpr static auto is_signed = Signedness;
+  constexpr static auto width = Width;
 };
 
-template<auto Id, bool Is_Signed, std::size_t Width>
-[[nodiscard]] constexpr auto field(signedness_t<Is_Signed>, width_t<Width>) noexcept {
-  using id = detail::integral_constant_t<Id>;
-  using is_signed = detail::integral_constant_t<Is_Signed>;
-  using width = detail::integral_constant_t<Width>;
+template<auto Identifier, bool Signedness, std::size_t Width>
+[[nodiscard]] constexpr auto field(signedness_t<Signedness>, width_t<Width>) noexcept(release) {
+  auto retval = field_t<Identifier, Signedness, Width>{};
+  return description{tuple{retval}};
+}
+
+template<auto Identifier, std::size_t Width>
+struct constant_t {
+  constexpr static auto tag = field_tag::constant;
+  constexpr static auto identifier = Identifier;
+  constexpr static auto is_signed = false;
+  constexpr static auto width = Width;
+
+  xuint<width> value;
+};
 
-  auto retval = field_t<id, is_signed, width>{};
-  return description{retval};
+template<auto Identifier, typename T, std::size_t Width>
+[[nodiscard]] constexpr auto constant(T n, width_t<Width>) noexcept(release) {
+  auto retval = constant_t<Identifier, Width>{};
+  return description{tuple{retval}};
 }
 
 } // namespace upd::descriptor
diff --git a/include/upd/detail/is_instance_of.hpp b/include/upd/detail/is_instance_of.hpp
index 869a315..f39810c 100644
--- a/include/upd/detail/is_instance_of.hpp
+++ b/include/upd/detail/is_instance_of.hpp
@@ -13,4 +13,10 @@ struct is_instance_of<TT<Ts...>, TT> : std::true_type {};
 template<typename T, template<typename...> typename TT>
 constexpr auto is_instance_of_v = is_instance_of<T, TT>::value;
 
+template<template<typename...> typename TT>
+struct is_instance_of_partial {
+  template<typename T>
+  using type = is_instance_of<T, TT>;
+};
+
 } // namespace upd::detail
diff --git a/include/upd/detail/variadic/diff.hpp b/include/upd/detail/variadic/diff.hpp
index 18d665d..d522329 100644
--- a/include/upd/detail/variadic/diff.hpp
+++ b/include/upd/detail/variadic/diff.hpp
@@ -9,21 +9,22 @@ struct diff;
 
 template<typename... Ts, typename... Us>
 struct diff<std::tuple<Ts...>, std::tuple<Us...>> {
-    constexpr static auto min_count = std::min(sizeof...(Ts), sizeof...(Us));
-    constexpr static auto max_count = std::max(sizeof...(Ts), sizeof...(Us));
+  constexpr static auto min_count = std::min(sizeof...(Ts), sizeof...(Us));
+  constexpr static auto max_count = std::max(sizeof...(Ts), sizeof...(Us));
 
-    using lhs = std::tuple<Ts...>;
-    using clipped_lhs = clip_t<lhs, 0, min_count>;
+  using lhs = std::tuple<Ts...>;
+  using clipped_lhs = clip_t<lhs, 0, min_count>;
 
-    using rhs = std::tuple<Us...>;
-    using clipped_rhs = clip_t<rhs, 0, min_count>;
+  using rhs = std::tuple<Us...>;
+  using clipped_rhs = clip_t<rhs, 0, min_count>;
 
-    template<typename... _Ts, typename... _Us, std::size_t... Is>
-    [[nodiscard]] static auto impl(std::tuple<_Ts...>, std::tuple<_Us...>, std::index_sequence<Is...>) noexcept {
-        return std::tuple<std::is_same<_Ts, _Us>..., std::bool_constant<true || Is>...>{};
-    }
+  template<typename... _Ts, typename... _Us, std::size_t... Is>
+  [[nodiscard]] static auto impl(std::tuple<_Ts...>, std::tuple<_Us...>, std::index_sequence<Is...>) noexcept {
+    return std::tuple<std::is_same<_Ts, _Us>..., std::bool_constant<true || Is>...>{};
+  }
 
-    using type = decltype(impl(std::declval<lhs>(), std::declval<rhs>(), std::make_index_sequence<max_count - min_count>{}));
+  using type =
+      decltype(impl(std::declval<lhs>(), std::declval<rhs>(), std::make_index_sequence<max_count - min_count>{}));
 };
 
 template<typename Lhs, typename Rhs>
diff --git a/include/upd/detail/variadic/equals.hpp b/include/upd/detail/variadic/equals.hpp
index fca6a99..587244a 100644
--- a/include/upd/detail/variadic/equals.hpp
+++ b/include/upd/detail/variadic/equals.hpp
@@ -6,7 +6,15 @@ template<typename, typename>
 struct equals;
 
 template<typename... Ts, typename... Us>
-struct equals<std::tuple<Ts...>, std::tuple<Us...>>: std::bool_constant<((Ts::value == Us::value) && ...)> {};
+struct equals<std::tuple<Ts...>, std::tuple<Us...>> {
+  constexpr static auto value = [] {
+    if constexpr (sizeof...(Ts) == sizeof...(Us)) {
+      return ((Ts::value == Us::value) && ...);
+    } else {
+      return false;
+    }
+  }();
+};
 
 template<typename Lhs, typename Rhs>
 constexpr auto equals_v = equals<Lhs, Rhs>::value;
diff --git a/include/upd/detail/variadic/filter.hpp b/include/upd/detail/variadic/filter.hpp
new file mode 100644
index 0000000..a773906
--- /dev/null
+++ b/include/upd/detail/variadic/filter.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <tuple>
+
+#include "clean.hpp"
+
+namespace upd::detail::variadic {
+
+template<typename, template<typename> typename>
+struct filter;
+
+template<typename... Ts, template<typename> typename F>
+struct filter<std::tuple<Ts...>, F> {
+  using marked = std::tuple<std::conditional_t<F<Ts>::value, Ts, marked_for_cleaning_t>...>;
+  using type = clean_t<marked>;
+};
+
+template<typename Tuple, template<typename> typename F>
+using filter_t = typename filter<Tuple, F>::type;
+
+template<typename, typename>
+struct filterf;
+
+template<typename... Ts, typename F>
+struct filterf<std::tuple<Ts...>, F> {
+  using marked = std::tuple<std::conditional_t<std::invoke_result_t<F, Ts>::value, Ts, marked_for_cleaning_t>...>;
+  using type = clean_t<marked>;
+};
+
+template<typename Tuple, typename F>
+using filterf_t = typename filterf<Tuple, F>::type;
+
+} // namespace upd::detail::variadic
\ No newline at end of file
diff --git a/include/upd/detail/variadic/find.hpp b/include/upd/detail/variadic/find.hpp
index 1b06c37..973d8eb 100644
--- a/include/upd/detail/variadic/find.hpp
+++ b/include/upd/detail/variadic/find.hpp
@@ -11,7 +11,8 @@ template<typename, typename>
 struct find;
 
 template<typename... Ts, typename U>
-struct find<std::tuple<Ts...>, U> : decltype(aggregated_leaves(std::declval<std::tuple<Ts...>>(), std::make_index_sequence<sizeof...(Ts)>{})
+struct find<std::tuple<Ts...>, U>
+    : decltype(aggregated_leaves(std::declval<std::tuple<Ts...>>(), std::make_index_sequence<sizeof...(Ts)>{})
                    .find((U *)nullptr)) {};
 
 template<typename T, typename U>
diff --git a/include/upd/detail/variadic/leaf.hpp b/include/upd/detail/variadic/leaf.hpp
index 43e4991..d20f99c 100644
--- a/include/upd/detail/variadic/leaf.hpp
+++ b/include/upd/detail/variadic/leaf.hpp
@@ -4,8 +4,8 @@
 #include <utility>
 
 #include "../../index_type.hpp"
-#include "../integral_constant.hpp"
 #include "../../literals.hpp"
+#include "../integral_constant.hpp"
 #include "../range.hpp"
 
 namespace upd::detail::variadic {
diff --git a/include/upd/detail/variadic/map.hpp b/include/upd/detail/variadic/map.hpp
index 7599cdc..dc1df5d 100644
--- a/include/upd/detail/variadic/map.hpp
+++ b/include/upd/detail/variadic/map.hpp
@@ -4,8 +4,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "flatten.hpp"
 #include "all_of.hpp"
+#include "flatten.hpp"
 
 namespace upd::detail::variadic {
 
@@ -58,7 +58,7 @@ using flatmapf_t = typename mapf<T, F>::type;
 template<typename Tuple, typename F>
 constexpr void for_each(Tuple, F) {
   using are_voids = map_t<Tuple, std::is_void>;
-  
+
   static_assert(all_of_v<are_voids>, "`F` should always return `void`");
 }
 
diff --git a/include/upd/detail/variadic/to_array.hpp b/include/upd/detail/variadic/to_array.hpp
index b72af2b..aa1cbda 100644
--- a/include/upd/detail/variadic/to_array.hpp
+++ b/include/upd/detail/variadic/to_array.hpp
@@ -7,7 +7,7 @@ struct to_array;
 
 template<typename... Ts>
 struct to_array<std::tuple<Ts...>> {
-    constexpr static auto value = std::array{Ts::value...};
+  constexpr static auto value = std::array{Ts::value...};
 };
 
 template<typename Tuple>
diff --git a/include/upd/integer.hpp b/include/upd/integer.hpp
index c60b3dd..d631393 100644
--- a/include/upd/integer.hpp
+++ b/include/upd/integer.hpp
@@ -1,25 +1,25 @@
 #pragma once
 
+#include <algorithm>
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <type_traits>
-#include <algorithm>
 #include <optional>
-#include <cmath>
+#include <type_traits>
 
-#include "detail/integral_constant.hpp"
+#include "detail/always_false.hpp"
 #include "detail/has_value_member.hpp"
-#include "literals.hpp"
+#include "detail/integral_constant.hpp"
 #include "detail/is_instance_of.hpp"
+#include "literals.hpp"
 #include "token.hpp"
-#include "detail/always_false.hpp"
 #include "upd.hpp"
 
 namespace upd::detail {
 
 template<typename T, std::size_t Bitsize>
-constexpr auto bitmask_v = ((T) 1 << Bitsize) - 1;
+constexpr auto bitmask_v = ((T)1 << Bitsize) - 1;
 
 } // namespace upd::detail
 
@@ -41,6 +41,15 @@ constexpr auto to_extended_integer(T) noexcept;
 template<typename, typename XInteger>
 constexpr auto decompose_into_xuint(XInteger) UPD_NOEXCEPT;
 
+template<typename Scalar>
+[[nodiscard]] constexpr auto reduce_scalar(Scalar, std::size_t) noexcept;
+
+template<typename Integer>
+[[nodiscard]] constexpr auto reduce_integer(Integer n, std::size_t bitsize) noexcept;
+
+template<typename Enum>
+[[nodiscard]] constexpr auto reduce_enum(Enum e, std::size_t bitsize) noexcept;
+
 template<std::size_t Bitsize, typename Underlying>
 using xinteger = extended_integer<detail::integral_constant_t<Bitsize>, Underlying>;
 
@@ -75,10 +84,10 @@ class extended_integer {
 
   static_assert(detail::has_value_member_v<Bitsize>, "`Bitsize` must has a `value` member");
   static_assert(std::is_integral_v<decltype(Bitsize::value)>, "`Bitsize::value` must be an integer");
-  static_assert(Bitsize::value >= 0,
-                "`Bitsize::value` must be a positive integer");
+  static_assert(Bitsize::value >= 0, "`Bitsize::value` must be a positive integer");
   static_assert(std::is_integral_v<Underlying_T>, "`Underlying_T` must be an integral type");
-  static_assert(Bitsize::value <= std::numeric_limits<Underlying_T>::digits, "`Bitsize::value` should be lesser or equal to the number of digits in `Underlying_T`");
+  static_assert(Bitsize::value <= std::numeric_limits<Underlying_T>::digits,
+                "`Bitsize::value` should be lesser or equal to the number of digits in `Underlying_T`");
 
 public:
   using underlying = Underlying_T;
@@ -87,22 +96,10 @@ class extended_integer {
   constexpr static auto is_signed = std::is_signed_v<underlying>;
 
   constexpr extended_integer() noexcept = default;
-  
+
   template<typename T>
-  constexpr extended_integer(T n) noexcept(release) {
-    if constexpr (std::is_integral_v<T>) {
-      using pow2_type = std::conditional_t<std::is_signed_v<T>, std::intmax_t, std::uintmax_t>;
-      auto pow2 = (pow2_type) 1 << bitsize;
-      m_value = static_cast<Underlying_T>(n % pow2);
-    } else if constexpr (std::is_enum_v<T>) {
-      using enum_underlying = std::underlying_type_t<T>;
-      using pow2_type = std::conditional_t<std::is_signed_v<enum_underlying>, std::intmax_t, std::uintmax_t>;
-      auto value = static_cast<enum_underlying>(n);
-      auto pow2 = (pow2_type) 1 << bitsize;
-      m_value = static_cast<Underlying_T>(value % pow2);
-    } else {
-      static_assert(UPD_ALWAYS_FALSE, "`n` must be an integer or an enumerator");
-    }
+  constexpr extended_integer(T n) noexcept(release) : m_value{(underlying)reduce_scalar(n, bitsize)} {
+    static_assert(std::is_integral_v<T> || std::is_enum_v<T>, "`n` must be an integer or an enumerator");
   }
 
   template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
@@ -112,14 +109,13 @@ class extended_integer {
       return static_cast<T>(m_value);
     } else {
       using underlying = std::underlying_type_t<T>;
-      static_assert(std::numeric_limits<underlying>::digits >= bitsize, "`T` cannot hold an integer with `Bitsize` bits");
+      static_assert(std::numeric_limits<underlying>::digits >= bitsize,
+                    "`T` cannot hold an integer with `Bitsize` bits");
       return static_cast<T>(m_value);
     }
   }
 
-  [[nodiscard]] constexpr auto value() const noexcept -> underlying {
-    return m_value;
-  }
+  [[nodiscard]] constexpr auto value() const noexcept -> underlying { return m_value; }
 
   template<std::size_t Bytewidth>
   [[nodiscard]] constexpr auto decompose(std::integral_constant<std::size_t, Bytewidth>) const noexcept {
@@ -131,7 +127,7 @@ class extended_integer {
   template<std::size_t ByteCount>
   [[nodiscard]] constexpr auto decompose(width_t<ByteCount>) const UPD_NOEXCEPT {
     using byte = xinteger<bitsize / ByteCount, underlying>;
- 
+
     return decompose_into_xuint<byte>(*this);
   }
 
@@ -148,9 +144,7 @@ class extended_integer {
     }
   }
 
-  [[nodiscard]] constexpr auto signbit() const noexcept -> bool {
-    return std::signbit(m_value);
-  }
+  [[nodiscard]] constexpr auto signbit() const noexcept -> bool { return std::signbit(m_value); }
 
   template<std::size_t NewBitsize>
   [[nodiscard]] constexpr auto resize(width_t<NewBitsize>) const noexcept {
@@ -196,25 +190,25 @@ class extended_integer {
 
   [[nodiscard]] constexpr auto operator~() const noexcept {
     static_assert(!is_signed, "Bitwise operators only work on unsigned values");
-  
+
     return xinteger<bitsize, underlying>{~m_value};
   }
 
-  constexpr auto operator<<=(std::size_t offset) noexcept -> extended_integer& {
+  constexpr auto operator<<=(std::size_t offset) noexcept -> extended_integer & {
     static_assert(!is_signed, "Bitwise operators only work on unsigned values");
-  
+
     m_value <<= offset;
 
     return *this;
   }
 
   template<typename T>
-  constexpr auto operator|=(T rhs) noexcept -> extended_integer& {
+  constexpr auto operator|=(T rhs) noexcept -> extended_integer & {
     auto xrhs = to_extended_integer(rhs);
-    
+
     static_assert(!is_signed && !xrhs.is_signed, "Bitwise operators only work on unsigned values");
     static_assert(xrhs.bitsize <= bitsize, "Such an operation would cause a narrowing conversion");
-  
+
     m_value |= xrhs.m_value;
 
     return *this;
@@ -285,7 +279,7 @@ template<typename Byte, typename XInteger>
 template<typename T, std::size_t N>
 [[nodiscard]] constexpr auto recompose_into_xuint(const std::array<T, N> &byteseq) noexcept {
   using namespace upd::literals;
-  
+
   auto retval = xuint<bitsize_v<T> * N>{0};
   auto first = byteseq.rbegin();
   auto last = byteseq.rend();
@@ -299,4 +293,39 @@ template<typename T, std::size_t N>
   return retval;
 }
 
+template<typename Scalar>
+[[nodiscard]] constexpr auto reduce_scalar(Scalar s, std::size_t bitsize) noexcept {
+  static_assert(std::is_scalar_v<Scalar>, "`s` must be a scalar type");
+
+  if constexpr (std::is_integral_v<Scalar>) {
+    return reduce_integer(s, bitsize);
+  } else if constexpr (std::is_enum_v<Scalar>) {
+    return reduce_enum(s, bitsize);
+  } else {
+    static_assert(UPD_ALWAYS_FALSE, "`s` has an unsupported type");
+  }
+}
+
+template<typename Integer>
+[[nodiscard]] constexpr auto reduce_integer(Integer n, std::size_t bitsize) noexcept {
+  static_assert(std::is_integral_v<Integer>, "`n` must be an integer");
+
+  using pow2_type = std::conditional_t<std::is_signed_v<Integer>, std::intmax_t, std::uintmax_t>;
+
+  auto pow2 = (pow2_type)1 << bitsize;
+
+  return n % pow2;
+}
+
+template<typename Enum>
+[[nodiscard]] constexpr auto reduce_enum(Enum e, std::size_t bitsize) noexcept {
+  static_assert(std::is_enum_v<Enum>, "`e` must be an enumerator");
+
+  using underlying = std::underlying_type_t<Enum>;
+
+  auto value = static_cast<underlying>(e);
+
+  return reduce_integer(value, bitsize);
+}
+
 } // namespace upd
diff --git a/include/upd/named_tuple.hpp b/include/upd/named_tuple.hpp
index 0788baa..efcc49b 100644
--- a/include/upd/named_tuple.hpp
+++ b/include/upd/named_tuple.hpp
@@ -11,8 +11,8 @@
 #include "detail/integral_constant.hpp"
 #include "detail/tuple_operations.hpp"
 #include "detail/variadic/concat.hpp"
-#include "detail/variadic/find.hpp"
 #include "detail/variadic/count.hpp"
+#include "detail/variadic/find.hpp"
 #include "integer.hpp"
 #include "upd.hpp"
 
@@ -69,10 +69,8 @@ class named_tuple {
   }
 
   template<typename Serializer, typename OutputIt>
-  constexpr void serialize(Serializer &ser, OutputIt output)  {
-    auto serialize_pack = [&] (const auto &... xs) {
-      (xs.serialize(ser, output), ...);
-    };
+  constexpr void serialize(Serializer &ser, OutputIt output) {
+    auto serialize_pack = [&](const auto &...xs) { (xs.serialize(ser, output), ...); };
 
     std::apply(serialize_pack, m_content);
   }
@@ -85,10 +83,10 @@ class named_tuple {
 };
 
 template<typename>
-struct is_named_tuple_instance: std::false_type {};
+struct is_named_tuple_instance : std::false_type {};
 
 template<typename Tuple, auto... Identifiers>
-struct is_named_tuple_instance<named_tuple<Tuple, Identifiers...>>: std::true_type {};
+struct is_named_tuple_instance<named_tuple<Tuple, Identifiers...>> : std::true_type {};
 
 template<auto... Ids, typename... Ts>
 [[nodiscard]] constexpr auto name_tuple(std::tuple<Ts...> tuple) noexcept {
diff --git a/include/upd/named_value.hpp b/include/upd/named_value.hpp
index c0ce701..446a4c6 100644
--- a/include/upd/named_value.hpp
+++ b/include/upd/named_value.hpp
@@ -12,12 +12,13 @@
 #include "detail/tuple_operations.hpp"
 #include "detail/variadic/concat.hpp"
 #include "integer.hpp"
-#include "upd.hpp"
 #include "named_tuple.hpp"
+#include "upd.hpp"
 
 namespace upd {
 
-template<typename> struct kw_t;
+template<typename>
+struct kw_t;
 
 template<auto Identifier>
 constexpr auto kw = kw_t<detail::integral_constant_t<Identifier>>{};
@@ -61,7 +62,7 @@ struct named_value {
   }
 
   template<typename NamedObject>
-  [[nodiscard]] constexpr auto operator,(NamedObject nobj) && noexcept {
+  [[nodiscard]] constexpr auto operator,(NamedObject nobj) &&noexcept {
     if constexpr (detail::is_instance_of_v<NamedObject, named_value>) {
       auto values = std::tuple{std::move(value), std::move(nobj.value)};
       return name_tuple<identifier, nobj.identifier>(std::move(values));
diff --git a/include/upd/tuple.hpp b/include/upd/tuple.hpp
index 18ed54f..8b44ca0 100644
--- a/include/upd/tuple.hpp
+++ b/include/upd/tuple.hpp
@@ -1,449 +1,602 @@
-//! \file
-
 #pragma once
 
-#include <array>
-#include <cstddef>
-#include <type_traits>
-
-#include "detail/serialization.hpp"
-#include "detail/type_traits/conjunction.hpp"
-#include "detail/type_traits/index_sequence.hpp"
-#include "detail/type_traits/require.hpp"
-#include "detail/type_traits/signature.hpp"
-#include "detail/type_traits/typelist.hpp"
-#include "format.hpp"
-#include "type.hpp"
-#include "typelist.hpp"
-#include "upd.hpp"
+#include "detail/variadic/at.hpp"
+#include "detail/variadic/leaf.hpp"
 
 namespace upd {
 
-template<typename, endianess, signed_mode, typename...>
-class tuple_view;
+struct encapsulate_t {};
+
+constexpr auto encapsulate = encapsulate_t{};
+
+template<typename Operator>
+struct operator_invoker {
+  constexpr static auto op = Operator{};
+
+  template<typename Lhs, typename Rhs>
+  [[nodiscard]] constexpr auto operator()(const Lhs &lhs, const Rhs &rhs) const -> decltype(auto) {
+    return op(lhs, rhs);
+  }
+
+  template<typename Lhs, typename Rhs>
+  [[nodiscard]] constexpr auto operator()(const std::pair<Lhs, Rhs> &lhs_rhs) const -> decltype(auto) {
+    const auto &[lhs, rhs] = lhs_rhs;
+    return op(lhs, rhs);
+  }
+};
+
+constexpr inline auto equal_to = operator_invoker<std::equal_to<>>{};
+constexpr inline auto plus = operator_invoker<std::plus<>>{};
+
+} // namespace upd
+
+namespace upd {
 
-namespace detail {
+template<auto Value>
+struct auto_constant {
+  using type = auto_constant<Value>;
+  using value_type = std::remove_cv_t<std::remove_reference_t<decltype(Value)>>;
+
+  constexpr static auto value = [] {
+    if constexpr (std::is_invocable_v<value_type>) {
+      return Value();
+    } else {
+      return Value;
+    }
+  }();
+
+  template<typename T>
+  [[nodiscard]] constexpr operator T() {
+    return static_cast<T>(value);
+  }
+};
+
+template<auto Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator==(auto_constant<Lhs>, auto_constant<Rhs>) noexcept -> decltype(auto) {
+  return auto_constant<Lhs == Rhs>{};
+}
+
+template<auto Lhs, typename Rhs>
+[[nodiscard]] constexpr auto operator==(auto_constant<Lhs>, Rhs &&rhs) -> decltype(auto) {
+  return Lhs == UPD_FWD(rhs);
+}
+
+template<typename Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator==(Lhs &&lhs, auto_constant<Rhs>) -> decltype(auto) {
+  return UPD_FWD(lhs) == Rhs;
+}
+
+template<auto Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator<(auto_constant<Lhs>, auto_constant<Rhs>) noexcept -> decltype(auto) {
+  return auto_constant < Lhs<Rhs>{};
+}
+
+template<auto Lhs, typename Rhs>
+[[nodiscard]] constexpr auto operator<(auto_constant<Lhs>, Rhs &&rhs) -> decltype(auto) {
+  return Lhs < UPD_FWD(rhs);
+}
 
-template<typename, endianess, signed_mode, typename...>
-class tuple_base; // IWYU pragma: keep
+template<typename Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator<(Lhs &&lhs, auto_constant<Rhs>) -> decltype(auto) {
+  return UPD_FWD(lhs) < Rhs;
+}
 
-//! \name
-//! \brief Normalize some type before being passed to a function
-//!
-//! For now, the only types to normalize are `std::array` instances (to their corresponding plain array-type)
-// \warning Be careful when using these functions as they do not extent the lifetime of their parameter.
-//!
-//! @{
+template<auto Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator+(auto_constant<Lhs>, auto_constant<Rhs>) noexcept -> decltype(auto) {
+  return auto_constant<Lhs + Rhs>{};
+}
 
-template<typename Target_T, typename T, std::size_t N, UPD_REQUIRE(std::is_same<Target_T, T[N]>::value)>
-auto normalize(std::array<T, N> &&array) -> T (&&)[N] {
-  return reinterpret_cast<T(&&)[N]>(*array.data());
+template<auto Lhs, typename Rhs>
+[[nodiscard]] constexpr auto operator+(auto_constant<Lhs>, Rhs &&rhs) -> decltype(auto) {
+  return Lhs + UPD_FWD(rhs);
 }
-template<typename Target_T,
-         typename T,
-         require<std::is_same<decltype(read_as<T, endianess::LITTLE, signed_mode::TWOS_COMPLEMENT>(nullptr)),
-                              Target_T>::value> = 0>
-T &&normalize(T &&x) {
-  return UPD_FWD(x);
+
+template<typename Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator+(Lhs &&lhs, auto_constant<Rhs>) -> decltype(auto) {
+  return UPD_FWD(lhs) + Rhs;
 }
 
-//! @}
+template<auto Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator-(auto_constant<Lhs>, auto_constant<Rhs>) noexcept -> decltype(auto) {
+  return auto_constant<Lhs - Rhs>{};
+}
 
-//! \brief Return the size in bytes occupied by the serialization of instances of the provided type (if serializable)
-template<typename T, detail::require_is_serializable<T> = 0>
-constexpr std::size_t serialization_size_impl(...) {
-  return sizeof(T);
+template<auto Lhs, typename Rhs>
+[[nodiscard]] constexpr auto operator-(auto_constant<Lhs>, Rhs &&rhs) -> decltype(auto) {
+  return Lhs - UPD_FWD(rhs);
 }
-template<typename T, detail::require_is_user_serializable<T> = 0>
-constexpr std::size_t serialization_size_impl(int) {
-  return decltype(make_view_for<endianess::LITTLE, signed_mode::TWOS_COMPLEMENT>(
-      (byte_t *)nullptr, examine_invocable<decltype(upd_extension<T>::unserialize)>{}))::size;
+
+template<typename Lhs, auto Rhs>
+[[nodiscard]] constexpr auto operator-(Lhs &&lhs, auto_constant<Rhs>) -> decltype(auto) {
+  return UPD_FWD(lhs) - Rhs;
 }
 
-//! \brief Return the size in bytes occupied by the serialization of instances of the provided type (if serializable)
+template<typename>
+struct is_auto_constant : std::false_type {};
+
+template<auto Value>
+struct is_auto_constant<auto_constant<Value>> : std::true_type {};
+
+template<typename T>
+constexpr auto is_auto_constant_v = is_auto_constant<T>::value;
+
+template<typename...>
+class tuple;
+
+template<typename...>
+class typelist;
+
+template<auto...>
+class constlist;
+
+template<std::size_t... Is>
+using indexlist = constlist<Is...>;
+
 template<typename T>
-struct serialization_size {
-  constexpr static auto value = serialization_size_impl<T>(0);
+struct typebox {
+  using type = T;
+
+  constexpr auto operator->() const noexcept -> const type * { return nullptr; }
+};
+
+} // namespace upd
+
+template<typename... Ts>
+struct std::tuple_size<upd::tuple<Ts...>> {
+  constexpr static auto value = sizeof...(Ts);
+};
+
+template<std::size_t I, typename... Ts>
+struct std::tuple_element<I, upd::tuple<Ts...>> {
+  using type = upd::detail::variadic::at_t<std::tuple<Ts...>, I>;
+};
+
+template<typename... Ts>
+struct std::tuple_size<upd::typelist<Ts...>> {
+  constexpr static auto value = sizeof...(Ts);
+};
+
+template<std::size_t I, typename... Ts>
+struct std::tuple_element<I, upd::typelist<Ts...>> {
+  using type = upd::detail::variadic::at_t<std::tuple<Ts...>, I>;
+};
+
+template<auto... Vs>
+struct std::tuple_size<upd::constlist<Vs...>> {
+  constexpr static auto value = sizeof...(Vs);
 };
 
-//! \brief Make a tuple view according to a typelist
-template<endianess Endianess, signed_mode Signed_Mode, typename It, typename... Ts>
-auto make_view_from_typelist(const It &it, detail::tlist_t<Ts...>)
-    -> decltype(tuple_view<It, Endianess, Signed_Mode, Ts...>{it}) {
-  return tuple_view<It, Endianess, Signed_Mode, Ts...>{it};
+template<std::size_t I, auto... Vs>
+struct std::tuple_element<I, upd::constlist<Vs...>> {
+  using type = upd::detail::variadic::at_t<std::tuple<upd::auto_constant<Vs>...>, I>;
+};
+
+namespace upd::detail {
+
+template<typename F, std::size_t... Is>
+[[nodiscard]] constexpr auto apply_on_index_sequence(F &&f, std::index_sequence<Is...>) -> decltype(auto) {
+  return UPD_FWD(f)(std::integral_constant<std::size_t, Is>{}...);
 }
 
-//! \brief Provides tuple features to the derived class throught CRTP
-//! \tparam D Type of the derived class
-//! \tparam Endianess endianess of the stored data
-//! \tparam Signed_Mode signed mode of the stored data
-//! \tparam Ts... Types of the serialized values
-template<typename D, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-class tuple_base {
-  D &derived() { return static_cast<D &>(*this); }
-  const D &derived() const { return static_cast<const D &>(*this); }
-
-  static_assert(detail::conjunction<std::integral_constant<bool,
-                                                           (!std::is_const<Ts>::value && !std::is_volatile<Ts>::value &&
-                                                            !std::is_reference<Ts>::value)>...>::value,
-                "Type parameters cannot be cv-qualified or ref-qualified.");
-
-  static_assert(detail::conjunction<detail::is_serializable<Ts>...>::value,
-                "Some of the provided types are not serializable (serializable types are integer types, types with "
-                "user-defined extension and array types of any of these)");
+template<std::size_t I, typename T>
+struct leaf {
+  [[nodiscard]] constexpr auto at(auto_constant<I>) &noexcept -> T & { return value; }
 
-public:
-  //! \brief Typelist holding `Ts...`
-  using types_t = upd::typelist_t<Ts...>;
+  [[nodiscard]] constexpr auto at(auto_constant<I>) const &noexcept -> const T & { return value; }
+
+  [[nodiscard]] constexpr auto at(auto_constant<I>) &&noexcept -> T && { return std::move(value); }
+
+  [[nodiscard]] constexpr auto at(auto_constant<I>) const &&noexcept -> const T && { return std::move(value); }
+
+  [[nodiscard]] constexpr static auto typebox_at(auto_constant<I>) noexcept -> typebox<T>;
+
+  T value;
+};
+
+template<typename, typename...>
+struct leaves;
 
-  //! \brief Typelist holding the sizes in byte of each type of `Ts...` when serialized
-  using sizes_t = upd::typelist_t<serialization_size<Ts>...>;
+template<std::size_t... Is, typename... Ts>
+struct leaves<std::index_sequence<Is...>, Ts...> : leaf<Is, Ts>... {
+  using leaf<Is, Ts>::at...;
+  using leaf<Is, Ts>::typebox_at...;
 
-  //! \brief Type of one of the serialized values
-  //! \tparam I Index of the requested type in `Ts...`
   template<std::size_t I>
-  using arg_t = detail::at<types_t, I>;
+  using raw_type = typename decltype(typebox_at(auto_constant<I>{}))::type;
+
+  constexpr static auto size = sizeof...(Ts);
+
+  explicit constexpr leaves() = default;
+
+  explicit constexpr leaves(Ts... xs) : leaf<Is, Ts>{UPD_FWD(xs)}... {}
+
+  [[nodiscard]] constexpr auto at(...) const noexcept -> variadic::not_found_t { return variadic::not_found; }
+};
+
+} // namespace upd::detail
+
+namespace upd {
+
+template<std::size_t N>
+constexpr auto sequence = detail::apply_on_index_sequence([](auto... is) { return indexlist<is.value...>{}; },
+                                                          std::make_index_sequence<N>{});
+
+template<std::size_t, typename Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&) noexcept -> auto &&;
+
+template<typename... Ts>
+[[nodiscard]] constexpr auto fittest_tuple_like(Ts &&...);
+
+template<typename Tuple, typename F>
+[[nodiscard]] constexpr auto apply(Tuple &&, F &&);
 
-  //! \brief Storage size in byte
-  constexpr static auto size = detail::sum<sizes_t>::value;
+template<typename Tuple, typename F>
+constexpr void for_each(Tuple &&, F &&);
 
-  //! \brief Equals the endianess given as template parameter
-  constexpr static auto storage_endianess = Endianess;
+template<typename Derived>
+class tuple_implementation {
+  constexpr static auto normalize = [](auto &&...xs) noexcept { return fittest_tuple_like(UPD_FWD(xs)...); };
 
-  //! \brief Equals the signed mode given as template parameter
-  constexpr static auto storage_signed_mode = Signed_Mode;
+  [[nodiscard]] constexpr auto derived() noexcept -> Derived & { return reinterpret_cast<Derived &>(*this); }
 
-  //! \brief Copy each element of a tuple-like object into the content
-  //! \param t Tuple-like object to copy from
-  template<typename Tuple, UPD_REQUIREMENT(is_tuple, Tuple)>
-  D &operator=(Tuple &&t) {
-    lay_tuple(make_index_sequence<sizeof...(Ts)>{}, UPD_FWD(t));
-    return derived();
+  [[nodiscard]] constexpr auto derived() const noexcept -> const Derived & {
+    return reinterpret_cast<const Derived &>(*this);
   }
 
-  //! \brief Unserialize one of the value held by the object
-  //! \tparam I Index of the requested value
-  //! \return A copy of the serialized value or a `std::array` instance if `I` designates an array type
-#ifdef DOXYGEN
-  template<std::size_t I>
-  auto get() const;
-#else
-  template<std::size_t I>
-  decltype(read_as<arg_t<I>, Endianess, Signed_Mode>(nullptr)) get() const {
-    using detail::clip;
-    using detail::sum;
+public:
+  template<typename I>
+  [[nodiscard]] constexpr auto operator[](I i) &noexcept -> auto & {
+    return get<i>(derived());
+  }
 
-    constexpr auto offset = sum<clip<sizes_t, 0, I>>::value;
-    return read_as<arg_t<I>, Endianess, Signed_Mode>(derived().src(), offset);
+  template<typename I>
+  [[nodiscard]] constexpr auto operator[](I i) const &noexcept -> const auto & {
+    return get<i>(derived());
   }
-#endif
 
-  //! \brief Set one of the value held by the object
-  //! \tparam I Index of the value which will be set
-  //! \param value Value to be copied from
-  template<std::size_t I>
-  void set(const arg_t<I> &value) {
-    using detail::clip;
-    using detail::sum;
+  template<typename I>
+  [[nodiscard]] constexpr auto operator[](I i) &&noexcept -> auto && {
+    return get<i>(std::move(derived()));
+  }
+
+  template<typename I>
+  [[nodiscard]] constexpr auto operator[](I i) const &&noexcept -> const auto && {
+    return get<i>(std::move(derived()));
+  }
+
+  template<typename I>
+  [[nodiscard]] constexpr auto at(I i) &noexcept -> auto & {
+    return get<i>(derived());
+  }
+
+  template<typename I>
+  [[nodiscard]] constexpr auto at(I i) const &noexcept -> const auto & {
+    return get<i>(derived());
+  }
+
+  template<typename I>
+  [[nodiscard]] constexpr auto at(I i) &&noexcept -> auto && {
+    return get<I>(std::move(derived()));
+  }
+
+  template<typename I>
+  [[nodiscard]] constexpr auto at(I i) const &&noexcept -> const auto && {
+    return get<I>(std::move(derived()));
+  }
+
+  [[nodiscard]] constexpr auto flatten() const {
+    struct subelement_index {
+      std::size_t sub_index;
+      std::size_t index;
+    };
+
+    auto get_sub_size = [](auto sub) { return sub.size(); };
+    auto retval_size = derived().transform_const(get_sub_size).fold_const(auto_constant<0>{}, plus);
+
+    auto make_shape = [&](auto... xs) {
+      auto shape = std::array<subelement_index, retval_size>{};
+      auto cursor = shape.begin();
+      auto sub_index = std::size_t{0};
+
+      auto add_sub_shape = [&](const auto &sub) {
+        for (auto i = std::size_t{0}; i < sub.size(); ++i, ++cursor) {
+          *cursor = subelement_index{sub_index, i};
+        }
+
+        ++sub_index;
+      };
+
+      (add_sub_shape(xs), ...);
+
+      return shape;
+    };
+
+    auto shape = derived().apply_const(make_shape, encapsulate);
+    auto shape_seq = sequence<shape().size()>;
+    auto get_subelement = [&](auto i) -> auto && {
+      constexpr auto subelement_index = shape()[i];
+      auto sub_index = auto_constant<subelement_index.sub_index>{};
+      auto index = auto_constant<subelement_index.index>{};
+
+      return UPD_FWD(derived()).at(sub_index).at(index);
+    };
 
-    constexpr auto offset = sum<clip<sizes_t, 0, I>>::value;
-    write_as<Endianess, Signed_Mode>(value, derived().src(), offset);
+    return shape_seq.transform(get_subelement);
+  }
+
+  template<typename Init, typename BinaryOp>
+  [[nodiscard]] constexpr auto fold_const(Init init, BinaryOp op) const noexcept {
+    auto impl = [](auto init, auto op, auto... xs) {
+      auto acc = init.value;
+      ((void)(acc = op(acc, xs)), ...);
+
+      return acc;
+    };
+
+    auto invoke_impl_const = [&](auto... xs) {
+      constexpr auto result = impl(init, op, xs...);
+      return auto_constant<result>{};
+    };
+
+    return derived().apply(invoke_impl_const);
+  }
+
+  template<template<typename> typename TT>
+  [[nodiscard]] constexpr static auto metatransform() noexcept {
+    auto apply_and_box_type = [](auto i) {
+      using raw = typename Derived::template raw_type<i>;
+      using result = TT<raw>;
+
+      return typebox<result>{};
+    };
+
+    return sequence<size()>.transform(apply_and_box_type);
+  }
+
+  [[nodiscard]] constexpr auto square() {
+    auto seq = sequence<size()>;
+    auto pair_up = [&](auto i) { return seq.transform([&](auto j) { return indexlist<i, j>{}; }); };
+
+    auto squared_seq = seq.transform(pair_up).flatten();
+
+    auto make_pair = [&](auto ipair) {
+      auto [i, j] = ipair;
+      return std::pair{at(i), at(j)};
+    };
+
+    return squared_seq.transform(make_pair);
   }
 
-  //! \brief Invoke a functor with the stored values
-  //! \param ftor Callback to be invoked
-  //! \return `ftor(upd::get<Is>()...)` with `Is` = `0`, `1`, ..., `sizeof...(Ts)`
-#ifdef DOXYGEN
   template<typename F>
-  auto invoke(F &&ftor) const;
-#else
+  [[nodiscard]] constexpr auto transform(F &&f) & {
+    return transform_and_apply(derived(), UPD_FWD(f), normalize);
+  }
+
   template<typename F>
-  detail::return_t<F> invoke(F &&ftor) const {
-    return invoke_impl(UPD_FWD(ftor), make_index_sequence<sizeof...(Ts)>{});
+  [[nodiscard]] constexpr auto transform(F &&f) const & {
+    return transform_and_apply(derived(), UPD_FWD(f), normalize);
   }
-#endif
 
-protected:
-  //! \brief Serialize values into the object content
-  template<std::size_t... Is, typename... Args>
-  void lay(detail::index_sequence<Is...>, const Args &...args) {
-    using discard = int[];
-    (void)discard{0, (set<Is>(args), 0)...};
+  template<typename F>
+  [[nodiscard]] constexpr auto transform(F &&f) && {
+    return transform_and_apply(std::move(derived()), UPD_FWD(f), normalize);
   }
 
-  //! \brief Lay the element of a tuple-like object into the content
-  template<std::size_t... Is, typename T>
-  void lay_tuple(detail::index_sequence<Is...> is, T &&t) {
-    lay(is, t.template get<Is>()...);
+  template<typename F>
+  [[nodiscard]] constexpr auto transform(F &&f) const && {
+    return transform_and_apply(std::move(derived()), UPD_FWD(f), normalize);
   }
 
-private:
-  //! \brief Unserialize the tuple content and forward it as parameters to the provided functor
-  template<typename F, std::size_t... Is>
-  detail::return_t<F> invoke_impl(F &&ftor, detail::index_sequence<Is...>) const {
-    return UPD_FWD(ftor)(detail::normalize<Ts>(get<Is>())...);
+  template<typename F>
+  [[nodiscard]] constexpr auto transform_const(F f) const noexcept {
+    auto apply_const = [&](auto x) { return auto_constant<f(x)>{}; };
+
+    return derived().transform(apply_const);
   }
-};
 
-} // namespace detail
-
-//! \brief Call the member function `get()` from an Unpadded tuple-like instance
-//!
-//! This function create a coherent interface with std::tuple for the sake of genericity.
-//!
-//! \param t Tuple to get a value from
-#if defined(DOXYGEN)
-template<std::size_t I, typename D, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-auto get(const detail::tuple_base<D, Endianess, Signed_Mode, Ts...> &t)
-#else  // defined(DOXYGEN)
-template<std::size_t I, typename D, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-decltype(std::declval<detail::tuple_base<D, Endianess, Signed_Mode, Ts...>>().template get<I>())
-get(const detail::tuple_base<D, Endianess, Signed_Mode, Ts...> &t)
-#endif // defined(DOXYGEN)
-{
-  return t.template get<I>();
-}
+  template<typename F>
+  [[nodiscard]] constexpr auto transform_type(F &&) const noexcept {
+    auto apply_and_box_type = [](auto i) {
+      using raw = typename Derived::template raw_type<i>;
+      using result = std::invoke_result_t<F, raw>;
 
-//! \brief Call the member function `set()` from an Unpadded tuple-like instance
-//!
-//! This function create a coherent interface std::tuple for the sake of genericity
-//!
-//! \param t Tuple to set a value in
-//! \param value Value to set
-template<std::size_t I, typename D, endianess Endianess, signed_mode Signed_Mode, typename... Ts, typename U>
-void set(detail::tuple_base<D, Endianess, Signed_Mode, Ts...> &t, U &&value) {
-  return t.template set<I>(UPD_FWD(value));
-}
+      return typebox<result>{};
+    };
 
-//! \brief Binds a byte sequence to a tuple view
-//!
-//! Once bound, the byte sequence content can be read and modified as it were the content of a \ref<tuple> tuple
-//! instance. The byte sequence and the tuple view are bound through an iterator. It must at least be a forward
-//! iterator, but tuple views are faster with random access iterators. Best case would be a non-volatile plain pointer,
-//! as it can be called with memcpy. \tparam It Type of the iterator used for binding with the byte sequence \tparam
-//! Endianess, Signed_Mode Serialization parameters \tparam Ts... Types of the serialized values
-template<typename It, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-class tuple_view
-    : public detail::tuple_base<tuple_view<It, Endianess, Signed_Mode, Ts...>, Endianess, Signed_Mode, Ts...> {
-  using base_t = detail::tuple_base<tuple_view<It, Endianess, Signed_Mode, Ts...>, Endianess, Signed_Mode, Ts...>;
+    return sequence<size()>.transform(apply_and_box_type);
+  }
 
-public:
-  using base_t::operator=;
+  [[nodiscard]] constexpr static auto type_only() noexcept {
+    auto apply_and_box_type = [](auto i) {
+      using raw = typename Derived::template raw_type<i>;
+      return typebox<raw>{};
+    };
 
-  //! \brief Bind the view to a byte sequence through an iterator
-  //! \param src Iterator to the start of the byte sequence
-  explicit tuple_view(const It &src) : m_begin{src}, m_end{src} { std::advance(m_end, base_t::size); }
+    return sequence<size()>.transform(apply_and_box_type);
+  }
 
-  //! \brief Beginning of the byte sequence
-  const It &begin() const { return m_begin; }
+  template<typename F>
+  [[nodiscard]] constexpr auto apply(F &&f) & -> decltype(auto) {
+    return upd::apply(derived(), UPD_FWD(f));
+  }
 
-  //! \brief End of the byte sequence
-  const It &end() const { return m_end; }
-  //! @}
+  template<typename F>
+  [[nodiscard]] constexpr auto apply(F &&f) const & -> decltype(auto) {
+    return upd::apply(derived(), UPD_FWD(f));
+  }
 
-  //! \copydoc begin()
-  const It &src() const { return m_begin; }
+  template<typename F>
+  [[nodiscard]] constexpr auto apply(F &&f) && -> decltype(auto) {
+    return upd::apply(std::move(derived()), UPD_FWD(f));
+  }
 
-private:
-  It m_begin, m_end;
+  template<typename F>
+  [[nodiscard]] constexpr auto apply(F &&f) const && -> decltype(auto) {
+    return upd::apply(std::move(derived()), UPD_FWD(f));
+  }
+
+  template<typename F>
+  [[nodiscard]] constexpr auto apply_const(F f, encapsulate_t) const noexcept {
+    auto impl = [&](auto... xs) {
+      constexpr auto result = f(xs...);
+      return [&] { return result; };
+    };
+
+    return derived().apply(impl);
+  }
+
+  template<typename F>
+  constexpr void for_each(F &&f) & {
+    upd::for_each(derived(), UPD_FWD(f));
+  }
+
+  template<typename F>
+  constexpr void for_each(F &&f) const & {
+    upd::for_each(derived(), UPD_FWD(f));
+  }
+
+  template<typename F>
+  constexpr void for_each(F &&f) && {
+    upd::for_each(std::move(derived()), UPD_FWD(f));
+  }
+
+  template<typename F>
+  constexpr void for_each(F &&f) const && {
+    upd::for_each(std::move(derived()), UPD_FWD(f));
+  }
+
+  [[nodiscard]] constexpr static auto size() noexcept -> std::size_t { return std::tuple_size_v<Derived>; }
 };
 
-//! \brief Bind a byte sequence to a tuple view
-//! \tparam Ts... Types held by the tuple
-//! \tparam Endianess Target endianess for serialization
-//! \tparam Signed_Mode Target signed representation for serialization
-//! \param src Start of the byte sequence
-//! \return a \ref<tuple_view> tuple_view instance bound to the byte sequence
-//! \related tuple_view
-template<typename... Ts, typename It, endianess Endianess, signed_mode Signed_Mode>
-tuple_view<It, Endianess, Signed_Mode, Ts...>
-make_view(endianess_h<Endianess>, signed_mode_h<Signed_Mode>, const It &src) {
-  return tuple_view<It, Endianess, Signed_Mode, Ts...>{src};
-}
+template<typename... Ts>
+class tuple : public tuple_implementation<tuple<Ts...>> {
+  template<std::size_t, typename Tuple>
+  friend constexpr auto get(Tuple &&) noexcept -> auto &&;
 
-//! \upd_doc{MakeView_Tuple}
-//! \brief Bind a view to a slice of a \ref<tuple> tuple
-//! \tparam I First element in the view
-//! \tparam L Number of elements in the view
-//! \param tuple Tuple to bind the view to
-//! \return a \ref<tuple_view> tuple_view including every elements in the given range
-//! \related tuple_view
-
-//! \copydoc MakeView_Tuple
-#if defined(DOXYGEN)
-template<std::size_t I, std::size_t L, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-auto make_view(tuple<Endianess, Signed_Mode, Ts...> &tuple)
-#else  // defined(DOXYGEN)
-template<std::size_t I, std::size_t L, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-auto make_view(tuple<Endianess, Signed_Mode, Ts...> &tuple) -> decltype(tuple.template view<I, L>())
-#endif // defined(DOXYGEN)
-{
-  return tuple.template view<I, L>();
-}
+  using leaves = detail::leaves<std::index_sequence_for<Ts...>, Ts...>;
 
-//! \copydoc MakeView_Tuple
-#if defined(DOXYGEN)
-template<std::size_t I, std::size_t L, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-auto make_view(const tuple<Endianess, Signed_Mode, Ts...> &tuple)
-#else  // defined(DOXYGEN)
-template<std::size_t I, std::size_t L, endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-auto make_view(const tuple<Endianess, Signed_Mode, Ts...> &tuple) -> decltype(tuple.template view<I, L>())
-#endif // defined(DOXYGEN)
-{
-  return tuple.template view<I, L>();
-}
+public:
+  template<std::size_t I>
+  using raw_type = typename leaves::template raw_type<I>;
+
+  template<typename Tuple>
+  [[nodiscard]] constexpr static auto normalize(Tuple &&tuple) {
+    return fittest_tuple_like(UPD_FWD(tuple));
+  }
 
-//! \brief Unaligned storage tuple
-//!
-//! \ref<tuple> tuple instances hold values like a tuple but in an unaligned manner (i.e., there is no padding between
-//! two consecutive values).
-//!
-//! \tparam Endianess, Signed_Mode Serialization parameters
-//! \tparam Ts... Types of the serialized values
-template<endianess Endianess, signed_mode Signed_Mode, typename... Ts>
-class tuple : public detail::tuple_base<tuple<Endianess, Signed_Mode, Ts...>, Endianess, Signed_Mode, Ts...> {
-  using base_t = detail::tuple_base<tuple<Endianess, Signed_Mode, Ts...>, Endianess, Signed_Mode, Ts...>;
-  using types_t = typename base_t::types_t;
-  using sizes_t = typename base_t::sizes_t;
+  explicit constexpr tuple(Ts... xs) noexcept : m_leaves{std::move(xs)...} {}
+
+private:
+  leaves m_leaves;
+};
+
+template<typename... Ts>
+class typelist : public tuple_implementation<typelist<Ts...>> {
+  template<std::size_t, typename Tuple>
+  friend constexpr auto get(Tuple &&) noexcept -> auto &&;
+
+  using leaves = detail::leaves<std::index_sequence_for<Ts...>, typebox<Ts>...>;
 
 public:
-  using base_t::operator=;
-
-  //! \brief Initialize the internal storage with default constructed values
-  tuple() : tuple(Ts{}...) {}
-
-  //! \brief Serialize the provided values
-  //! \param args... Values to be serialized
-  explicit tuple(const Ts &...args) { base_t::lay(detail::make_index_sequence<sizeof...(Ts)>{}, args...); }
-
-#if __cplusplus >= 201703L
-  //! \brief (C++17) Serialize the provided values
-  //!
-  //! \tparam Endianess, Signed_Mode Serialization parameters
-  //! \param values... Values to be serialized
-  explicit tuple(endianess_h<Endianess>, signed_mode_h<Signed_Mode>, const Ts &...values) : tuple(values...) {}
-#endif // __cplusplus >= 201703L
-
-  //! \brief Beginning of the internal storage
-  byte_t *begin() { return m_storage; }
-
-  //! \copydoc begin()
-  const byte_t *begin() const { return m_storage; }
-
-  //! \brief End of the internal storage
-  byte_t *end() { return m_storage + base_t::size; }
-
-  //! \copydoc end()
-  const byte_t *end() const { return m_storage + base_t::size; }
-
-  //! \brief Access the object content
-  //!
-  //! \warning There is no bound check performed.
-  //!
-  //! \param i Index of the accessed byte
-  byte_t &operator[](std::size_t i) { return m_storage[i]; }
-
-  //! \brief Access the object content
-  //!
-  //! \warning There is no bound check performed.
-  //!
-  //! \param i Index of the accessed byte
-  const byte_t &operator[](std::size_t i) const { return m_storage[i]; }
-
-  //! \copydoc begin()
-  byte_t *src() { return begin(); }
-
-  //! \copydoc begin()
-  const byte_t *src() const { return begin(); }
-
-  //! \brief Make a view out of a subset of the tuple
-  //! \tparam I First element in the view
-  //! \tparam L Number of elements in the view
-  //! \return a \ref<tuple_view> tuple_view instance including every elements in the given range
-#if defined(DOXYGEN)
-  template<std::size_t I, std::size_t L>
-  auto view()
-#else  // defined(DOXYGEN)
-  template<std::size_t I, std::size_t L>
-  decltype(detail::make_view_from_typelist<Endianess, Signed_Mode>((byte_t *)nullptr, detail::clip<types_t, I, L>{}))
-  view()
-#endif // defined(DOXYGEN)
-  {
-    using detail::clip;
-    using detail::sum;
-
-    constexpr auto offset = sum<clip<sizes_t, 0, I>>::value;
-
-    return detail::make_view_from_typelist<Endianess, Signed_Mode>(begin() + offset, clip<types_t, I, L>{});
-  }
-
-  //! \copydoc view
-#if defined(DOXYGEN)
-  template<std::size_t I, std::size_t L>
-  auto view() const
-#else  // defined(DOXYGEN)
-  template<std::size_t I, std::size_t L>
-  decltype(detail::make_view_from_typelist<Endianess, Signed_Mode>((const byte_t *)nullptr,
-                                                                   detail::clip<types_t, I, L>{}))
-  view() const
-#endif // defined(DOXYGEN)
-  {
-    using detail::clip;
-    using detail::sum;
-    constexpr auto offset = sum<clip<sizes_t, 0, I>>::value;
-    return detail::make_view_from_typelist<Endianess, Signed_Mode>(begin() + offset, clip<types_t, I, L>{});
+  template<std::size_t I>
+  using raw_type = typename leaves::template raw_type<I>::type;
+
+  template<typename Tuple>
+  [[nodiscard]] constexpr static auto normalize(Tuple &&tuple) {
+    return fittest_tuple_like(UPD_FWD(tuple));
   }
 
+  constexpr typelist() noexcept = default;
+
 private:
-  upd::byte_t m_storage[base_t::size];
+  leaves m_leaves;
 };
 
-template<endianess Endianess, signed_mode Signed_Mode>
-class tuple<Endianess, Signed_Mode> : public detail::tuple_base<tuple<Endianess, Signed_Mode>, Endianess, Signed_Mode> {
+template<auto... Vs>
+class constlist : public tuple_implementation<constlist<Vs...>> {
+  template<std::size_t, typename Tuple>
+  friend constexpr auto get(Tuple &&) noexcept -> auto &&;
+
+  using leaves = detail::leaves<std::make_index_sequence<sizeof...(Vs)>, auto_constant<Vs>...>;
+
 public:
-  constexpr byte_t *begin() const { return nullptr; }
-  constexpr byte_t *end() const { return nullptr; }
-  constexpr byte_t *src() const { return begin(); }
+  template<std::size_t I>
+  using raw_type = typename leaves::template raw_type<I>;
+
+  template<typename Tuple>
+  [[nodiscard]] constexpr static auto normalize(Tuple &&tuple) {
+    return fittest_tuple_like(UPD_FWD(tuple));
+  }
+
+  constexpr constlist() noexcept = default;
+
+private:
+  leaves m_leaves;
 };
 
-//! \brief Construct a \ref<tuple> tuple instance from provided values
-//! \tparam Endianess, Signed_Mode Serialization parameters
-//! \param args... Values to be serialized into the return value
-//! \return a \ref<tuple> tuple instance initialized from `args...`
-//! \related tuple
-template<endianess Endianess, signed_mode Signed_Mode, typename... Args>
-tuple<Endianess, Signed_Mode, Args...>
-make_tuple(endianess_h<Endianess>, signed_mode_h<Signed_Mode>, const Args &...args) {
-  return tuple<Endianess, Signed_Mode, Args...>{args...};
+template<typename... Ts>
+[[nodiscard]] constexpr auto fittest_tuple_like(Ts &&...xs) {
+  if constexpr ((detail::is_instance_of_v<std::decay_t<Ts>, typebox> && ...)) {
+    return typelist<typename std::decay_t<Ts>::type...>{};
+  } else if constexpr ((is_auto_constant_v<Ts> && ...)) {
+    return constlist<xs.value...>{};
+  } else {
+    return tuple{UPD_FWD(xs)...};
+  }
 }
 
-//! \brief Construct a \ref<tuple> tuple instance holding default values
-//! \tparam Args... Types of the values held by the tuple
-//! \tparam Endianess, Signed_Mode Serialization parameters
-//! \related tuple
-template<typename... Args, endianess Endianess, signed_mode Signed_Mode>
-tuple<Endianess, Signed_Mode, Args...> make_tuple(endianess_h<Endianess>, signed_mode_h<Signed_Mode>) {
-  return tuple<Endianess, Signed_Mode, Args...>{};
+template<typename... Ts, typename... Us>
+[[nodiscard]] constexpr auto operator+(tuple<Ts...> lhs, tuple<Us...> rhs) noexcept -> tuple<Ts..., Us...> {
+  auto impl = [&](auto i) {
+    auto lhs_size = auto_constant<sizeof...(Ts)>{};
+
+    if constexpr (i < sizeof...(Ts)) {
+      return std::move(lhs[i]);
+    } else {
+      return std::move(rhs[i - lhs_size]);
+    }
+  };
+
+  return sequence<sizeof...(Ts) + sizeof...(Us)>.transform(impl);
 }
 
-} // namespace upd
+template<std::size_t I, typename Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&tuple) noexcept -> auto && {
+  auto &&retval = UPD_FWD(tuple).m_leaves.at(auto_constant<I>{});
 
-template<upd::endianess Endianess, upd::signed_mode Signed_Mode, typename... Ts>
-struct std::tuple_size<upd::tuple<Endianess, Signed_Mode, Ts...>> {
-  constexpr static auto value = sizeof...(Ts);
-};
+  using retval_type = decltype(retval);
+  static_assert(!std::is_same_v<retval_type, detail::variadic::not_found_t &&>, "`I` is not a valid index for `tuple`");
 
-template<std::size_t I, upd::endianess Endianess, upd::signed_mode Signed_Mode, typename... Ts>
-struct std::tuple_element<I, upd::tuple<Endianess, Signed_Mode, Ts...>> {
-  using type = decltype(std::declval<upd::tuple<Endianess, Signed_Mode, Ts...>>().template get<I>());
-};
+  return retval;
+}
 
-template<typename It, upd::endianess Endianess, upd::signed_mode Signed_Mode, typename... Ts>
-struct std::tuple_size<upd::tuple_view<It, Endianess, Signed_Mode, Ts...>> {
-  constexpr static auto value = sizeof...(Ts);
-};
+template<typename Tuple, typename F, typename Aggregator>
+[[nodiscard]] constexpr auto transform_and_apply(Tuple &&t, F &&f, Aggregator &&agg) {
+  constexpr auto size = std::tuple_size_v<std::remove_reference_t<Tuple>>;
+  constexpr auto seq = std::make_index_sequence<size>{};
 
-template<std::size_t I, typename It, upd::endianess Endianess, upd::signed_mode Signed_Mode, typename... Ts>
-struct std::tuple_element<I, upd::tuple_view<It, Endianess, Signed_Mode, Ts...>> {
-  using type = decltype(std::declval<upd::tuple<Endianess, Signed_Mode, Ts...>>().template get<I>());
-};
+  auto invoke_f_once = [&](auto i) -> decltype(auto) { return f(get<i>(UPD_FWD(t))); };
+
+  auto invoke_f_on_each = [&](auto... is) -> decltype(auto) { return UPD_FWD(agg)(invoke_f_once(is)...); };
+
+  return detail::apply_on_index_sequence(invoke_f_on_each, seq);
+}
+
+template<typename Tuple, typename F>
+[[nodiscard]] constexpr auto apply(Tuple &&t, F &&f) {
+  constexpr auto size = std::tuple_size_v<std::remove_reference_t<Tuple>>;
+  constexpr auto seq = std::make_index_sequence<size>{};
+
+  auto apply_f = [&](auto... is) -> decltype(auto) { return UPD_FWD(f)(get<is>(UPD_FWD(t))...); };
+
+  return detail::apply_on_index_sequence(apply_f, seq);
+}
+
+template<typename Tuple, typename F>
+constexpr void for_each(Tuple &&t, F &&f) {
+  auto impl = [&](auto &&...xs) { ((void)f(UPD_FWD(xs)), ...); };
+
+  apply(UPD_FWD(t), impl);
+}
+
+} // namespace upd
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 4a15fed..611fde6 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -101,7 +101,7 @@ add_custom_target(check_revamp COMMAND ctest -L check_revamp
                                        --output-on-failure)
 
 add_revamp_test(basic_tuple basic_tuple.cpp)
-add_revamp_test(basic_ibytestream basic_ibytestream.cpp)
+# add_revamp_test(basic_ibytestream basic_ibytestream.cpp)
 add_revamp_test(basic_obytestream basic_obytestream.cpp)
 add_revamp_test(detail_variadic_clean detail/variadic/clean.cpp)
 add_revamp_test(detail_variadic_clip detail/variadic/clip.cpp)
diff --git a/test/basic_ibytestream.cpp b/test/basic_ibytestream.cpp
index e708f5d..52545c5 100644
--- a/test/basic_ibytestream.cpp
+++ b/test/basic_ibytestream.cpp
@@ -63,9 +63,8 @@ TEST_CASE("Deserializing a packet...") {
     using namespace upd::literals;
     using namespace upd::descriptor;
 
-    auto descr =
-        field<"a"_h>(upd::signed_int, upd::width<16>) | field<"b"_h>(upd::unsigned_int, upd::width<8>) |
-        field<"c"_h>(upd::unsigned_int, upd::width<16>) | field<"d"_h>(upd::signed_int, upd::width<8>);
+    auto descr = field<"a"_h>(upd::signed_int, upd::width<16>) | field<"b"_h>(upd::unsigned_int, upd::width<8>) |
+                 field<"c"_h>(upd::unsigned_int, upd::width<16>) | field<"d"_h>(upd::signed_int, upd::width<8>);
     auto signed_value = std::array{-64, 1};
     auto unsigned_value = std::array{48, 16};
 
diff --git a/test/integer.cpp b/test/integer.cpp
index 9ca34c9..6ccc7a0 100644
--- a/test/integer.cpp
+++ b/test/integer.cpp
@@ -13,9 +13,7 @@ using namespace fakeit;
 
 template<typename Bitsize, typename Underlying>
 struct Catch::StringMaker<upd::extended_integer<Bitsize, Underlying>> {
-    constexpr static auto convert = [](auto xn) {
-      return std::to_string(xn.value());
-    };
+  constexpr static auto convert = [](auto xn) { return std::to_string(xn.value()); };
 };
 
 // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
@@ -27,13 +25,12 @@ TEST_CASE("Decompose an extended integer") {
   using byte16 = upd::xinteger<10, std::uint16_t>;
   using byte32 = upd::xinteger<2, std::uint32_t>;
 
-  auto x = upd::xinteger_fit<std::uint32_t>{0b1011'0000'1001'1100'0111}
-    .resize(upd::width<20>)
-    .value();
+  auto x = upd::xinteger_fit<std::uint32_t>{0b1011'0000'1001'1100'0111}.resize(upd::width<20>).value();
 
   REQUIRE(upd::decompose_into_xuint<byte8>(x) == std::array<byte8, 4>{0b00111, 0b01110, 0b00010, 0b10110});
   REQUIRE(upd::decompose_into_xuint<byte16>(x) == std::array<byte16, 2>{0b0111000111, 0b1011000010});
-  REQUIRE(upd::decompose_into_xuint<byte32>(x) == std::array<byte32, 10>{0b11, 0b01, 0b00, 0b11, 0b01, 0b10, 0b00, 0b00, 0b11, 0b10});
+  REQUIRE(upd::decompose_into_xuint<byte32>(x) ==
+          std::array<byte32, 10>{0b11, 0b01, 0b00, 0b11, 0b01, 0b10, 0b00, 0b00, 0b11, 0b10});
 }
 
 TEST_CASE("Recompose an extended integer") {