diff --git a/include/stdx/type_traits.hpp b/include/stdx/type_traits.hpp
index 515fa98..e35b729 100644
--- a/include/stdx/type_traits.hpp
+++ b/include/stdx/type_traits.hpp
@@ -68,6 +68,9 @@ constexpr bool is_callable_v = is_function_v<T> or is_function_object_v<T>;
 
 template <typename T> struct type_identity {
     using type = T;
+    [[nodiscard]] friend constexpr auto operator==(type_identity const &,
+                                                   type_identity const &)
+        -> bool = default;
 };
 template <typename T> using type_identity_t = typename type_identity<T>::type;
 template <typename T>
diff --git a/include/stdx/utility.hpp b/include/stdx/utility.hpp
index 4e91509..2665520 100644
--- a/include/stdx/utility.hpp
+++ b/include/stdx/utility.hpp
@@ -35,6 +35,11 @@ template <map_value_helper V> struct map_value_t {
     constexpr static inline auto value = V.value;
 };
 
+template <typename T> consteval auto unwrap_map_value(T t) -> T { return t; }
+template <map_value_helper V> consteval auto unwrap_map_value(map_value_t<V>) {
+    return V.value;
+}
+
 template <typename... Ts> struct type_map : Ts... {};
 } // namespace detail
 
@@ -52,8 +57,6 @@ using tv_pair = tt_pair<K, detail::map_value_t<V>>;
 template <detail::map_value_helper K, detail::map_value_helper V>
 using vv_pair = tt_pair<detail::map_value_t<K>, detail::map_value_t<V>>;
 
-template <typename... Ts> using type_map = shrink_t<detail::type_map<Ts...>>;
-
 namespace detail {
 template <typename K, typename Default>
 constexpr static auto lookup(...) -> Default;
@@ -121,6 +124,36 @@ constexpr static auto reverse_value_lookup_v =
                                               missing_t>(expand<M>())),
               detail::map_value_t<Default>>::value;
 
+template <typename... Ts>
+class type_map : public shrink_t<detail::type_map<Ts...>> {
+    using map_t = shrink_t<detail::type_map<Ts...>>;
+
+    template <typename K> consteval static auto try_lookup() {
+        using V = type_lookup_t<map_t, K>;
+        if constexpr (requires { V{}; }) {
+            return detail::unwrap_map_value(V{});
+        } else {
+            return type_identity_v<V>;
+        }
+    }
+
+  public:
+    template <typename K> consteval auto operator[](K) const {
+        if constexpr (not same_as<decltype(try_lookup<K>()), missing_t>) {
+            return try_lookup<K>();
+        } else if constexpr (requires { typename K::type; }) {
+            return try_lookup<typename K::type>();
+        } else {
+            return missing;
+        }
+    }
+
+    template <typename K> consteval auto operator()(K) const {
+        return this->operator[](
+            detail::map_value_t<detail::map_value_helper{K::value}>{});
+    }
+};
+
 template <typename T, typename U>
 [[nodiscard]] constexpr auto forward_like(U &&u) noexcept -> decltype(auto) {
     constexpr auto t_is_const = std::is_const_v<std::remove_reference_t<T>>;
diff --git a/test/type_map.cpp b/test/type_map.cpp
index a4773df..df13846 100644
--- a/test/type_map.cpp
+++ b/test/type_map.cpp
@@ -1,4 +1,5 @@
 #include <stdx/ct_string.hpp>
+#include <stdx/udls.hpp>
 #include <stdx/utility.hpp>
 
 #include <catch2/catch_test_macros.hpp>
@@ -13,184 +14,273 @@ struct Z;
 
 TEST_CASE("look up type in map", "[type map]") {
     using M = stdx::type_map<stdx::type_pair<A, X>, stdx::type_pair<B, Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::type_lookup_t<M, A>, X>);
-    STATIC_REQUIRE(std::is_same_v<stdx::type_lookup_t<M, B>, Y>);
+    STATIC_CHECK(std::is_same_v<stdx::type_lookup_t<M, A>, X>);
+    STATIC_CHECK(std::is_same_v<stdx::type_lookup_t<M, B>, Y>);
 }
 
 TEST_CASE("look up type not in map", "[type map]") {
     using M = stdx::type_map<stdx::type_pair<A, X>, stdx::type_pair<B, Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::type_lookup_t<M, Z>, stdx::missing_t>);
