struct Order
{
  int id;
  bool shipped, prepaid_, risk;
  double amount;

  // эти строчки просто для разных способов определения свойств ордера, помимо o.shipped
  bool prepaid() const { return prepaid_; }
  friend bool has_risk(const Order& o) { return o.risk; }
};

struct HasRisk; // Свойство, которое мы хотим проверять в compile time

// предикат (CheckExact - это проверка того, что свойство HasRisk строго равно false.
//           понятно, что можно сделать другие предикаты, типа AtLeast и т.п.)
template<class O> using can_increase_amount = CheckExact< O, HasRisk, bm::false_ >;

//разрешаем (enable_if) функцию только если проверка прошла
template<class O>
typename boost::enable_if< can_increase_amount<O>, O >::type
increase_amount(O o, double incr)
{
  std::cout << "increasing amount of order " << unwrap(o) << " by " << incr << std::endl;
  unwrap(o).amount += incr;
  return o;
}

// ругнемся, чтоб программеру было понятно, что он написал что-то не то.
// в принципе, эту функцию можно и не писать, но тогда сообщение об ошибке 
// будет слишком загадочным ("функция не найдена")
template<class O>
typename boost::disable_if< can_increase_amount<O>, O >::type
increase_amount(O o, double incr)
{
  BOOST_MPL_ASSERT_MSG(false, YOU_CANT_INCREASE_AMOUNT_FOR_SUCH_ORDER, (O));
  return o;
}

