namespace table {
   template<typename T, T v>
   struct value_impl {
       static constexpr inline auto value = v;
       constexpr inline value_impl() { };
       constexpr inline value_impl(T value_) { static_assert(value_ == v); }
       constexpr inline operator T() { return v; }
   };

   template<auto v, typename T = decltype(v)>
   using value = value_impl<T, v>;

   template<typename T>
   struct dec {
       friend constexpr auto get(dec);
   };

   template<typename Src, typename Dst>
   struct inj {
       friend constexpr auto get(Src) {
           return Dst{};
       }
   };

   template <typename Src, typename Dst>
   constexpr inline bool map = sizeof(inj<dec, Dst>);

   template <typename Key, typename = void>
   struct unmap_type {};

   template <typename Key>
   struct unmap_type<Key, std::void_t<decltype(get(dec{}))>> {
       using type = decltype(get(std::declval<dec>()));
   };
   
   template <typename T, typename = void>
   struct unmap_value {};

  …