Re: [Boost-users] eval_if fails - problem for C++ guru

Subject: Re: [Boost-users] eval_if fails - problem for C++ guru
From: Lee Clagett (forum_at_[hidden])
Date: 2015-06-06 23:45:00

On Sat, Jun 6, 2015 at 10:22 PM, Robert Ramey <ramey_at_[hidden]> wrote:

>
> I've been having a very difficult time with a problem illustrated by the
> following program: It looks like the eval_if in line 51 isn't working
> correctly. That is, the metafuction get_promotion_policy is being invoked
> when both types are not safe types. I've been working on this for two days
> and can't see what's going on. Any help from a TMP genious would be much
> appreciated.
>
> #include <type_traits>
> #include <boost/mpl/and.hpp>
> #include <boost/mpl/or.hpp>
> #include <boost/mpl/if.hpp>
> #include <boost/mpl/eval_if.hpp>
> #include <boost/mpl/identity.hpp>
>
> struct safe_tag {};
>
> template<class T, class P = void>
> struct safe : public safe_tag {
>     T m_t;
>     typedef P PromotionPolicy;
> };
>
> template<class T>
> struct is_safe : public
>     //std::is_arithmetic<T>
>     std::is_base_of<safe_tag, T>
> {};
>
> template<class T, class U>
> struct common_policies {
>     static_assert(
>         boost::mpl::or_<
>             is_safe<T>,
>             is_safe<U>
>         >::value,
>         "at least one type must be a safe type"
>     );
>
>     template<typename Z>
>     struct get_promotion_policy {
>         static_assert(
>             is_safe<Z>::value,
>             "only safe types have promotion policies"
>         );
>         typedef typename Z::PromotionPolicy type;
>     };
>
>
>     // if both types are safe, the policies have to be the same!
>     static_assert(
>         boost::mpl::eval_if<
>             boost::mpl::and_<
>                 is_safe<T>,
>                 is_safe<U>
>             >,
>             typename std::is_same<
>                 typename get_promotion_policy<T>::type,
>                 typename get_promotion_policy<U>::type
>             >::type,
>             boost::mpl::identity<boost::mpl::true_>
>         >::type::value,
>         "if both types are safe, the policies have to be the same!"
>     );
>
>     // now we've verified that there is no conflict between policies
>     // return the one from the first safe type
>     typedef typename boost::mpl::if_<
>         is_safe<T>,
>         T,
>     typename boost::mpl::if_<
>         is_safe<U>,
>         U,
>     //
>         boost::mpl::void_
>     >::type
>     >::type safe_type;
>
>     typedef typename get_promotion_policy<safe_type>::type
> promotion_policy;
>
> };
>
> common_policies<int, safe<int> > t;
>
> int main(){
>     return 0;
> }
>
>
The problem are the immediate instantations of `typename
get_promotion_policy<T>::type` which cause the static assert to be
instantiated too. You need to delay instantating ::type in these objects
until std::is_same needs to be evaluated. I don't know know of a way to do
this with standard MPL (see
https://abel.web.elte.hu/mpllibs/metamonad/lazy.html ), but one easy way
with C++11 (if metaparse is not an option):

    template<template<typename...> class F, typename... A>
    struct lazy_eval
    {
        using type = typename F<typename A::type...>::type;
    };

    // if both types are safe, the policies have to be the same!
    static_assert(
        boost::mpl::eval_if<
            boost::mpl::and_<
                is_safe<T>,
                is_safe<U>
            >,
            lazy_eval<
                std::is_same,
                get_promotion_policy<T>,
                get_promotion_policy<U>
            >,
            boost::mpl::identity<boost::mpl::true_>
        >::type::value,
        "if both types are safe, the policies have to be the same!"
    );

which will work with any metafunction F that accepts 1 or more arguments.
There might be some way to re-write what you are trying to avoid this, but
I haven't put much thought into that.

Lee