diff --git a/src/mpp/Constants.hpp b/src/mpp/Constants.hpp
index 7c7fd2389..f3243229c 100644
--- a/src/mpp/Constants.hpp
+++ b/src/mpp/Constants.hpp
@@ -203,6 +203,12 @@ struct family_sequence {
 	}
 };
 
+template <compact::Family NEW_FAMILY, compact::Family ...FAMILY>
+static constexpr auto family_sequence_populate(struct family_sequence<FAMILY...>)
+{
+	return family_sequence<NEW_FAMILY, FAMILY...>{};
+}
+
 template <compact::Family ...FAMILY>
 std::ostream&
 operator<<(std::ostream& strm, family_sequence<FAMILY...>)
diff --git a/src/mpp/Dec.hpp b/src/mpp/Dec.hpp
index 19d17038c..e603e2dc3 100644
--- a/src/mpp/Dec.hpp
+++ b/src/mpp/Dec.hpp
@@ -82,6 +82,10 @@ constexpr auto detectFamily()
 		      "Can't decode to constant type");
 	if constexpr (is_wrapped_family_v<T>) {
 		return family_sequence<T::family>{};
+	} else if constexpr (tnt::is_optional_v<U>) {
+		return family_sequence_populate<compact::MP_NIL>(detectFamily<tnt::value_type_t<U>>());
+	} else if constexpr (has_dec_rule_v<U>) {
+		return detectFamily<decltype(get_dec_rule<U>())>();
 	} else if constexpr (std::is_same_v<U, std::nullptr_t>) {
 		return family_sequence<compact::MP_NIL>{};
 	} else if constexpr (std::is_same_v<U, bool>) {
@@ -203,7 +207,21 @@ using path_push_t =
 							 STATIC_SIZE,
 							 STATIC_POS)>;
 
-template <size_t I, size_t... P>
+/**
+ * The class allows to get an object by its path.
+ * All object can be divided into 3 parts: visible, transparent and
+ * semi-transparent. For example:
+ * std::vector<int> is visible - when the path points to the vector, it
+ * is always returned by resolver,
+ * class MyClass { static constexpr mpp = ...; } is transparent - resolver
+ * never returns an instance of MyClass itself.
+ * std::optional<int> is semi-transparent - the path, that points to the
+ * optional, also points to the underlying int. So, when the template argument
+ * ShowSemiTransparent is true, resolver will return the optional itself, and
+ * when it is false, it will skip semi-transparent objects - in our case,
+ * underlying int will be returned.
+ */
+template <bool ShowSemiTransparent, size_t I, size_t... P>
 struct Resolver {
 	template <size_t J>
 	static constexpr size_t ITEM = tnt::iseq<P...>::template get<J>();
@@ -239,41 +257,69 @@ struct Resolver {
 			return I;
 		} else if constexpr (std::is_member_pointer_v<R> ||
 				     tnt::is_tuplish_v<R>) {
-			using PrevResolver = Resolver<I - 1, P...>;
+			/*
+			 * If the object with dec_rule is wrapped into optional,
+			 * the optional must be skipped. That's why PrevResolver
+			 * must have false ShowSemiTransparent flag.
+			 */
+			using PrevResolver = Resolver<false, I - 1, P...>;
 			return PrevResolver::template find_obj_index<T...>();
 		} else {
 			static_assert(tnt::always_false_v<E>);
 		}
 	}
 
+	/**
+	 * The method is used to get the container which contains the value the
+	 * path points to.
+	 */
 	template <class... T>
-	static constexpr auto&& prev(T... t)
+	static constexpr auto&& parent_container(T... t)
 	{
-		return unwrap(Resolver<I - 1, P...>::get(t...));
+		/*
+		 * If the container is wrapped into optional, the optional must
+		 * be skipped. That's why the Resolver must have false
+		 * ShowSemiTransparent flag.
+		 */
+		return unwrap(Resolver<false, I - 1, P...>::get(t...));
 	}
 
 	template <class... T>
