Измените исследование времени выполнения на время компиляции

Во-первых, нет необходимости использовать to_tuple(tuple_t<...>); вы можете просто использовать tuple_t<...>. Теперь я думаю, что вы на самом деле хотите сделать (поскольку вам, похоже, нужно хранилище во время выполнения, что имеет смысл):

// "map" of a set of types to a storage of some type
using StorageMap = hana::tuple<
  hana::pair<hana::tuple<hana::type<C1>, hana::type<C2>>, StorageA>,
  hana::pair<hana::tuple<hana::type<C3>>, StorageB>
>;
// Actual object that contains the runtime storage (and the free mapping between types)
StorageMap map;

Теперь вы можете реализовать свою функцию getStorage<Component>() следующим образом:

template <typename Component>
decltype(auto) getStorage() {
  auto found = index_if(map, [](auto const& pair) {
    return hana::contains(hana::first(pair), hana::type<Component>{});
  });
  return hana::second(hana::at(map, found));
}

где index_if — это тривиальный вариант функции, представленной в этом ответе, который будет работать с произвольным предикатом вместо определенного элемента. Эта функция будет добавлена ​​в Hana, когда у меня будет свободное время (см. соответствующий запрос) .

Похоже, вы пытаетесь создать карту, которая может искать один экземпляр с использованием разных ключей. Вот фрагмент из старой реализации, которую я написал. Я немного изменил его, но он должен передать идею.

namespace detail {
    // extractKeys - returns pairs of each element and itself
    struct extract_keys_fn
    {
        template<typename TypesType>
        constexpr auto operator()(TypesType s) const {
            return decltype(hana::unpack(typename TypesType::type{},
                hana::make_tuple
                ^hana::on^
                hana::reverse_partial(hana::make_pair, s)
            )){};
        }
    };
    constexpr extract_keys_fn extract_keys{};
}//detail

template<typename ...Pair>
struct multi_map
{
    // the keys must be `type<tuple<path...>>`
    using Storage = decltype(hana::make_map(std::declval<Pair>()...));

    // each key is a hana::tuple which contain the keys we
    // want to use to lookup an element
    using Lookup = decltype(hana::unpack(
        hana::flatten(hana::unpack(hana::keys(std::declval<Storage>()),
            hana::make_tuple ^hana::on^ detail::extract_keys)),
        hana::make_map
    ));

    constexpr multi_map()
        : storage()
    { }

    constexpr multi_map(Pair&&... p)
        : storage(hana::make_map(std::forward<Pair>(p)...))
    { }

    constexpr multi_map(Pair const&... p)
        : storage(hana::make_map(p...))
    { }

    constexpr multi_map(Pair&... p)
        : storage(hana::make_map(p...))
    { }

    template<typename T>
    constexpr decltype(auto) operator[](T t) const&
    {
        return hana::at_key(storage, hana::at_key(Lookup{}, t));
    }

    template<typename T>
    constexpr decltype(auto) operator[](T t) &
    {
        return hana::at_key(storage, hana::at_key(Lookup{}, t));
    }

    template<typename T>
    constexpr decltype(auto) operator[](T t) &&
    {
        return hana::at_key(storage, hana::at_key(Lookup{}, t));
    }

    Storage storage;
};

Суть того, что происходит выше, заключается в том, что storage — это hana::map, содержащий экземпляры, на которые вам нужны ссылки. Тогда Lookup является hana::map, указывающим каждому ключу на ключ, который используется в storage (который является кортежем всех ключей, которые на него указывают). По сути, это просто карта для сопоставления, но с ее помощью вы можете получить ссылку на один экземпляр, используя любой из ключей.