On Sat, Jun 6, 2015 at 10:22 PM, Robert Ramey <ramey@rrsd.com> 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
>::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
>,
typename std::is_same<
typename get_promotion_policy<T>::type,
typename get_promotion_policy::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,
//
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
 >,
 lazy_eval<
 std::is_same,
 get_promotion_policy<T>,
 get_promotion_policy
 >,
 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