diff --git a/example/dynamixel-protocol-2.0.cpp b/example/dynamixel-protocol-2.0.cpp
index 6141e81..39cc10f 100644
--- a/example/dynamixel-protocol-2.0.cpp
+++ b/example/dynamixel-protocol-2.0.cpp
@@ -159,14 +159,8 @@ int main() {
   auto oit = std::ostream_iterator<std::byte>{std::cout, " "};
   std::cout << std::hex;
 
-  auto ping_ex1 = description.instantiate(ser,
-      "id"_kw = 1, "length"_kw = 3, "instruction"_kw = 1);
-  if (!ping_ex1) {
-    return (int)ping_ex1.error();
-  }
-
   std::printf("Ping: example 1\n");
-  ping_ex1->serialize(ser, oit);
+  description.encode(("id"_kw = 1, "length"_kw = 3, "instruction"_kw = 1), ser, oit);
   std::printf("\n\n");
 
   auto answer1_seq = bytearray{0xff, 0xff, 0xfd, 0x00, 0x01, 0x07, 0x00, 0x55, 0x00, 0x06, 0x04, 0x26, 0x65, 0x5d};
diff --git a/include/upd/constexpr.hpp b/include/upd/constexpr.hpp
index 28f4512..ee01b66 100644
--- a/include/upd/constexpr.hpp
+++ b/include/upd/constexpr.hpp
@@ -25,7 +25,7 @@ struct auto_constant {
 
   constexpr static auto value = Value;
 
-  template<typename T>
+  template<typename T> requires std::convertible_to<value_type, T>
   [[nodiscard]] constexpr operator T() const {
     return static_cast<T>(value);
   }
diff --git a/include/upd/description.hpp b/include/upd/description.hpp
index 816389d..a28fb78 100644
--- a/include/upd/description.hpp
+++ b/include/upd/description.hpp
@@ -7,6 +7,8 @@
 #include <tuple>
 #include <type_traits>
 #include <variant>
+#include <expected>
+#include <iterator>
 
 #include "detail/always_false.hpp"
 #include "detail/has_value_member.hpp"
@@ -22,19 +24,16 @@
 #include "tuple.hpp"
 #include "upd.hpp"
 
-namespace upd::descriptor {
-
-template<name, bool, std::size_t>
-struct field_t;
-
-template<name, std::size_t>
-struct constant_t;
-
-} // namespace upd::descriptor
+#define UPD_WELL_FORMED(...) \
+  do { \
+    if (requires { __VA_ARGS__; }) { \
+      __VA_ARGS__; \
+    } \
+  } while (false)
 
 namespace upd::detail {
 
-template<typename Iter>
+template<std::input_or_output_iterator Iter>
 class iterator_reference {
 public:
   using iterator_type = Iter;
@@ -58,10 +57,12 @@ class iterator_reference {
     return *this;
   }
 
-  constexpr auto operator++() const -> const iterator_reference & {
+  constexpr auto operator++(int) -> iterator_reference {
+    auto retval = *this;
     m_cache = *m_iter;
     ++m_iter.get();
-    return *this;
+    
+    return retval;
   }
 
 private:
@@ -73,6 +74,99 @@ class iterator_reference {
 
 namespace upd {
 
+struct no_error {};
+
+struct not_matching_deduction {
+  const char *identifier;
+};
+
+using error_data_types = typelist<
+  no_error,
+  not_matching_deduction
+>;
+
+template<typename T>
+concept variadic_instance = requires(T x) {
+  []<template<typename ...> typename TT, typename ...Ts>(const TT<Ts...> &) {} (x);
+};
+
+template<typename T>
+using is_variadic_instance = auto_constant<variadic_instance<T>>;
+
+template<typename T>
+concept value_variadic_instance = requires(T x) {
+  []<template<auto ...> typename TT, auto ...Values>(const TT<Values...> &) {} (x);
+};
+
+template<typename T>
+using is_value_variadic_instance = auto_constant<value_variadic_instance<T>>;
+
+template<typename T, typename Variadic>
+concept element_of = variadic_instance<Variadic>
+&& instantiate_variadic<detail::lite_tuple, Variadic>::has_type(typebox<T>{});
+
+template<typename T, variadic_instance Variadic>
+using is_element_of = auto_constant<element_of<T, Variadic>>;
+
+template<auto Value, typename Variadic>
+concept value_element_of = value_variadic_instance<Variadic>
+&& instantiate_variadic<detail::lite_tuple, Variadic>::has_type(expr<Value>);
+
+template<auto Value, value_variadic_instance Variadic>
+using is_value_element_of = auto_constant<value_element_of<Value, Variadic>>;
+
+template<typename T>
+concept error_data = element_of<std::remove_cvref_t<T>, error_data_types>;
+
+class error {
+  using data_type = instantiate_variadic<std::variant, error_data_types>;
+
+  public:
+    constexpr error() noexcept(release) = default;
+    constexpr error(const error&) noexcept(release) = default;
+    constexpr error(error&&) noexcept(release) = default;
+
+    template<error_data ErrorData>
+    constexpr error(ErrorData &&err_data) noexcept(release) : m_data{UPD_FWD(err_data)} {}
+
+    constexpr auto operator=(const error&) noexcept(release) -> error & = default;
+    constexpr auto operator=(error&&) noexcept(release) -> error & = default;
+
+    template<error_data ErrorData>
+    constexpr auto operator=(ErrorData &&err_data) noexcept(release) -> error& {
+      m_data = UPD_FWD(err_data);
+      return *this;
+    }
+
+    [[nodiscard]] constexpr operator bool() const noexcept(release) {
+      return !std::holds_alternative<no_error>(m_data);
+    }
+
+  private:
+    data_type m_data;
+};
+
+template<typename T>
+using result = std::expected<T, error>;
+
+template<typename T>
+[[nodiscard]] constexpr auto result_if_no_error(T &&x, const error &err) -> result<std::remove_cvref_t<T>> {
+  if (err) {
+    return std::unexpected{err};
+  } else {
+    return UPD_FWD(x);
+  }
+}
+
+template<typename T>
+[[nodiscard]] constexpr auto result_if_no_error(T &&x, error &&err) -> result<std::remove_cvref_t<T>> {
+  if (err) {
+    return std::unexpected{std::move(err)};
+  } else {
+    return UPD_FWD(x);
+  }
+}
+
 template<typename>
 class invoker_iterator;
 
@@ -160,98 +254,6 @@ class transformer_iterator {
   F m_f;
 };
 
-enum class error {
-  none,
-  checksum_mismatch,
-  constant_mismatch,
-};
-
-template<typename E = error>
-class unexpected {
-public:
-  constexpr unexpected() noexcept = default;
-
-  constexpr unexpected(E e) noexcept : m_error{std::move(e)} {}
-
-  [[nodiscard]] constexpr operator bool() const noexcept { return static_cast<bool>(m_error); }
-
-  [[nodiscard]] constexpr auto error() const noexcept -> E { return m_error; }
-
-private:
-  E m_error;
-};
-
-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; }
-
-  [[nodiscard]] constexpr auto operator*() noexcept -> T & { return value(); }
-
-  [[nodiscard]] constexpr auto operator*() const noexcept -> const T & { return value(); }
-
-  [[nodiscard]] constexpr auto operator->() noexcept -> T * { return &value(); }
-
-  [[nodiscard]] constexpr auto operator->() const noexcept -> const T * { return &value(); }
-
-  [[nodiscard]] constexpr auto value() & noexcept(release) -> T & {
-    auto *v = value_if();
-    UPD_ASSERT(v != nullptr);
-
-    return *v;
-  }
-
-  [[nodiscard]] constexpr auto value() const & noexcept(release) -> const T & {
-    const auto *v = value_if();
-    UPD_ASSERT(v != nullptr);
-
-    return *v;
-  }
-
-  [[nodiscard]] constexpr auto value() && noexcept(release) -> T && {
-    auto *v = value_if();
-    UPD_ASSERT(v != nullptr);
-
-    return std::move(*v);
-  }
-
-  [[nodiscard]] constexpr auto error() & noexcept(release) -> E & {
-    auto *e = error_if();
-    UPD_ASSERT(e != nullptr);
-
-    return *e;
-  }
-
-  [[nodiscard]] constexpr auto error() const & noexcept(release) -> const E & {
-    const auto *e = error_if();
-    UPD_ASSERT(e != nullptr);
-
-    return *e;
-  }
-
-  [[nodiscard]] constexpr auto error() && noexcept(release) -> 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() 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() const noexcept -> const E * { return std::get_if<1>(&m_value_or_error); }
-
-private:
-  std::variant<T, E> m_value_or_error;
-};
-
 } // namespace upd
 
 namespace upd::descriptor {
@@ -290,165 +292,120 @@ enum class field_tag {
   checksum,
 };
 
-template<typename... Ts>
-class description {
-  template<typename... Ts_, typename... Us>
-  friend constexpr auto operator|(description<Ts_...> lhs, description<Us...> rhs) noexcept;
+template<named_value_instance ...NamedValues>
+using named_value_bundle = decltype(named_tuple{std::declval<NamedValues>()...});
+
+template<typename T>
+concept field_like = requires(T) {
+  typename T::value_type;
+} && requires(T x) {
+  { x.default_value() } -> std::same_as<typename T::value_type>;
+  { x.deduce(named_tuple{}) } -> std::same_as<typename T::value_type>;
+};
 
-  template<name, bool Is_Signed, std::size_t Width>
-  friend constexpr auto descriptor::field(signedness_t<Is_Signed>, width_t<Width>) noexcept(release);
+template<typename T, typename Serializer>
+concept decodable_field = field_like<T>
+&& serializer<Serializer>
+&& requires(
+    T x,
+    Serializer ser,
+    const byte_type<Serializer> *src) {
+  { x.decode(src, ser) } -> std::same_as<typename T::value_type>;
+};
 
-  template<name, typename T, std::size_t Width>
-  friend constexpr auto descriptor::constant(T, width_t<Width>) noexcept(release);
+template<typename T, typename Serializer>
+concept encodable_field = field_like<T>
+&& serializer<Serializer>
+&& requires(
+    T x,
+    Serializer ser,
+    typename T::value_type value,
+    byte_type<Serializer> *dest) {
+  { x.encode(value, ser, dest) } -> std::same_as<void>;
+};
 
-  template<name, typename BinaryOp, std::size_t Width, typename Init>
-  friend constexpr auto descriptor::checksum(BinaryOp, width_t<Width>, Init, descriptor::all_fields_t) noexcept(release);
+template<field_like... Ts>
+class description {
+  template<typename... _Ts, typename... Us>
+  friend constexpr auto operator|(description<_Ts...> lhs, description<Us...> rhs) noexcept(release);
 
 public:
   constexpr static auto identifiers = typelist<Ts...>{}
-    .transform([](auto field_type) { return expr<field_type->identifier>; });
-
-  template<typename Serializer, named_value_instance... NamedValues>
-  [[nodiscard]] constexpr auto instantiate(Serializer &ser, NamedValues &&... nvs) const noexcept {
-    static_assert((requires { named_value{nvs}; } && ...),
-                  "`nvs` must be a pack of `named_value` instances");
-
-    auto named_args = named_tuple{UPD_FWD(nvs)...};
-    auto first_pass = [&](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[keyword<field.identifier>{}];
-        return keyword<field.identifier>{} = representation{value};
-      } else if constexpr (field.tag == field_tag::constant) {
-        return keyword<field.identifier>{} = field.value;
-      } else if constexpr (field.tag == field_tag::checksum) {
-        constexpr auto width = field.width;
-        return keyword<field.identifier>{} = xuint<width>{field.init};
-      } else {
-        static_assert(UPD_ALWAYS_FALSE, "`field` is not a field object");
-      }
-    };
-
-    auto make_named_tuple = [](auto &&...nvs) { return named_tuple{UPD_FWD(nvs)...}; };
-    auto retval = m_fields.transform(first_pass).apply(make_named_tuple);
-    auto second_pass = [&](const auto &field) {
-      if constexpr (field.tag == field_tag::checksum) {
-        constexpr auto identifier = field.identifier;
-        auto &[op, init, get_range] = field;
-        auto &acc = retval[keyword<identifier>{}];
-        auto folder = invoker_iterator{
-          [&, op=op](auto x) { acc = op(acc, x); }
-        };
-
-        get_range(identifiers).for_each([&](auto id) {
-          return retval[keyword<id.value>{}].serialize(ser, folder);
-        });
-      }
-    };
-
-    m_fields.for_each(second_pass);
-    return expected{std::move(retval)};
+    .transform([]<typename T>(typebox<T>) { return expr<T::identifier>; });
+
+  explicit constexpr description(Ts ...fields) : m_fields{std::move(fields)...} {}
+
+  template<named_tuple_instance NamedTuple, serializer Serializer, std::output_iterator<byte_type<Serializer>> OutputIt>
+  constexpr void encode(const NamedTuple &nargs, Serializer &ser, OutputIt dest) const {
+    auto packet = m_fields
+      .transform([&]<typename Field>(const Field &field) {
+        using value_type = typename Field::value_type;
+        auto id = expr<field.identifier>;
+        if constexpr (nargs.contains(id)) {
+          return keyword<field.identifier>{} = value_type{nargs[id]};
+        } else {
+          return keyword<field.identifier>{} = field.default_value();
+        }
+      })
+      .apply([](auto &&... field_values) { return named_tuple{UPD_FWD(field_values)...}; });
+
+    zip(packet, m_fields)
+      .for_each(unpack | [&](auto &field_value, const auto &field) {
+        UPD_WELL_FORMED(field_value.value() = field.deduce(std::as_const(packet)));
+      });
+
+    zip(packet, m_fields)
+      .for_each(unpack | [&](const auto &field_value, const auto &field) {
+        field.encode(field_value.value(), ser, dest);
+      });
   }
 
-  template<typename InputIt, typename Serializer>
-  [[nodiscard]] constexpr auto decode(InputIt src, Serializer &ser) const noexcept(release) {
-    auto err = unexpected{};
-    auto accumulators = m_fields
-      .filter([](const auto &field) { return expr<field.tag == field_tag::checksum>; })
-      .apply([](auto &&... checksum_fields) {
-          return named_tuple { (keyword<checksum_fields.identifier>{} = checksum_fields.init)...};
-        }
-      );
-
-    auto first_pass = [&](const auto &field) {
-      if constexpr (field.tag == field_tag::checksum) {
-        const auto &[op, init, get_range] = field;
-        auto &acc = accumulators[keyword<field.identifier>{}];
-        auto range = get_range(identifiers);
-        auto accumulate = [&, &op = op](auto identifier, const auto &value) {
-          auto position = range
-            .find_if(to_metafunction([=](auto id) { return id == identifier; }));
-
-          if constexpr (position < range.size()) {
-            acc = op(acc, value);
-          }
-        };
-
-        return accumulate;
-      }
-    };
-    
-    auto checksum_accs = m_fields.transform(first_pass, filter_void);
-    auto second_pass = [&](const auto &field) {
-      constexpr auto identifier = field.identifier;
-      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 decorated_src = transformer_iterator{
-          detail::iterator_reference{src},
-          [&](const auto &value) {
-            checksum_accs.for_each([&](auto acc) { acc(auto_constant<identifier>{}, value); });
-            return value;
-          }
-        };
-        return keyword<identifier>{} = deserialize_into_xinteger<representation>(decorated_src, ser);
-      } else if constexpr (field.tag == field_tag::constant) {
-        constexpr auto width = field.width;
-        using representation = std::conditional_t<field.is_signed, xint<width>, xuint<width>>;
-        auto decorated_src = transformer_iterator{
-          detail::iterator_reference{src},
-          [&](const auto &value) {
-            checksum_accs.for_each([&](auto acc) { acc(auto_constant<identifier>{}, value); });
-            return value;
-          }
-        };
-
-        auto received = deserialize_into_xinteger<representation>(decorated_src, ser);
-        if (!err && received != field.value) {
-          err = error::constant_mismatch;
-        }
-      } else if constexpr (field.tag == field_tag::checksum) {
-        constexpr auto width = field.width;
-        using representation = std::conditional_t<field.is_signed, xint<width>, xuint<width>>;
-        auto received = deserialize_into_xinteger<representation>(detail::iterator_reference{src}, ser);
-        if (!err && accumulators[keyword<identifier>{}] != received) {
-          err = error::checksum_mismatch;
+  template<serializer Serializer, std::input_iterator InputIt>
+  [[nodiscard]] constexpr auto decode(InputIt src, Serializer &ser) const {
+    auto err = error{};
+    auto retval = m_fields
+      .apply([](const auto & ...fields) {
+          return named_tuple { (keyword<fields.identifier>{} = fields.default_value())... };
+      });
+
+    m_fields
+      .for_each([&](const auto &field) {
+        retval[expr<field.identifier>] = field.decode(detail::iterator_reference{src}, ser);
+      });
+
+    zip(retval, m_fields)
+      .for_each(unpack | [&](const auto &field_value, const auto &field) {
+        if (!err && field_value.value() == field.deduce(retval)) {
+          err = not_matching_deduction{field_value.identifier.string};
         }
-      } else {
-        static_assert(UPD_ALWAYS_FALSE, "`field.tag` is not a valid `field_tag` enumerator");
-      }
-    };
+      });
 
-    auto retval = m_fields
-      .transform(second_pass, filter_void)
-      .apply([](auto &&... nvs) { return named_tuple{UPD_FWD(nvs)...}; });
-    return err ? err : expected{std::move(retval)};
+    return result_if_no_error(std::move(retval), std::move(err));
   }
 
 private:
-  explicit constexpr description(tuple<Ts...> fields) : m_fields{std::move(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::move(lhs.m_fields) + std::move(rhs.m_fields);
+[[nodiscard]] constexpr auto operator|(description<Ts...> lhs, description<Us...> rhs) noexcept(release) {
+  auto concatenated_fields = std::move(lhs.m_fields) + std::move(rhs.m_fields);
 
   // 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
+  auto self_comparison_count = concatenated_fields
     .type_only()
     .transform([]<typename T>(typebox<T>) { return expr<T::identifier>; })
     .square()
     .transform(unpack | equal_to)
     .fold_left(expr<0uz>, plus);
 
-  static_assert(self_comparison_count == fields.size(), "Merging these descriptions would result in duplicate IDs");
+  static_assert(self_comparison_count == concatenated_fields.size(), "Merging these descriptions would result in duplicate IDs");
 
-  return description{std::move(fields)};
+  return std::move(concatenated_fields).apply(
+    [](auto && ...fields) { return description{std::move(fields)...}; }
+  );
 }
 
 } // namespace upd
@@ -457,53 +414,130 @@ namespace upd::descriptor {
 
 template<name Identifier, bool Signedness, std::size_t Width>
 struct field_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;
+
+  using value_type = std::conditional_t<is_signed, xint<width>, xuint<width>>;
+
+  [[nodiscard]] constexpr static auto default_value() noexcept(release) -> value_type {
+    return value_type{};
+  }
+
+  template<named_tuple_like Packet>
+  [[nodiscard]] constexpr static auto deduce(const Packet &packet) -> value_type {
+    return packet.at(expr<identifier>);
+  }
+
+  template<serializer Serializer, std::input_iterator InputIt>
+  [[nodiscard]] constexpr static auto decode(InputIt src, Serializer &ser) -> value_type {
+    if constexpr (is_signed) {
+      return ser.deserialize_signed(src, upd::width<width>);
+    } else {
+      return ser.deserialize_unsigned(src, upd::width<width>);
+    }
+  }
+
+  template<serializer Serializer, std::output_iterator<byte_type<Serializer>> OutputIt>
+  constexpr static void encode(value_type value, Serializer &ser, OutputIt dest) {
+    if constexpr (is_signed) {
+      return ser.serialize_signed(value, dest);
+    } else {
+      return ser.serialize_unsigned(value, dest);
+    }
+  }
 };
 
 template<name 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}};
+  field_like auto retval = field_t<Identifier, Signedness, Width>{};
+
+  return description{retval};
 }
 
 template<name 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;
+  using value_type = xuint<width>;
+
+  value_type field_value;
+
+  [[nodiscard]] constexpr auto default_value() const noexcept(release) -> value_type {
+    return field_value;
+  }
+
+  template<named_tuple_like Packet>
+  [[nodiscard]] constexpr static auto deduce(const Packet &packet) -> value_type {
+    return packet.at(expr<identifier>);
+  }
+
+  template<serializer Serializer, std::input_iterator InputIt>
+  [[nodiscard]] constexpr static auto decode(InputIt src, Serializer &ser) -> value_type {
+    return ser.deserialize_unsigned(src, upd::width<width>);
+  }
+
+  template<serializer Serializer, std::output_iterator<byte_type<Serializer>> OutputIt>
+  constexpr static void encode(value_type value, Serializer &ser, OutputIt dest) {
+    return ser.serialize_unsigned(value, dest);
+  }
 };
 
 template<name Identifier, typename T, std::size_t Width>
 [[nodiscard]] constexpr auto constant(T n, width_t<Width>) noexcept(release) {
   auto retval = constant_t<Identifier, Width>{n};
-  return description{tuple{retval}};
+  return description{retval};
 }
 
-template<name Identifier, typename BinaryOp, std::size_t Width, typename Init, typename GetRange>
+template<name Identifier, typename BinaryOp, std::size_t Width, typename Init, typename FieldFilter>
 struct checksum_t {
-  constexpr static auto tag = field_tag::checksum;
   constexpr static auto identifier = Identifier;
-  constexpr static auto is_signed = false;
   constexpr static auto width = Width;
 
+  using value_type = xuint<width>;
+
   BinaryOp op;
   Init init;
-  GetRange get_range;
+  FieldFilter identifier_filter;
+
+  [[nodiscard]] constexpr static auto default_value() noexcept(release) -> value_type {
+    return 0u;
+  }
+
+  template<named_tuple_like Packet>
+  [[nodiscard]] constexpr auto deduce(const Packet &packet) const -> value_type {
+    auto field_filter = [&](const auto &nv) {
+      return UPD_INVOKE(identifier_filter, expr<nv.identifier>);
+    };
+
+    return packet
+      .filter(field_filter)
+      .transform([](const auto &named_field) -> const auto & { return named_field.value(); })
+      .fold_left(init, op);
+  }
+
+  template<serializer Serializer, std::input_iterator InputIt>
+  [[nodiscard]] constexpr static auto decode(InputIt src, Serializer &ser) -> value_type {
+    return ser.deserialize_unsigned(src, upd::width<width>);
+  }
+
+  template<serializer Serializer, std::output_iterator<byte_type<Serializer>> OutputIt>
+  constexpr static void encode(value_type value, Serializer &ser, OutputIt dest) {
+    return ser.serialize_unsigned(value, dest);
+  }
 };
 
 template<name Identifier, typename BinaryOp, std::size_t Width, typename Init>
 [[nodiscard]] constexpr auto checksum(BinaryOp op, width_t<Width>, Init init, all_fields_t) noexcept(release) {
-  auto get_range = [](auto identifiers) { return identifiers.filter([](auto id) { return auto_constant<id != Identifier>{}; }); };
+  auto is_not_this_field = [](auto id) {
+    return expr<id != Identifier>;
+  };
+
   auto retval = checksum_t<Identifier, BinaryOp, Width,
-       Init, decltype(get_range)>{std::move(op), init, get_range};
+       Init, decltype(is_not_this_field)>{std::move(op), init, is_not_this_field};
   
-  return description{tuple{retval}};
+  return description{std::move(retval)};
 }
 
 } // namespace upd::descriptor
diff --git a/include/upd/named_value.hpp b/include/upd/named_value.hpp
index d210794..2613c44 100644
--- a/include/upd/named_value.hpp
+++ b/include/upd/named_value.hpp
@@ -71,6 +71,11 @@ struct name {
   char string[name_max_size];
 };
 
+template<name Identifier, typename Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&t) noexcept(release) -> auto && {
+  return UPD_FWD(t).template get<Identifier, Tuple>();
+}
+
 template<name>
 struct keyword;
 
@@ -80,6 +85,8 @@ struct keyword;
 
 template<std::size_t N>
 struct names {
+  constexpr static auto size = N;
+
   template<std::convertible_to<std::string_view>... Strings> requires (sizeof...(Strings) == N)
   consteval names(Strings... strs) noexcept(release): strings{} {
     using namespace std::ranges;
@@ -93,6 +100,28 @@ struct names {
 template<std::convertible_to<std::string_view>... Strings>
 names(Strings...) -> names<sizeof...(Strings)>;
 
+template<names... NameLists>
+concept unique_names = sizeof...(NameLists) > 0 && [] {
+  namespace stdr = std::ranges;
+
+  auto to_sv_array = [](auto &name_list) {
+    auto sv_array = std::array<std::string_view, name_list.size>{};
+    auto last = stdr::copy(name_list.strings, sv_array.begin());
+
+    UPD_CONSTEXPR_ASSERT(last.out == sv_array.end());
+
+    return sv_array;
+  };
+
+  auto joined_names = tuple{ref{NameLists}...}
+    .transform(to_sv_array)
+    .flatten()
+    .apply([](auto... name_views) { return std::array{name_views...}; });
+
+  stdr::sort(joined_names);
+  return stdr::adjacent_find(joined_names) == joined_names.end();
+}();
+
 template<name Identifier, typename T>
 class named_value {
 public:
@@ -153,8 +182,8 @@ template<typename... Named_Tuple_Ts>
 [[nodiscard]] constexpr auto concat_named_tuple(Named_Tuple_Ts &&...);
 
 template<names Identifiers, typename... Ts>
-requires (std::size(Identifiers.strings) == sizeof...(Ts))
-class named_tuple {
+requires (Identifiers.size == sizeof...(Ts))
+class named_tuple : public tuple_implementation<named_tuple<Identifiers, Ts...>> {
   constexpr static auto element_types = zip(sequence<sizeof...(Ts)>, typelist<Ts...>{})
     .transform(unpack | []<typename T>(auto i, typebox<T>) {
         using type = named_value<Identifiers.strings[i.value], T>;
@@ -165,40 +194,68 @@ class named_tuple {
   using content_type = instantiate_variadic<tuple, std::remove_cvref_t<decltype(element_types)>>;
 
 public:
+  constexpr static auto identifiers = sequence<Identifiers.size>
+    .transform([](auto i) {
+        return expr<name{Identifiers.strings[i.value]}>;
+    })
+    .to_constlist();
+
+  template<typename... Us, typename... Args>
+  [[nodiscard]] constexpr static auto make_tuple(typelist<Us...>, Args &&... xs) {
+    return tuple<Us...>{UPD_FWD(xs)...};
+  }
+
+  template<typename... Us>
+  [[nodiscard]] constexpr static auto make_typelist(typelist<Us...>) noexcept(release) {
+    return typelist<Us...>{};
+  }
+
+  template<auto... Values>
+  [[nodiscard]] constexpr static auto make_constlist(constlist<Values...>) noexcept(release) {
+    return constlist<Values...>{};
+  }
+
+  constexpr named_tuple() requires (sizeof...(Ts) == 0) = default;
+
   template<named_value_instance... NamedValues> requires (sizeof...(NamedValues) == sizeof...(Ts))
   constexpr explicit named_tuple(NamedValues && ...nvs): m_nvs{UPD_FWD(nvs)...} {}
 
-  template<name Identifier>
-  [[nodiscard]] constexpr auto get() & noexcept -> auto && {
-    auto position = m_nvs.find_if([](const auto &nv) {
+  template<name Identifier, typename Self> requires (identifiers.find(expr<Identifier>) < identifiers.size())
+  [[nodiscard]] constexpr auto get(this Self &&self) noexcept(release) -> auto && {
+    auto position = self.m_nvs.find_if([](const auto &nv) {
       return expr<nv.identifier == Identifier>;
     });
 
-    if constexpr (position < m_nvs.size()) {
-      return m_nvs.at(position).value();
+    if constexpr (position < self.m_nvs.size()) {
+      return UPD_FWD(self).m_nvs.at(position).value();
     } else {
       static_assert(UPD_ALWAYS_FALSE, "There are no element named `Identifier`");
     }
   }
 
-  template<name Identifier>
-  [[nodiscard]] constexpr auto operator[](keyword<Identifier>) & noexcept(release) -> auto & {
-    return get<Identifier>();
+  template<std::size_t I, typename Self>
+  [[nodiscard]] constexpr auto get(this Self &&self) noexcept(release) -> auto && {
+    return UPD_FWD(self).m_nvs.at(expr<I>);
   }
 
-  template<name Identifier>
-  [[nodiscard]] constexpr auto operator[](keyword<Identifier>) const & noexcept(release) -> const auto & {
-    return get<Identifier>();
+  template<typename Self, name Identifier>
+  [[nodiscard]] constexpr auto operator[](this Self &&self, keyword<Identifier>) noexcept(release) -> auto && {
+    return UPD_FWD(self).template get<Identifier, Self>();
   }
 
-  template<name Identifier>
-  [[nodiscard]] constexpr auto operator[](keyword<Identifier>) && noexcept(release) -> auto && {
-    return std::move(*this).template get<Identifier>();
+  template<typename Self, name Identifier>
+  [[nodiscard]] constexpr auto operator[](this Self &&self, auto_constant<Identifier>) noexcept(release) -> auto && {
+    return UPD_FWD(self).template get<Identifier, Self>();
+  }
+
+  template<typename Self, std::size_t I>
+  [[nodiscard]] constexpr auto operator[](this Self &&self, auto_constant<I>) noexcept(release) -> auto && {
+    return UPD_FWD(self).template get<I, Self>();
   }
 
   template<name Identifier>
-  [[nodiscard]] constexpr auto operator[](keyword<Identifier>) const && noexcept(release) -> const auto && {
-    return std::move(*this).template get<Identifier>();
+  [[nodiscard]] constexpr static auto contains(auto_constant<Identifier>) noexcept(release) -> bool {
+    return !unique_names<Identifiers, names{Identifier}>;
   }
 
   template<serializer Serializer, std::output_iterator<byte_type<Serializer>> OutputIt>
@@ -211,6 +268,8 @@ class named_tuple {
   content_type m_nvs;
 };
 
+named_tuple() -> named_tuple<{}>;
+
 template<named_value_instance... NamedValues>
 explicit named_tuple(NamedValues...) -> named_tuple<{NamedValues::identifier...}, typename NamedValues::value_type...>;
 
@@ -219,10 +278,9 @@ concept named_tuple_instance = requires(T x) {
   { named_tuple{x} } -> std::same_as<T>;
 };
 
-
-template<named_tuple_instance... NamedTuples>
+template<named_tuple_like... NamedTuples>
 [[nodiscard]] constexpr auto concat(NamedTuples &&...nts) {
-  return tuple<NamedTuples &&...>{nts...}
+  return tuple<NamedTuples &&...>{UPD_FWD(nts)...}
     .flatten()
     .apply([](auto &&... nvs) { return named_tuple{UPD_FWD(nvs)...}; });
 }
@@ -250,6 +308,29 @@ struct keyword {
 
 } // namespace upd
 
+template<auto Names, typename ...Ts>
+struct std::tuple_size<upd::named_tuple<Names, Ts...>> {
+  constexpr static auto value = sizeof...(Ts);
+};
+
+template<std::size_t I, auto Names, typename... Ts>
+struct std::tuple_element<I, upd::named_tuple<Names, Ts...>> {
+  using type = upd::named_value<
+    upd::named_tuple_identifier_v<I, upd::named_tuple<Names, Ts...>>,
+    upd::named_tuple_element_t<I, upd::named_tuple<Names, Ts...>>
+  >;
+};
+
+template<std::size_t I, auto Names, typename... Ts>
+struct upd::named_tuple_element<I, upd::named_tuple<Names, Ts...>> {
+  using type = typename decltype(auto{upd::detail::lite_tuple<upd::typebox<Ts>...>{}.at(upd::expr<I>)})::type;
+};
+
+template<std::size_t I, auto Names, typename... Ts>
+struct upd::named_tuple_identifier<I, upd::named_tuple<Names, Ts...>> {
+  constexpr static auto value = upd::name{Names.strings[I]};
+};
+
 namespace upd::literals {
 
 template<name Identifier>
diff --git a/include/upd/tuple.hpp b/include/upd/tuple.hpp
index af7062c..ea73442 100644
--- a/include/upd/tuple.hpp
+++ b/include/upd/tuple.hpp
@@ -18,20 +18,32 @@
 #define UPD_CONSTEXPR_ASSERT(...) \
   (std::is_constant_evaluated() && (__VA_ARGS__) ? (void) 0 : throw)
 
+#define UPD_THIS_DEDUCTION_REQUIRES_WORKAROUND(...) \
+  static_assert(__VA_ARGS__)
+
+#define UPD_VARIADIC_CONSTRAINT_WORKAROUND(...) \
+  ((__VA_ARGS__) && ...)
+
+#define UPD_INVOKE(INVOCABLE, ...) ((INVOCABLE)(__VA_ARGS__))
+
 namespace upd::detail {
 
 template<std::size_t I, typename T>
-struct leaf {
+struct leaf{
   [[nodiscard]] constexpr auto at(auto_constant<I>) &noexcept -> T & { return value; }
 
   [[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>) &&noexcept -> T && { return UPD_FWD(value); }
 
-  [[nodiscard]] constexpr auto at(auto_constant<I>) const &&noexcept -> const T && { return std::move(value); }
+  [[nodiscard]] constexpr auto at(auto_constant<I>) const &&noexcept -> const T && { return UPD_FWD(value); }
 
   [[nodiscard]] constexpr static auto typebox_at(auto_constant<I>) noexcept -> typebox<T>;
 
+  [[nodiscard]] constexpr static auto has_type(typebox<T>) noexcept(release) -> bool {
+    return true;
+  }
+
   T value;
 };
 
@@ -42,9 +54,12 @@ 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...;
+  using leaf<Is, Ts>::has_type...;
 
   [[nodiscard]] constexpr auto typebox_at(...) const noexcept -> variadic::not_found_t { return variadic::not_found; }
 
+  [[nodiscard]] constexpr static auto has_type(...) noexcept(release) -> bool { return false; }
+
   template<std::size_t I>
   using raw_type = typename decltype(typebox_at(auto_constant<I>{}))::type;
 
@@ -113,16 +128,6 @@ struct reference_like<T, U&&> {
 template<typename T, typename U>
 using reference_like_t = typename reference_like<T, U>::type;
 
-template<std::size_t I, typename Tuple>
-[[nodiscard]] constexpr auto get(Tuple &&tuple) noexcept(release) -> auto && {
-  decltype(auto) retval = UPD_FWD(tuple).m_leaves.at(expr<I>);
-
-  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`");
-
-  return UPD_FWD(retval);
-}
-
 template<typename T, typename BinaryOp>
 class accumulable_t {
   template<typename _T, typename U, std::invocable<_T, U> _BinaryOp>
@@ -180,8 +185,9 @@ concept tuple_like = requires(std::remove_reference_t<T> x) {
   };
   return (has_tuple_element(auto_constant<Is>{}) && ...);
 } (std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{})
-&& []<std::size_t... Is>(std::index_sequence<Is...>) {
-  [[maybe_unused]] auto is_nth_gettable = [](auto i) {
+&&
+[]<std::size_t... Is>(std::index_sequence<Is...>) {
+  [[maybe_unused]] auto is_nth_gettable = []([[maybe_unused]] auto i) {
     return requires(T &&x) {
       { get<i>(UPD_FWD(x)) } -> std::same_as<
         transfert_reference_t<std::tuple_element_t<i, std::remove_reference_t<T>> &&, T &&>
@@ -189,7 +195,12 @@ concept tuple_like = requires(std::remove_reference_t<T> x) {
     };
   };
   return (is_nth_gettable(auto_constant<Is>{}) && ...);
-} (std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{});
+}(std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{});
+
+template<std::size_t I, typename Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&t) noexcept(release) -> auto && {
+  return UPD_FWD(t).template get<I, Tuple>();
+}
 
 template<std::size_t N>
 constexpr auto sequence = []<std::size_t... Is>(std::index_sequence<Is...>) {
@@ -251,6 +262,79 @@ concept constlist_like = tuple_like<T> && []<std::size_t... Is>(constlist<Is...>
   return (metavalue<std::tuple_element_t<Is, T>> && ...);
 }(sequence_for<T>);
 
+template<std::size_t, typename>
+struct named_tuple_element;
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_element<I, const Tuple> {
+  using type = const typename named_tuple_element<I, Tuple>::type;
+};
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_element<I, volatile Tuple> {
+  using type = volatile typename named_tuple_element<I, Tuple>::type;
+};
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_element<I, const volatile Tuple> {
+  using type = const volatile typename named_tuple_element<I, Tuple>::type;
+};
+
+template<std::size_t I, typename Tuple>
+using named_tuple_element_t = typename named_tuple_element<I, Tuple>::type;
+
+template<std::size_t, typename>
+struct named_tuple_identifier;
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_identifier<I, const Tuple> {
+  constexpr static auto value = named_tuple_identifier<I, Tuple>::value;
+};
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_identifier<I, volatile Tuple> {
+  constexpr static auto value = named_tuple_identifier<I, Tuple>::value;
+};
+
+template<std::size_t I, typename Tuple>
+struct named_tuple_identifier<I, const volatile Tuple> {
+  constexpr static auto value = named_tuple_identifier<I, Tuple>::value;
+};
+
+template<std::size_t I, typename Tuple>
+constexpr auto named_tuple_identifier_v = named_tuple_identifier<I, Tuple>::value;
+
+template<typename T>
+concept named_tuple_like = tuple_like<T>
+&& []<std::size_t... Is>(std::index_sequence<Is...>) {
+  [[maybe_unused]] auto has_tuple_identifier = [](auto i) {
+    return requires(std::remove_reference_t<T> x) {
+      named_tuple_identifier<i, decltype(x)>::value;
+    };
+  };
+  return (has_tuple_identifier(expr<Is>) && ...);
+} (std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{})
+&& []<std::size_t... Is>(std::index_sequence<Is...>) {
+  [[maybe_unused]] auto has_tuple_identifier = [](auto i) {
+    return requires(std::remove_reference_t<T> x) {
+      typename named_tuple_element<i, decltype(x)>::type;
+    };
+  };
+  return (has_tuple_identifier(expr<Is>) && ...);
+} (std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{})
+&& []<std::size_t... Is>(std::index_sequence<Is...>) {
+  [[maybe_unused]] auto is_nth_id_gettable = []([[maybe_unused]] auto i) {
+    using noref_type = std::remove_reference_t<T>;
+    [[maybe_unused]] constexpr auto identifier = named_tuple_identifier_v<i, noref_type>;
+    return requires(T &&x) {
+      { get<named_tuple_identifier_v<i, noref_type>>(UPD_FWD(x)) } -> std::same_as<
+        transfert_reference_t<named_tuple_element_t<i, noref_type> &&, T &&>
+      >;
+    };
+  };
+  return (is_nth_id_gettable(expr<Is>) && ...);
+}(std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>{});
+
 template<typename T>
 concept array_like = tuple_like<T>
 && std::tuple_size_v<T> > 0
@@ -362,12 +446,12 @@ class tuple_implementation {
 
   template<typename Self, metavalue I>
   [[nodiscard]] constexpr auto operator[](this Self &&self, I i) noexcept(release) -> auto && {
-    return get<i>(UPD_FWD(self).derived());
+    return UPD_FWD(self).at(i);
   }
 
   template<typename Self, metavalue I>
   [[nodiscard]] constexpr auto at(this Self &&self, I i) noexcept(release) -> auto && {
-    return get<i>(UPD_FWD(self).derived());
+    return UPD_FWD(self).derived().template get<i>();
   }
 
   template<typename T, typename Self>
@@ -417,10 +501,16 @@ class tuple_implementation {
     return transform(filter_one).clean(typebox<cleanme_t>{});
   }
 
+  template<auto Value> requires constlist_like<Derived>
+  [[nodiscard]] constexpr auto find(auto_constant<Value>) const {
+    return find_if([](const auto &x) { return expr<x.value == Value>; });
+  }
+
   template<const_predicate_on_each<Derived> UnaryPred> 
   [[nodiscard]] constexpr auto find_if(UnaryPred &&p) const {
     auto filtered = zip(sequence<size()>, derived())
-      .filter(unpack | [&](auto, const auto &x) { return std::invoke(p, x); });
+      .filter(unpack | [&](auto, const auto &x) { return std::invoke(p, x); })
+      .clone();
 
     if constexpr (filtered.size() > 0) {
       return filtered[expr<0uz>][expr<0uz>];
@@ -554,7 +644,7 @@ class tuple_implementation {
 
   template<typename Self, typename F>
   [[nodiscard]] constexpr auto transform(this Self &&self, F &&f) {
-    static_assert(transformer_on_each<F, Derived>);
+    UPD_THIS_DEDUCTION_REQUIRES_WORKAROUND(transformer_on_each<F, Derived>);
 
     auto invoke_f_at = [&](auto i) -> decltype(auto) {
       return f(UPD_FWD(self).at(i));
@@ -589,8 +679,9 @@ class tuple_implementation {
     return upd::type_only(derived());
   }
 
-  template<typename Self, applicable<Derived> F>
+  template<typename Self, typename F>
   [[nodiscard]] constexpr auto apply(this Self &&self, F &&f) -> decltype(auto) {
+    // UPD_THIS_DEDUCTION_REQUIRES_WORKAROUND(applicable<F, Derived>);
     auto seq = std::make_index_sequence<size()>{};
 
     return [&]<std::size_t ...Is>(std::index_sequence<Is...>) -> decltype(auto) {
@@ -603,7 +694,7 @@ class tuple_implementation {
     static_assert(invocable_on_each<F, Derived>);
 
     UPD_FWD(self).apply([&](auto &&... xs) {
-      ((void) std::invoke(f, UPD_FWD(xs)), ...);
+      ((void) UPD_INVOKE(f, UPD_FWD(xs)), ...);
     });
   }
 
@@ -614,9 +705,6 @@ class tuple_implementation {
 
 template<typename... Ts>
 class tuple : public tuple_implementation<tuple<Ts...>> {
-  template<std::size_t, typename Tuple>
-  friend constexpr auto get(Tuple &&) noexcept(release) -> auto &&;
-
   using leaves = detail::leaves<std::index_sequence_for<Ts...>, Ts...>;
 
 public:
@@ -641,6 +729,16 @@ class tuple : public tuple_implementation<tuple<Ts...>> {
   template<typename ...Us>
   constexpr explicit tuple(std::in_place_t, Us &&... xs): m_leaves{UPD_FWD(xs)...} {}
 
+  template<std::size_t I, typename Self>
+  [[nodiscard]] constexpr auto get(this Self &&self) noexcept(release) -> auto && {
+    decltype(auto) retval = UPD_FWD(self).m_leaves.at(expr<I>);
+
+    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`");
+
+    return UPD_FWD(retval);
+  }
+
 private:
   leaves m_leaves;
 };
@@ -657,9 +755,6 @@ explicit tuple(std::in_place_t, Ts...) -> tuple<
 
 template<typename... Ts>
 class typelist : public tuple_implementation<typelist<Ts...>> {
-  template<std::size_t, typename Tuple>
-  friend constexpr auto get(Tuple &&) noexcept(release) -> auto &&;
-
   using leaves = detail::leaves<std::index_sequence_for<Ts...>, typebox<Ts>...>;
 
 public:
@@ -683,6 +778,16 @@ class typelist : public tuple_implementation<typelist<Ts...>> {
   template<metatype... Metas>
   constexpr explicit typelist(Metas...) noexcept(release) {}
 
+  template<std::size_t I, typename Self>
+  [[nodiscard]] constexpr auto get(this Self &&self) noexcept(release) -> auto && {
+    decltype(auto) retval = UPD_FWD(self).m_leaves.at(expr<I>);
+
+    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`");
+
+    return UPD_FWD(retval);
+  }
+
 private:
   leaves m_leaves;
 };
@@ -720,6 +825,16 @@ class constlist : public tuple_implementation<constlist<Vs...>> {
   template<metavalue... Metas>
   constexpr explicit constlist(Metas...) noexcept(release) {}
 
+  template<std::size_t I, typename Self>
+  [[nodiscard]] constexpr auto get(this Self &&self) noexcept(release) -> auto && {
+    decltype(auto) retval = UPD_FWD(self).m_leaves.at(expr<I>);
+
+    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`");
+
+    return UPD_FWD(retval);
+  }
+
 private:
   leaves m_leaves;
 };
@@ -738,7 +853,7 @@ template<tuple_like Tuple>
     .apply([](auto ...types) { return typelist {types...}; });
 }
 
-template<tuple_like ...Tuples> requires (!(typelist_like<Tuples> && ...))
+template<tuple_like ...Tuples> requires (!UPD_VARIADIC_CONSTRAINT_WORKAROUND(typelist_like<Tuples> || named_tuple_like<Tuples>))
 [[nodiscard]] constexpr auto concat(Tuples &&... ts) noexcept(release) {
   auto element_types = concat(type_only(ts)...);
   using retval_type = instantiate_variadic<tuple, decltype(element_types)>;
@@ -783,7 +898,7 @@ template<typename F>
 struct unpacker {
   template<typename Self, typename Tuple>
   [[nodiscard]] constexpr auto operator()(this Self &&self, Tuple &&t) noexcept(release) -> decltype(auto) {
-    static_assert(applicable<F, Tuple>);
+    UPD_THIS_DEDUCTION_REQUIRES_WORKAROUND(applicable<F, Tuple>);
 
     using noref_type = std::remove_reference_t<Tuple>;
     constexpr auto size = std::tuple_size_v<noref_type>;