void pay_order(Order o, Payment p)
{
   
    Assert(o.PaymentStatus != PaymentStatus.Paid, "An order cannot be paid twice. Detach an existing payment from order prior to attaching another payment");
    Assert(p.UsedFor == null, "This payment is already used to pay another order");
    Assert(o.Amount == p.Amount, "Payment amount must exactly match the order amount");
    Assert(p.Status >= Verified, "Only verified payments can be used to pay the orders");
    
    p.UsedFor = o;
    o.Payment = p;
    o.PaymentStatus = PaymentStatus.Paid;
}

void goods_arrived(Goods g) {
  for( Order& o: orders_in_db() ) {
    if ( o.contains(g) ) {
      // do lots of stuff: mark arrived goods as available etc...
      request_payment(o);
    }
  }
}

O request_payment(O o) { ... }

void goods_arrived(Goods g) {
  for( Order& o: orders_in_db() ) {
    if ( o.contains(g) ) {
      // do lots of stuff: mark arrived goods as available etc...
      if ( !payed(o) ) { // <<< вот этот вот if программер забыл
        request_payment(o);
      }
    }
  }
}

struct Payed;

template<class O>
typename boost::enable_if< CheckExact< O, Payed, bm::false_ >, O >::type
request_payment(O o) { ... }

void goods_arrived(Goods g) {
  for( Order& o: orders_in_db() ) {
    if ( o.contains(g) ) {
      // do lots of stuff: mark arrived goods as available etc...
      PROP_IF_NOT( unpayed_o, payed(o), Payed ) { // <<< без вот этого if
        request_payment(unpayed_o);               // <<< эта строчка не скомпилируется
        // (я тут даже переименовал o в unpayed_o для наглядности, хотя можно было и о оставить)
      }
    }
  }
}

S>void pay_order(Order o, Payment p)
S>{
   
S>    Assert(o.PaymentStatus != PaymentStatus.Paid, "An order cannot be paid twice. Detach an existing payment from order prior to attaching another payment");
S>    Assert(p.UsedFor == null, "This payment is already used to pay another order");
S>    Assert(o.Amount == p.Amount, "Payment amount must exactly match the order amount");
S>    Assert(p.Status >= Verified, "Only verified payments can be used to pay the orders");
    
S>    p.UsedFor = o;
S>    o.Payment = p;
S>    o.PaymentStatus = PaymentStatus.Paid;
S>}
S>

public void process(Order o){
// программисты любят забыть эту проверку
//  if (o == null) throw ...
o.amount += 10; .. //ой

public void process(Optiona<Order> o){
o.amount += 10; .. //не скомпилировалось

order.amount = 10.usd + 10.eur  // не скомпилировалось

M>Так как задача достаточно изолированна, то можно придумать себе какие угодно условия. Попробовать и так и так Как видим, пока проблема в том, что ни у кого не получается ничего придумать

public void HandleDelivery(Order newOrder)
{
   var previousOrder = GetExistingCustomerOrders(newOrder.Customer).FirstOrDefault();
   if (previousOrder != null)
   {
     MergeNewOrderIntoAPreviousOrder(previousOrder, newOrder); // ARRGH! there is no implicit conversion from Order to OrderThatAllowsIncreasingAmount
     SubmitforDelivery(previousOrder);
   }
   else
     SubmitForDelivery(newOrder);
   
}

public void HandleDelivery(Order newOrder)
{
   var previousOrder = GetExistingCustomerOrdersAllowedForAmountIncrease(newOrder.Customer).FirstOrDefault();
   if (previousOrder != null)
   {
     MergeNewOrderIntoAPreviousOrder(previousOrder, newOrder); // Compiler's happy
     SubmitforDelivery(previousOrder);
   }
   else
     SubmitForDelivery(newOrder);
   
}

public void HandleDelivery(Order newOrder)
{
   var previousOrder = GetExistingCustomerOrders(newOrder.Customer).FirstOrDefault();
   if (previousOrder != null)
   {
     MergeNewOrderIntoAPreviousOrder(EnsureOrderAllowsIncreasingAmount(previousOrder), newOrder); // ARRGH! Runtime exception.
     SubmitforDelivery(previousOrder);
   }
   else
     SubmitForDelivery(newOrder);
   
}