void try_to_change_amount(Order& o)
{
  //increase_amount(o, 2.71);  - не скомпилируется: мы ничего не знаем о риске
  
  PROP_IF(o, has_risk(o), HasRisk) {
    //increase_amount(o, 2.71); - не скомпилируется: ордер помечен как рисковый
  }
  PROP_ELSE(o) {
    increase_amount(o, 2.71);
  };

error: ************::YOU_CANT_INCREASE_AMOUNT_FOR_SUCH_ORDER::************(Type<Order&, mpl::map<_{HasRisk:true_ }> >)

если товар помечен, как risk, то изменять сумму нельзя

если заказ отправлен, нельзя увеличивать, можно уменьшать

struct Shipped; // новое свойство

template<class O> using can_increase_amount =
    bm::and_< CheckExact< O, HasRisk, bm::false_ >
            , CheckExact< O, Shipped, bm::false_ > // новое ad-hoc требование
            >;

error: ************::YOU_CANT_INCREASE_AMOUNT_FOR_SUCH_ORDER::************(Type<Order&, mpl::map<_{HasRisk:false_ }> >)

void try_to_change_amount(Order& o)
{
  PROP_IF(o, has_risk(o), HasRisk) {
    // сообщить об ошибке
  }
  PROP_ELSE(o) {
    // increase_amount(o, 2.71); -- больше не работает: надо проверять Shipped
    PROP_IF(o, o.shipped, Shipped ) {
      //increase_amount(o, 2.71); // (*)
      // сообщить об ошибке
    }
    PROP_ELSE(o) {
      increase_amount(o, 2.71);
    };
  };

error: ************::YOU_CANT_INCREASE_AMOUNT_FOR_SUCH_ORDER::************(Type<Order&, mpl::map<_{HasRisk:false_ }, _{Shipped:true_}> >)

template<class O>
typename boost::enable_if< IncreaseAmountOK<O>, O >::type
increase_amount(O o, double incr);

void try_to_change_amount(Order& o, double new_amt)
{
  PROP_IF(o, can_increase_amount(o, new_amt), IncreaseAmountOK) {
    increase_amount(o, new_amt);
  };
}

template<class OrderAndAmount>
typename boost::enable_if< IncreaseAmountOK<OrderAndAmount>, OrderAndAmount >::type
increase_amount(OrderAndAmount oa)
{
  unwrap(oa.order).amount += oa.amount;
}

void try_to_change_amount(Order& o, double new_amt)
{
  PROP_IF(order_and_amount, can_increase_amount(o, new_amt), IncreaseAmountOK) {
    increase_amount(order_and_amount);
  };
}

A>Задача стала интересна сама по себе, безотносительно Мамута и попыток ему что-то объяснить или доказать.

// no idea why parens are needed around, probably a GCC bug
#define PROP_IF(object, getter, property) \
  if (auto ifres = \
        bool_result<property>( object \
                             , ([&object = unwrap(object)]{return getter;})() /*this is just a boolean expr*/ \
                             ) ) run_lambda*[object = ifres.yes()]

#define PROP_ELSE(object) ; else run_lambda*[object = ifres.no()]

struct RunLambda
{
  template<class F>
  void operator*(F f) const { f(); }
} run_lambda;

template< class T, class Prop>
struct bool_result_t
{
  T& object;
  bool val;
  
  auto yes() const { return add_prop<Prop, bm::true_ >(object); }
  auto no()  const { return add_prop<Prop, bm::false_>(object); }
  explicit operator bool() const { return val; }
};

template< class Prop, class T>
auto bool_result( T& x, bool val ) { return bool_result_t<T, Prop>{ x, val }; }

#define PROP_IF(property, object, ...) \
  if (auto ifres = \
        bool_result<property>( object \
                             , property ## CheckProp(object, __VA_ARGS__) \
                             ) ) run_lambda*[object = ifres.yes()]

struct HasRisk;

template<typename O>
bool HasRiskCheckProp(O& o)
{
  return has_risk(unwrap(o));
}

struct Shipped;

template<typename O>
bool ShippedCheckProp(O& o)
{
  return unwrap(o).shipped;
}

void try_to_change_amount(Order& o)
{
  PROP_IF(HasRisk, o) {
    // сообщить об ошибке
  }
  PROP_ELSE(o) {
    // increase_amount(o, 2.71); -- больше не работает: надо проверять Shipped
    PROP_IF(Shipped, o) {
      //increase_amount(o, 2.71); // (*)
      // сообщить об ошибке
    }
    PROP_ELSE(o) {
      increase_amount(o, 2.71);
    };
  };

struct IncreaseAmountOK;

template<typename O>
bool IncreaseAmountOKCheckProp(O& o, double new_amt)
{
  return can_increase_amount(unwrap(o), new_amt);
}

void try_to_change_amount(Order& o, double new_amt)
{
  PROP_IF(IncreaseAmountOK, o, new_amt) {
    increase_amount(o, new_amt);
  };
}

struct HasRisk;

template<typename O>
bool CheckProp(HasRisk, O& o);

// or:

template<typename O>
bool CheckProp(Property<HasRisk>, O& o);

struct HasRisk
{
  template<typename O>
  bool operator()(O& o) const {
    return has_risk( unwrap(o) );
  }
};

struct HasRisk: bool_result_t {...};

J>>void try_to_change_amount(Order& o)

template<class O>
void try_to_change_amount(O& o);

template<class O>
void try_to_change_amount(O& o);

Цитата: Any dev can build systems without worrying about implementation internals. Just fit types together

Возражение: После чего в пятницу вечером сервер ложится и не поднимается, потому что какой-то новичок написал код, позволяющий создавать отчеты о продажах за целый год, что начало поднимать с диска терабайты данных в память. А что? API-вызов всего лишь требует типа TDate

orderIds = order_table.get_all_ids()

foreach(table in archived_order_tables):
  ids = table.get_all_ids()
  orderIds.append(ids)

sort(orderIds)

filter(OrderIds, определенное_условие)

M>Охохонюшки. Опять только один статус и только одна проверка У нас в рантайме все хорошо и без типов и трансляторов И да, у нас можно изменять сумму после отправки И условий, при которых нельзя — с десяток. Создавать десяток классов?

struct AnotherClass;