-	static constexpr auto&& extract(T... t)
+	static constexpr auto&& extract_impl(T... t)
 	{
 		if constexpr (TYPE == PIT_STATIC_L0) {
 			return std::get<POS>(std::tie(t...)).get();
 		} else if constexpr (is_path_item_static(PI)) {
-			return tnt::get<POS>(prev(t...));
+			return tnt::get<POS>(parent_container(t...));
 		} else if constexpr (TYPE == PIT_DYN_POS) {
 			constexpr size_t ARG_POS = dyn_arg_pos();
 			uint64_t arg = std::get<ARG_POS>(std::tie(t...));
-			return std::data(prev(t...))[arg >> 32];
+			return std::data(parent_container(t...))[arg >> 32];
 		} else if constexpr (TYPE == PIT_DYN_BACK) {
-			return prev(t...).back();
+			return parent_container(t...).back();
 		} else if constexpr (TYPE == PIT_DYN_ADD) {
-			return prev(t...);
+			return parent_container(t...);
 		} else if constexpr (TYPE == PIT_DYN_KEY) {
-			return prev(t...);
+			return parent_container(t...);
 		} else {
 			static_assert(tnt::always_false_v<T...>);
 		}
 	}
 
+	template <class... T>
+	static constexpr auto&& extract(T... t)
+	{
+		auto &&extracted = extract_impl(t...);
+		auto &&unwrapped = unwrap(extracted);
+		using unwrapped_t = std::remove_reference_t<decltype(unwrapped)>;
+		if constexpr (!ShowSemiTransparent && tnt::is_optional_v<unwrapped_t>) {
+			assert(unwrapped.has_value());
+			return *unwrapped;
+		} else {
+			return extracted;
+		}
+	}
+
 	template <class... T>
 	static constexpr auto&& unrule(T... t)
 	{
@@ -309,7 +355,12 @@ struct Resolver {
 		using R = unwrap_t<U>;
 		if constexpr (std::is_member_pointer_v<R>) {
 			constexpr size_t OBJ_I = find_obj_index<T...>();
-			using Res = Resolver<OBJ_I, P...>;
+			/*
+			 * If the object with the required field is wrapped into
+			 * optional, the optional must be skipped. That's why
+			 * Resolver must have false ShowSemiTransparent flag.
+			 */
+			using Res = Resolver<false, OBJ_I, P...>;
 			return self_unwrap(unwrap(Res::extract(t...)).*
 					   unwrap(unrule(t...)));
 		} else {
@@ -323,18 +374,29 @@ struct Resolver {
 	}
 };
 
+/** Resolve path, semi-transparent object are visible. */
+template <size_t... P, class... T>
+constexpr auto&& path_resolve_transparent(tnt::iseq<P...>, T... t)
+{
+	using Res = Resolver<false, sizeof...(P) - 1, P...>;
+	static_assert(Res::expected_arg_count() == sizeof...(T));
+	return Res::get(t...);
+}
+
+/** Resolve path, semi-transparent object are invisible. */
 template <size_t... P, class... T>
 constexpr auto&& path_resolve(tnt::iseq<P...>, T... t)
 {
-	using Res = Resolver<sizeof...(P) - 1, P...>;
+	using Res = Resolver<true, sizeof...(P) - 1, P...>;
 	static_assert(Res::expected_arg_count() == sizeof...(T));
 	return Res::get(t...);
 }
 
+/** Resolve parent path, semi-transparent object are invisible. */
 template <size_t... P, class... T>
 constexpr auto&& path_resolve_parent(tnt::iseq<P...>, T... t)
 {
-	using Res = Resolver<sizeof...(P) - 1, P...>;
+	using Res = Resolver<false, sizeof...(P) - 1, P...>;
 	static_assert(Res::expected_arg_count() == sizeof...(T) - 1);
 	return Res::get(t...);
 }
@@ -429,6 +491,8 @@ auto read_item(BUF& buf, ITEM& item)
 			item.resize(val);
 	} else if constexpr (std::is_enum_v<ITEM>) {
 		item = static_cast<ITEM>(val);
+	} else if constexpr (FAMILY == compact::MP_NIL && tnt::is_optional_v<ITEM>) {
+		item.reset();
 	} else {
 		item = val;
 	}
@@ -641,8 +705,7 @@ struct JumpsBuilder {
 		if constexpr (path_item_type(LAST) == PIT_DYN_SKIP) {
 			return getFamiliesByRules<all_rules_t>();
 		} else if constexpr (path_item_type(LAST) == PIT_DYN_KEY) {
-			using R = decltype(path_resolve(PATH{},
-							std::declval<T>()...));
+			using R = decltype(path_resolve(PATH{}, std::declval<T>()...));
 			using DST = std::remove_reference_t<R>;
 			static_assert(tnt::is_tuplish_v<DST>);
 			constexpr size_t S = tnt::tuple_size_v<DST>;
@@ -655,8 +718,7 @@ struct JumpsBuilder {
 				return keyMapKeyFamiliesFlat<DST>(is{});
 			}
 		} else {
-			using R = decltype(path_resolve(PATH{},
-							std::declval<T>()...));
+			using R = decltype(path_resolve(PATH{}, std::declval<T>()...));
 			using DST = std::remove_reference_t<R>;
 			if constexpr (path_item_type(LAST) == PIT_DYN_ADD) {
 				return detectFamily<tnt::value_type_t<DST>>();
@@ -817,7 +879,7 @@ template <compact::Family FAMILY, size_t SUBRULE,
 bool jump_add(BUF& buf, T... t)
 {
 	static_assert(path_item_type(PATH::last()) == PIT_DYN_ADD);
-	auto&& dst = path_resolve(PATH{}, t...);
+	auto&& dst = path_resolve_transparent(PATH{}, t...);
 	using dst_t = std::remove_reference_t<decltype(dst)>;
 	tnt::value_type_t<dst_t> trg;
 	read_item<FAMILY, SUBRULE>(buf, trg);
@@ -853,17 +915,16 @@ constexpr enum path_item_type get_next_arr_item_type()
 template <class ARR, enum path_item_type TYPE>
 constexpr size_t get_next_arr_static_size()
 {
-	if constexpr (TYPE <= PIT_STADYN)
+	if constexpr (TYPE > PIT_BAD && TYPE <= PIT_STADYN)
 		return tnt::tuple_size_v<ARR>;
 	else
 		return 0;
 }
 
 template <compact::Family FAMILY, size_t SUBRULE,
-	  class PATH, class BUF, class... T>
-bool jump_read(BUF& buf, T... t)
+	  class PATH, class BUF, class DST, class... T>
+bool jump_read_impl(BUF& buf, DST &&dst, T... t)
 {
-	auto&& dst = unwrap(path_resolve(PATH{}, t...));
 	using dst_t = std::remove_reference_t<decltype(dst)>;
 	using RULE = rule_by_family_t<FAMILY>;
 	auto val = read_item<FAMILY, SUBRULE>(buf, dst);
@@ -932,6 +993,32 @@ bool jump_read(BUF& buf, T... t)
 
 decode_next_label:
 	return decode_next<PATH>(buf, t...);
+
+}
+
+template <compact::Family FAMILY, size_t SUBRULE,
+	  class PATH, class BUF, class... T>
+bool jump_read(BUF& buf, T... t)
+{
+	auto&& dst = unwrap(path_resolve_transparent(PATH{}, t...));
+	return jump_read_impl<FAMILY, SUBRULE, PATH>(buf, dst, t...);
+}
+
+template <compact::Family FAMILY, size_t SUBRULE,
+	  class PATH, class BUF, class... T>
+bool jump_read_optional(BUF& buf, T... t)
+{
+	auto&& optional_dst = unwrap(path_resolve(PATH{}, t...));
+	if constexpr (FAMILY == compact::MP_NIL) {
+		[[maybe_unused]] auto val = read_value<FAMILY, SUBRULE>(buf);
+		optional_dst.reset();
+		return decode_next<PATH>(buf, t...);
+	} else {
+		if (!optional_dst.has_value())
+			optional_dst.emplace();
+		auto&& dst = unwrap(path_resolve_transparent(PATH{}, t...));
+		return jump_read_impl<FAMILY, SUBRULE, PATH>(buf, dst, t...);
+	}
 }
 
 template <class K, class V>
@@ -1012,7 +1099,7 @@ bool jump_find_key(K k, tnt::iseq<I, J...>, BUF& buf, T... t)
 {
 	static_assert(path_item_type(PATH::last()) == PIT_DYN_KEY);
 
-	auto&& key = key_path_resolve<PAIRS, I>(path_resolve(PATH{}, t...));
+	auto&& key = key_path_resolve<PAIRS, I>(path_resolve_transparent(PATH{}, t...));
 	using PAIRS_NEXT_PREPATH = path_push_t<PATH, PIT_STATIC, I + 1, I>;
 	using PAIRS_NEXT_PATH = path_push_t<PAIRS_NEXT_PREPATH, PIT_STATIC, 2, 1>;
 	using FLAT_NEXT_PATH = path_push_t<PATH, PIT_STATIC, I * 2 + 2, I * 2 + 1>;
@@ -1033,7 +1120,7 @@ template <compact::Family FAMILY, size_t SUBRULE,
 bool jump_read_key(BUF& buf, T... t)
 {
 	static_assert(path_item_type(PATH::last()) == PIT_DYN_KEY);
-	auto&& dst = path_resolve(PATH{}, t...);
+	auto&& dst = path_resolve_transparent(PATH{}, t...);
 	using dst_t = std::remove_reference_t<decltype(dst)>;
 	static_assert(tnt::is_tuplish_v<dst_t>);
 
@@ -1053,14 +1140,20 @@ template <compact::Family FAMILY, size_t SUBRULE,
 	  class PATH, class BUF, class... T>
 bool jump_common(BUF& buf, T... t)
 {
-	if constexpr (path_item_type(PATH::last()) == PIT_DYN_ADD)
-		return jump_add<FAMILY, SUBRULE, PATH>(buf, t...);
-	else if constexpr (path_item_type(PATH::last()) == PIT_DYN_SKIP)
+	if constexpr (path_item_type(PATH::last()) == PIT_DYN_SKIP) {
 		return jump_skip<FAMILY, SUBRULE, PATH>(buf, t...);
-	else if constexpr (path_item_type(PATH::last()) == PIT_DYN_KEY)
-		return jump_read_key<FAMILY, SUBRULE, PATH>(buf, t...);
-	else
-		return jump_read<FAMILY, SUBRULE, PATH>(buf, t...);
+	} else {
+		auto&& dst = unwrap(path_resolve(PATH{}, t...));
+		using dst_t = std::remove_reference_t<decltype(dst)>;
+		if constexpr (tnt::is_optional_v<dst_t> && path_item_type(PATH::last()) != PIT_DYN_KEY)
+			return jump_read_optional<FAMILY, SUBRULE, PATH>(buf, t...);
+		else if constexpr (path_item_type(PATH::last()) == PIT_DYN_ADD)
+			return jump_add<FAMILY, SUBRULE, PATH>(buf, t...);
+		else if constexpr (path_item_type(PATH::last()) == PIT_DYN_KEY)
+			return jump_read_key<FAMILY, SUBRULE, PATH>(buf, t...);
+		else
+			return jump_read<FAMILY, SUBRULE, PATH>(buf, t...);
+	}
 }
 
 template <class BUF, class... T>
diff --git a/src/mpp/Enc.hpp b/src/mpp/Enc.hpp
index 894377f33..e2e532e32 100644
--- a/src/mpp/Enc.hpp
+++ b/src/mpp/Enc.hpp
@@ -544,6 +544,12 @@ encode(CONT &cont, tnt::CStr<C...> prefix,
 	} if constexpr(mpp::has_enc_rule_v<T>) {
 		const auto& rule = mpp::get_enc_rule<T>();
 		return encode(cont, prefix, ais, subst(rule, t), more...);
+	} else if constexpr(tnt::is_optional_v<U>) {
+		static_assert(!is_wrapped_family_v<T> && !is_wrapped_raw_v<T>);
+		if (u.has_value())
+			return encode(cont, prefix, ais, u.value(), more...);
+		else
+			return encode(cont, prefix, ais, nullptr, more...);
 	} else if constexpr(is_wrapped_raw_v<T>) {
 		if constexpr(std::is_base_of_v<ChildrenTag, U>) {
 			using V = typename U::type;
diff --git a/test/EncDecTest.cpp b/test/EncDecTest.cpp
index e0e23472b..d45e1f214 100644
--- a/test/EncDecTest.cpp
+++ b/test/EncDecTest.cpp
@@ -34,6 +34,7 @@
 #include <set>
 #include <map>
 #include <vector>
+#include <optional>
 
 #include "Utils/Helpers.hpp"
 #include "Utils/RefVector.hpp"
@@ -1109,6 +1110,11 @@ struct IntegerWrapper {
 		return i == that.i;
 	}
 
+	bool operator<(const IntegerWrapper& that) const
+	{
+		return i < that.i;
+	}
+
 	static constexpr auto mpp = &IntegerWrapper::i;
 };
 
@@ -1128,6 +1134,11 @@ struct Triplet {
 	{
 		return std::tie(a, b, c) == std::tie(that.a, that.b, that.c);
 	}
+
+	bool operator<(const Triplet& that) const
+	{
+		return std::tie(a, b, c) < std::tie(that.a, that.b, that.c);
+	}
 };
 
 template <>
@@ -1152,6 +1163,11 @@ struct Error {
 		return std::tie(code, descr) == std::tie(that.code, that.descr);
 	}
 
+	bool operator<(const Error& that) const
+	{
+		return std::tie(code, descr) < std::tie(that.code, that.descr);
+	}
+
 	static constexpr auto mpp = std::make_tuple(
 		std::make_pair(0, &Error::code),
 		std::make_pair(1, &Error::descr));
@@ -1181,6 +1197,12 @@ struct Body {
 		       std::tie(that.str, that.num, that.triplets, that.errors);
 	}
 
+	bool operator<(const Body& that) const
+	{
+		return std::tie(str, num, triplets, errors) <
+		       std::tie(that.str, that.num, that.triplets, that.errors);
+	}
+
 	static constexpr auto mpp = std::make_tuple(
 		std::make_pair(0, &Body::str),
 		std::make_pair(1, &Body::num),
@@ -1197,9 +1219,11 @@ test_object_codec()
 	Buf_t buf;
 
 	Body wr, rd;
+	std::set<Body> rds;
 	wr.gen();
 
 	mpp::encode(buf, wr);
+	mpp::encode(buf, mpp::as_arr(std::forward_as_tuple(wr)));
 
 	for (auto itr = buf.begin(); itr != buf.end(); ++itr) {
 		char c = itr.get<uint8_t>();
@@ -1214,11 +1238,214 @@ test_object_codec()
 
 	auto itr = buf.begin();
 	mpp::decode(itr, rd);
-
 	fail_unless(rd == wr);
+
+	mpp::decode(itr, rds);
+	fail_unless(rds.count(wr) > 0);
+
 	fail_unless(itr == buf.end());
 }
 
+static void
+test_optional()
+{
+	TEST_INIT(0);
+
+	using Buf_t = tnt::Buffer<16 * 1024>;
+	Buf_t buf;
+	bool ok;
+
+	TEST_CASE("number");
+	mpp::encode(buf, std::optional<int>(100), std::optional<int>(),
+		    std::optional<int>(42));
+
+	auto run = buf.begin<true>();
+	std::optional<int> opt_num;
+	ok = mpp::decode(run, opt_num);
+	fail_unless(ok);
+	fail_unless(opt_num.has_value());
+	fail_unless(opt_num.value() == 100);
+
+	ok = mpp::decode(run, opt_num);
+	fail_unless(ok);
+	fail_unless(!opt_num.has_value());
+
+	ok = mpp::decode(run, opt_num);
+	fail_unless(ok);
+	fail_unless(opt_num.has_value());
+	fail_unless(opt_num.value() == 42);
+
+	buf.flush();
+
+	TEST_CASE("containers with numbers");
+	int null_idx = 4;
+	mpp::encode(buf, std::make_optional(mpp::as_arr(
+		std::forward_as_tuple(0, std::make_optional(1), 2, 3, std::optional<int>(), 5)
+	)));
+	mpp::encode(buf, nullptr);
+	std::vector<std::optional<int>> opt_num_arr;
+	std::set<std::optional<int>> opt_num_set;
+	std::optional<std::vector<std::optional<int>>> opt_num_opt_arr;
+	std::optional<std::set<std::optional<int>>> opt_num_opt_set;
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_num_arr);
+	fail_unless(ok);
+	fail_unless(opt_num_arr.size() == 6);
+	for (int i = 0; i < 6; i++) {
+		if (i == null_idx) {
+			fail_unless(!opt_num_arr[i].has_value());
+			continue;
+		}
+		fail_unless(opt_num_arr[i].has_value());
+		fail_unless(opt_num_arr[i].value() == i);
+	}
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_num_set);
+	fail_unless(ok);
+	fail_unless(opt_num_set.size() == 6);
+	for (int i = 0; i < 6; i++) {
+		if (i == null_idx) {
+			fail_unless(opt_num_set.count(i) == 0);
+			fail_unless(opt_num_set.count(std::nullopt) == 1);
+			continue;
+		}
+		fail_unless(opt_num_set.count(i) > 0);
+	}
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_num_opt_arr);
+	fail_unless(ok);
+	fail_unless(opt_num_opt_arr.has_value());
+	fail_unless(opt_num_opt_arr->size() == 6);
+	for (int i = 0; i < 6; i++) {
+		if (i == null_idx) {
+			fail_unless(!opt_num_opt_arr.value()[i].has_value());
+			continue;
+		}
+		fail_unless(opt_num_opt_arr.value()[i].has_value());
+		fail_unless(opt_num_opt_arr.value()[i].value() == i);
+	}
+	ok = mpp::decode(run, opt_num_opt_arr);
+	fail_unless(ok);
+	fail_unless(!opt_num_opt_arr.has_value());
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_num_opt_set);
+	fail_unless(ok);
+	fail_unless(opt_num_opt_set.has_value());
+	fail_unless(opt_num_opt_set->size() == 6);
+	for (int i = 0; i < 6; i++) {
+		if (i == null_idx) {
+			fail_unless(opt_num_opt_set->count(i) == 0);
+			fail_unless(opt_num_opt_set->count(std::nullopt) == 1);
+			continue;
+		}
+		fail_unless(opt_num_opt_set->count(i) > 0);
+	}
+	ok = mpp::decode(run, opt_num_opt_set);
+	fail_unless(ok);
+	fail_unless(!opt_num_opt_set.has_value());
+
+	buf.flush();
+
+	TEST_CASE("objects");
+	Body wr;
+	wr.gen();
+	mpp::encode(buf, std::optional<Body>(wr), std::optional<Body>());
+
+	run = buf.begin<true>();
+	std::optional<Body> rd;
+	ok = mpp::decode(run, rd);
+	fail_unless(ok);
+	fail_unless(rd.has_value());
+	fail_unless(rd.value() == wr);
+
+	ok = mpp::decode(run, rd);
+	fail_unless(ok);
+	fail_unless(!rd.has_value());
+
+	buf.flush();
+
+	TEST_CASE("containers with objects");
+	std::vector<Body> wrs;
+	for (size_t i = 0; i < 3; i++) {
+		wrs.emplace_back();
+		wrs[i].gen();
+		wrs[i].str += std::to_string(i);
+	}
+	null_idx = 1;
+	mpp::encode(buf, mpp::as_arr(std::forward_as_tuple(wrs[0], nullptr, wrs[2])));
+	mpp::encode(buf, nullptr);
+	std::vector<std::optional<Body>> opt_body_arr;
+	std::set<std::optional<Body>> opt_body_set;
+	std::optional<std::vector<std::optional<Body>>> opt_body_opt_arr;
+	std::optional<std::set<std::optional<Body>>> opt_body_opt_set;
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_body_arr);
+	fail_unless(ok);
+	fail_unless(opt_body_arr.size() == 3);
+	for (int i = 0; i < 3; i++) {
+		if (i == null_idx) {
+			fail_unless(!opt_body_arr[i].has_value());
+			continue;
+		}
+		fail_unless(opt_body_arr[i].has_value());
+		fail_unless(opt_body_arr[i].value() == wrs[i]);
+	}
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_body_set);
+	fail_unless(ok);
+	fail_unless(opt_body_set.size() == 3);
+	fail_unless(opt_body_set.count(std::nullopt) == 1);
+	for (int i = 0; i < 3; i++) {
+		if (i == null_idx) {
+			fail_unless(opt_body_set.count(wrs[i]) == 0);
+			continue;
+		}
+		fail_unless(opt_body_set.count(wrs[i]) > 0);
+	}
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_body_opt_arr);
+	fail_unless(ok);
+	fail_unless(opt_body_opt_arr.has_value());
+	fail_unless(opt_body_opt_arr->size() == 3);
+	for (int i = 0; i < 3; i++) {
+		if (i == null_idx) {
+			fail_unless(!opt_body_opt_arr.value()[i].has_value());
+			continue;
+		}
+		fail_unless(opt_body_opt_arr.value()[i].has_value());
+		fail_unless(opt_body_opt_arr.value()[i].value() == wrs[i]);
+	}
+	ok = mpp::decode(run, opt_body_opt_arr);
+	fail_unless(ok);
+	fail_unless(!opt_body_opt_arr.has_value());
+
+	run = buf.begin<true>();
+	ok = mpp::decode(run, opt_body_opt_set);
+	fail_unless(ok);
+	fail_unless(opt_body_opt_set.has_value());
+	fail_unless(opt_body_opt_set->size() == 3);
+	fail_unless(opt_body_opt_set->count(std::nullopt) == 1);
+	for (int i = 0; i < 3; i++) {
+		if (i == null_idx) {
+			fail_unless(opt_body_opt_set->count(wrs[i]) == 0);
+			continue;
+		}
+		fail_unless(opt_body_opt_set->count(wrs[i]) > 0);
+	}
+	ok = mpp::decode(run, opt_body_opt_set);
+	fail_unless(ok);
+	fail_unless(!opt_body_opt_set.has_value());
+
+	buf.flush();
+}
+
 int main()
 {
 	test_under_ints();
@@ -1227,4 +1454,5 @@ int main()
 	test_basic();
 	test_class_rules();
 	test_object_codec();
+	test_optional();
 }