-    STATIC_REQUIRE(std::is_same_v<stdx::type_lookup_t<M, Z, int>, int>);
+    STATIC_CHECK(std::is_same_v<stdx::type_lookup_t<M, Z>, stdx::missing_t>);
+    STATIC_CHECK(std::is_same_v<stdx::type_lookup_t<M, Z, int>, int>);
 }
 
 TEST_CASE("look up type in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<0, X>, stdx::vt_pair<1, Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, 0>, X>);
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, 1>, Y>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, 0>, X>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, 1>, Y>);
 }
 
 TEST_CASE("look up type not in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<0, X>, stdx::vt_pair<1, Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, 2>, stdx::missing_t>);
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, 2, int>, int>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, 2>, stdx::missing_t>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, 2, int>, int>);
 }
 
 TEST_CASE("look up type in map (by string value)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<"A", X>, stdx::vt_pair<"B", Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, "A">, X>);
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, "B">, Y>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, "A">, X>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, "B">, Y>);
 }
 
 TEST_CASE("look up type not in map (by string value)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<"A", X>, stdx::vt_pair<"B", Y>>;
-    STATIC_REQUIRE(
-        std::is_same_v<stdx::value_lookup_t<M, "C">, stdx::missing_t>);
-    STATIC_REQUIRE(std::is_same_v<stdx::value_lookup_t<M, "C", int>, int>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, "C">, stdx::missing_t>);
+    STATIC_CHECK(std::is_same_v<stdx::value_lookup_t<M, "C", int>, int>);
 }
 
 TEST_CASE("look up value in map (by type)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<A, 0>, stdx::tv_pair<B, 1>>;
-    STATIC_REQUIRE(stdx::type_lookup_v<M, A> == 0);
-    STATIC_REQUIRE(stdx::type_lookup_v<M, B> == 1);
+    STATIC_CHECK(stdx::type_lookup_v<M, A> == 0);
+    STATIC_CHECK(stdx::type_lookup_v<M, B> == 1);
 }
 
 TEST_CASE("look up value not in map (by type)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<A, 0>, stdx::tv_pair<B, 1>>;
-    STATIC_REQUIRE(stdx::type_lookup_v<M, Z> == stdx::missing);
-    STATIC_REQUIRE(stdx::type_lookup_v<M, Z, 2> == 2);
+    STATIC_CHECK(stdx::type_lookup_v<M, Z> == stdx::missing);
+    STATIC_CHECK(stdx::type_lookup_v<M, Z, 2> == 2);
 }
 
 TEST_CASE("look up string value in map (by type)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::tv_pair<A, "X">, stdx::tv_pair<B, "Y">>;
-    STATIC_REQUIRE(stdx::type_lookup_v<M, A> == "X"_cts);
-    STATIC_REQUIRE(stdx::type_lookup_v<M, B> == "Y"_cts);
+    STATIC_CHECK(stdx::type_lookup_v<M, A> == "X"_cts);
+    STATIC_CHECK(stdx::type_lookup_v<M, B> == "Y"_cts);
 }
 
 TEST_CASE("look up string value not in map (by type)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::tv_pair<A, "X">, stdx::tv_pair<B, "Y">>;
-    STATIC_REQUIRE(stdx::type_lookup_v<M, Z> == stdx::missing);
-    STATIC_REQUIRE(stdx::type_lookup_v<M, Z, "Z"> == "Z"_cts);
+    STATIC_CHECK(stdx::type_lookup_v<M, Z> == stdx::missing);
+    STATIC_CHECK(stdx::type_lookup_v<M, Z, "Z"> == "Z"_cts);
 }
 
 TEST_CASE("look up value in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vv_pair<0, 10>, stdx::vv_pair<1, 11>>;
-    STATIC_REQUIRE(stdx::value_lookup_v<M, 0> == 10);
-    STATIC_REQUIRE(stdx::value_lookup_v<M, 1> == 11);
+    STATIC_CHECK(stdx::value_lookup_v<M, 0> == 10);
+    STATIC_CHECK(stdx::value_lookup_v<M, 1> == 11);
 }
 
 TEST_CASE("look up value not in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vv_pair<0, 10>, stdx::vv_pair<1, 11>>;
-    STATIC_REQUIRE(stdx::value_lookup_v<M, 2> == stdx::missing);
-    STATIC_REQUIRE(stdx::value_lookup_v<M, 2, 3> == 3);
+    STATIC_CHECK(stdx::value_lookup_v<M, 2> == stdx::missing);
+    STATIC_CHECK(stdx::value_lookup_v<M, 2, 3> == 3);
 }
 
 TEST_CASE("look up string value in map (by string value)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vv_pair<"A", "X">, stdx::vv_pair<"B", "Y">>;
-    STATIC_REQUIRE(stdx::value_lookup_v<M, "A"> == "X"_cts);
-    STATIC_REQUIRE(stdx::value_lookup_v<M, "B"> == "Y"_cts);
+    STATIC_CHECK(stdx::value_lookup_v<M, "A"> == "X"_cts);
+    STATIC_CHECK(stdx::value_lookup_v<M, "B"> == "Y"_cts);
 }
 
 TEST_CASE("look up string value not in map (by string value)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vv_pair<"A", "X">, stdx::vv_pair<"B", "Y">>;
-    STATIC_REQUIRE(stdx::value_lookup_v<M, "C"> == stdx::missing);
-    STATIC_REQUIRE(stdx::value_lookup_v<M, "C", "Z"> == "Z"_cts);
+    STATIC_CHECK(stdx::value_lookup_v<M, "C"> == stdx::missing);
+    STATIC_CHECK(stdx::value_lookup_v<M, "C", "Z"> == "Z"_cts);
 }
 
 TEST_CASE("reverse look up type in map", "[type map]") {
     using M = stdx::type_map<stdx::type_pair<A, X>, stdx::type_pair<B, Y>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_type_lookup_t<M, X>, A>);
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_type_lookup_t<M, Y>, B>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_type_lookup_t<M, X>, A>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_type_lookup_t<M, Y>, B>);
 }
 
 TEST_CASE("reverse look up type not in map", "[type map]") {
     using M = stdx::type_map<stdx::type_pair<A, X>, stdx::type_pair<B, Y>>;
-    STATIC_REQUIRE(
+    STATIC_CHECK(
         std::is_same_v<stdx::reverse_type_lookup_t<M, Z>, stdx::missing_t>);
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_type_lookup_t<M, Z, int>, int>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_type_lookup_t<M, Z, int>, int>);
 }
 
 TEST_CASE("reverse look up type in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<X, 0>, stdx::tv_pair<Y, 1>>;
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_value_lookup_t<M, 0>, X>);
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_value_lookup_t<M, 1>, Y>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_value_lookup_t<M, 0>, X>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_value_lookup_t<M, 1>, Y>);
 }
 
 TEST_CASE("reverse look up type not in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<X, 0>, stdx::tv_pair<Y, 1>>;
-    STATIC_REQUIRE(
+    STATIC_CHECK(
         std::is_same_v<stdx::reverse_value_lookup_t<M, 2>, stdx::missing_t>);
-    STATIC_REQUIRE(
-        std::is_same_v<stdx::reverse_value_lookup_t<M, 2, int>, int>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_value_lookup_t<M, 2, int>, int>);
 }
 
 TEST_CASE("reverse look up type in map (by string value)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<X, "A">, stdx::tv_pair<Y, "B">>;
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_value_lookup_t<M, "A">, X>);
-    STATIC_REQUIRE(std::is_same_v<stdx::reverse_value_lookup_t<M, "B">, Y>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_value_lookup_t<M, "A">, X>);
+    STATIC_CHECK(std::is_same_v<stdx::reverse_value_lookup_t<M, "B">, Y>);
 }
 
 TEST_CASE("reverse look up type not in map (by string value)", "[type map]") {
     using M = stdx::type_map<stdx::tv_pair<X, "A">, stdx::tv_pair<Y, "B">>;
-    STATIC_REQUIRE(
+    STATIC_CHECK(
         std::is_same_v<stdx::reverse_value_lookup_t<M, "C">, stdx::missing_t>);
-    STATIC_REQUIRE(
+    STATIC_CHECK(
         std::is_same_v<stdx::reverse_value_lookup_t<M, "C", int>, int>);
 }
 
 TEST_CASE("reverse look up value in map (by type)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<0, A>, stdx::vt_pair<1, B>>;
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, A> == 0);
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, B> == 1);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, A> == 0);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, B> == 1);
 }
 
 TEST_CASE("reverse look up value not in map (by type)", "[type map]") {
     using M = stdx::type_map<stdx::vt_pair<0, A>, stdx::vt_pair<1, B>>;
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, Z> == stdx::missing);
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, Z, 2> == 2);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, Z> == stdx::missing);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, Z, 2> == 2);
 }
 
 TEST_CASE("reverse look up string value in map (by type)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vt_pair<"A", A>, stdx::vt_pair<"B", B>>;
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, A> == "A"_cts);
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, B> == "B"_cts);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, A> == "A"_cts);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, B> == "B"_cts);
 }
 
 TEST_CASE("reverse look up string value not in map (by type)", "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vt_pair<"A", A>, stdx::vt_pair<"B", B>>;
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, Z> == stdx::missing);
-    STATIC_REQUIRE(stdx::reverse_type_lookup_v<M, Z, "C"> == "C"_cts);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, Z> == stdx::missing);
+    STATIC_CHECK(stdx::reverse_type_lookup_v<M, Z, "C"> == "C"_cts);
 }
 
 TEST_CASE("reverse look up value in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vv_pair<0, 10>, stdx::vv_pair<1, 11>>;
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, 10> == 0);
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, 11> == 1);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, 10> == 0);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, 11> == 1);
 }
 
 TEST_CASE("reverse look up value not in map (by value)", "[type map]") {
     using M = stdx::type_map<stdx::vv_pair<0, 10>, stdx::vv_pair<1, 11>>;
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, 2> == stdx::missing);
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, 2, 3> == 3);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, 2> == stdx::missing);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, 2, 3> == 3);
 }
 
 TEST_CASE("reverse look up string value in map (by string value)",
           "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vv_pair<"X", "A">, stdx::vv_pair<"Y", "B">>;
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, "A"> == "X"_cts);
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, "B"> == "Y"_cts);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, "A"> == "X"_cts);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, "B"> == "Y"_cts);
 }
 
 TEST_CASE("reverse look up string value not in map (by string value)",
           "[type map]") {
     using namespace stdx::literals;
     using M = stdx::type_map<stdx::vv_pair<"X", "A">, stdx::vv_pair<"Y", "B">>;
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, "C"> == stdx::missing);
-    STATIC_REQUIRE(stdx::reverse_value_lookup_v<M, "C", "Z"> == "Z"_cts);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, "C"> == stdx::missing);
+    STATIC_CHECK(stdx::reverse_value_lookup_v<M, "C", "Z"> == "Z"_cts);
+}
+
+namespace {
+template <auto V> struct S {
+    [[nodiscard]] friend constexpr auto operator==(S const &, S const &)
+        -> bool = default;
+};
+} // namespace
+
+TEST_CASE("operator[] lookup (type -> type)", "[type map]") {
+    using M = stdx::type_map<stdx::tt_pair<S<0>, S<100>>,
+                             stdx::tt_pair<S<1>, S<101>>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m[S<0>{}] == S<100>{});
+    STATIC_CHECK(m[S<1>{}] == S<101>{});
+    STATIC_CHECK(m[S<2>{}] == stdx::missing);
+}
+
+TEST_CASE("operator[] lookup (type -> type) (incomplete types)", "[type map]") {
+    using M = stdx::type_map<stdx::tt_pair<A, X>, stdx::tt_pair<B, Y>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m[stdx::type_identity_v<A>] == stdx::type_identity_v<X>);
+    STATIC_CHECK(m[stdx::type_identity_v<B>] == stdx::type_identity_v<Y>);
+    STATIC_CHECK(m[stdx::type_identity_v<Z>] == stdx::missing);
+}
+
+TEST_CASE("operator[] lookup (type -> value)", "[type map]") {
+    using M = stdx::type_map<stdx::tv_pair<S<0>, 0>, stdx::tv_pair<S<1>, 1>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m[S<0>{}] == 0);
+    STATIC_CHECK(m[S<1>{}] == 1);
+    STATIC_CHECK(m[S<2>{}] == stdx::missing);
+}
+
+TEST_CASE("operator[] lookup (type -> value) (incomplete types)",
+          "[type map]") {
+    using M = stdx::type_map<stdx::tv_pair<A, 0>, stdx::tv_pair<B, 1>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m[stdx::type_identity_v<A>] == 0);
+    STATIC_CHECK(m[stdx::type_identity_v<B>] == 1);
+    STATIC_CHECK(m[stdx::type_identity_v<Z>] == stdx::missing);
+}
+
+TEST_CASE("operator() lookup (value -> type)", "[type map]") {
+    using namespace stdx::literals;
+    using M =
+        stdx::type_map<stdx::vt_pair<0u, S<100>>, stdx::vt_pair<1u, S<101>>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m(0_c) == S<100>{});
+    STATIC_CHECK(m(1_c) == S<101>{});
+    STATIC_CHECK(m(2_c) == stdx::missing);
+}
+
+TEST_CASE("operator() lookup (value -> type) (incomplete types)",
+          "[type map]") {
+    using namespace stdx::literals;
+    using M = stdx::type_map<stdx::vt_pair<0u, A>, stdx::vt_pair<1u, B>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m(0_c) == stdx::type_identity_v<A>);
+    STATIC_CHECK(m(1_c) == stdx::type_identity_v<B>);
+    STATIC_CHECK(m(2_c) == stdx::missing);
+}
+
+TEST_CASE("operator() lookup (value -> value)", "[type map]") {
+    using namespace stdx::literals;
+    using M = stdx::type_map<stdx::vv_pair<0u, 100>, stdx::vv_pair<1u, 101>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m(0_c) == 100);
+    STATIC_CHECK(m(1_c) == 101);
+    STATIC_CHECK(m(2_c) == stdx::missing);
+}
+
+TEST_CASE("operator() lookup (string -> string)", "[type map]") {
+    using namespace stdx::literals;
+    using M = stdx::type_map<stdx::vv_pair<"A", "X">, stdx::vv_pair<"B", "Y">>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m("A"_ctst) == "X"_cts);
+    STATIC_CHECK(m("B"_ctst) == "Y"_cts);
+    STATIC_CHECK(m("C"_ctst) == stdx::missing);
+}
+
+TEST_CASE("multi-depth lookup", "[type map]") {
+    using namespace stdx::literals;
+    using P = stdx::type_map<stdx::vv_pair<"1", "L">, stdx::vv_pair<"2", "M">>;
+    using Q = stdx::type_map<stdx::vv_pair<"1", "N">, stdx::vv_pair<"2", "O">>;
+    using M = stdx::type_map<stdx::vt_pair<"A", P>, stdx::vt_pair<"B", Q>>;
+    constexpr auto m = M{};
+    STATIC_CHECK(m("A"_ctst)("1"_ctst) == "L"_cts);
+    STATIC_CHECK(m("A"_ctst)("2"_ctst) == "M"_cts);
+    STATIC_CHECK(m("B"_ctst)("1"_ctst) == "N"_cts);
+    STATIC_CHECK(m("B"_ctst)("2"_ctst) == "O"_cts);
 }