poignée type partiel avec Boost Hana

Question

Ce que j'appelle un type partiel ici est quelque chose comme ça:

template < template <typename ...> typename Skeleton, 
      template <typename ...> typename WrapperType, 
      typename ... Pölicies > 
struct MetaStorage { 

    template < typename ... Ts > 
    struct With_Type { 

    using type = Skeleton<WrapperType<Ts...>, Policies...>; 
    }; 
}; 

using partialType = MetaStorage<Sk, Wt, P1, P2, P3>; 
using finalType = partialType::With_Type<T1, T2>; 

Je ne pense pas que cela correspond bien à la philosophie de hana et ce n'est pas lisible si je veux diviser le type plus que cela.

Alors, quel est le moyen efficace de le faire avec Boost Hana?

Edit:

Je veux dire, une façon de permettre à l'utilisateur de créer le dernier type en plusieurs étapes. Comme ça, ils peuvent utiliser un type partiel pour générer chaque type final. Mais avec la syntaxe habituelle et hana::type.

Answer 1

Avec Boost.Hana vous pouvez soulever les types de valeurs avec hana::type et même avec des modèles utilisant hana::template_. Avec cela, vous pouvez effectuer les opérations suivantes:

#include <boost/hana.hpp> 

namespace hana = boost::hana; 


template <typename ...X> struct skeleton_t { }; 
constexpr auto skeleton = hana::template_<skeleton_t>; 
template <typename ...X> struct wrapper_t { }; 
constexpr auto wrapper = hana::template_<wrapper_t>; 
template <int i> struct policy_t { }; 
template <int i> constexpr auto policy = hana::type_c<policy_t<i>>; 
template <int i> struct foo_t { }; 
template <int i> constexpr auto foo = hana::type_c<foo_t<i>>; 

int main() { 
    auto meta_storage = [](auto s, auto w, auto ...policies) { 
    return [=](auto ...ts) { 
     return s(w(ts...), policies...); 
    }; 
    }; 

    auto partial = meta_storage(skeleton, wrapper, policy<1>, policy<2>); 

    auto final_ = partial(foo<1>, foo<2>); 

    skeleton_t<wrapper_t<foo_t<1>, foo_t<2>>, policy_t<1>, policy_t<2>> check 
    = typename decltype(final_)::type{}; 
} 

Personnellement, je préfère ne pas se soucier de hana::template_ dans les cas où je peux utiliser une fonction. J'utilise également une macro pour créer un type de tag avec sa valeur hana::type correspondante pour réduire une partie de la configuration que vous voyez au-dessus de la fonction principale.