struct successful_result_t { ... };
struct failed_result_t { ... };

struct reply_t {
  request_id_t id_;
  worker_id_t worker_;
  std::variant<successful_result_t, failed_result_t> result_;

  template<typename Actual_Result>
  reply_t(request_id_t id, worker_id_t worker, Actual_Result && result)
    : id_{std::move(id)}, worker_{std::move(worker)}
    , result_{std::forward<Actual_Result>(result)}
  {}
};

return reply_t{id, self, successful_result_t{...}};

return reply_t{id, self, failed_result_t{...}};

struct successful_result_t { ... };
S>struct failed_result_t { ... };

S>struct reply_t {
S>  request_id_t id_;
S>  worker_id_t worker_;
S>  std::variant<successful_result_t, failed_result_t> result_;

S>  template<typename Actual_Result>
S>  reply_t(request_id_t id, worker_id_t worker, Actual_Result && result)
S>    : id_{std::move(id)}, worker_{std::move(worker)}
S>    , result_{std::forward<Actual_Result>(result)}
S>  {}
S>};

return reply_t{id, self, successful_result_t{...}};

return reply_t{id, self, failed_result_t{...}};

struct result_t
{
   bool successful ;
   ...
}

struct result_t { ... };

// в случае ошибки
throw -1 ; // тогда тебе просто не нужны данные failed_result_t

template <typename C>
void print (const C &c)
{
    if constexpr (std::is_same_v<C, std::vector<int>>) {
        cout << "vector<int>: ";
    }

    if constexpr (std::is_same_v<C, std::list<int>>) {
        cout << "list<int>:   ";
    }

    if constexpr (std::is_same_v<C, std::deque<int>>) {
        cout << "deque<int>:  ";
    }

    for (auto i : c)
    {
        cout << i << ", ";
    }
    cout << '\n';
}

Вы вместе с вашими матерыми C++ разработчиками вместо этого предлагаете что?

E>Ну вы хамите побольше

Это всего лишь означает, что ты не умеешь контролировать их "расползание" по коду...

Это, кстати, хорошее упражнение...Попробуешь сам?

Why don't you use this awesome C++ feature?

Box2D is designed to be portable, so I try to keep the C++ usage simple. Also, I don't use the STL (except sort) or other libraries to keep the dependencies low. I keep template usage low and don't use name spaces. Remember, just because a C++ feature exists, that doesn't mean you need to use it.

The many ports of Box2D to other languages platforms shows that this strategy has been successful.

struct successful_result_t {
  A a_;
  B b_;
  C c_;
  ... // Конструктор/деструктор и пр. лабуда.
};

struct failed_result_t {
  D d_;
  E e_;
  ... // Конструктор/деструктор и пр. лабуда.
};

struct successful_result_t {
S>  A a_;
S>  B b_;
S>  C c_;
S>  ... // Конструктор/деструктор и пр. лабуда.
S>};

S>struct failed_result_t {
S>  D d_;
S>  E e_;
S>  ... // Конструктор/деструктор и пр. лабуда.
S>};
S>

struct result_t {
   bool successful ;
   A a_;
   B b_;
   C c_;
   D d_;
   E e_;
// Конструктор/деструктор и пр. лабуда.
};

class reply_t final {
  ...
  std::variant<successful_result_t, failed_result_t> result_;
public:
  ...
  bool successful() const noexcept { return std::holds_alternative<successful_result_t>(result_); }

  template<typename L>
  decltype(auto) on_success(L handler) const {
    return handler(std::get<successful_result_t>(result_));
  }

  bool failed() const noexcept { return std::holds_alternative<failed_result_t>(result_); }
  ...
};
...
auto reply = receive_reply();
if(reply.successful())
  return reply.on_success([](const auto & d) {...});
else ...

struct reply_t {
  using result_t = std::variant<successful_result_t, failed_result_t>;
  ...
  result_t result_;

  reply_t(request_id_t id, worker_id_t id, result_t result);
};

namespace Foo {
namespace Bar { class A; class B; }
namespace Buzz { 
    class C;
    ...
}
}

struct reply_t {
S>  using result_t = std::variant<successful_result_t, failed_result_t>;
S>  ...
S>  result_t result_;

S>  reply_t(request_id_t id, worker_id_t id, result_t result);
S>};

CK>namespace Foo {
CK>namespace Bar { class A; class B; }
CK>}

Avoid complicated template programming.

The techniques used in template metaprogramming are often obscure to anyone but language experts. Code that uses templates in complicated ways is often unreadable, and is hard to debug or maintain.

Template metaprogramming often leads to extremely poor compiler time error messages: even if an interface is simple, the complicated implementation details become visible when the user does something wrong.

Template metaprogramming interferes with large scale refactoring by making the job of refactoring tools harder. First, the template code is expanded in multiple contexts, and it's hard to verify that the transformation makes sense in all of them. Second, some refactoring tools work with an AST that only represents the structure of the code after template expansion. It can be difficult to automatically work back to the original source construct that needs to be rewritten.

  template<typename Actual_Result>
  reply_t(request_id_t id, worker_id_t worker, Actual_Result && result)
    : id_{std::move(id)}, worker_{std::move(worker)}
    , result_{std::forward<Actual_Result>(result)}
  {}

  reply_t(request_id_t id, worker_id_t worker, successful_result_t result)
    : id_{std::move(id)}, worker_{std::move(worker)}
    , result_{std::move(result)}
  {}
  reply_t(request_id_t id, worker_id_t worker, failed_result_t result)
    : id_{std::move(id)}, worker_{std::move(worker)}
    , result_{std::move(result)}
  {}

Q> Тут за примером мне далеко идти не придётся 

А: Про программистов на C++ ходит такой еще слух (нам, сторонним людям, очень интересно, что ты скажешь о слухах, которые ходят о Яндексе), что у вас там сплошные шаблоны на шаблонах, и метапрограммирование на шаблонах, ехал шаблон через шаблон. Это правда, или это в другом отделе, или этого вообще нет?

АЮ: Там есть стандартная библиотека своя. И в самих нутрях ее, конечно же, шаблоны, иначе ей невозможно пользоваться. И, порой, шаблон на шаблоне. А иногда и шаблон на шаблоне на шаблоне, это понятно. Но снаружи это не особо видно. То есть, один раз этот код написан. Он сложный, он шаблонизирован, но он отлажен, покрыт тестами, и, в принципе, на этом заканчивается. В прикладных программах, у тебя один шаблон, в смысле, вложенность. Ну, две, но не больше. Плюс, использование шаблонов, как замена функциональному программированию, особо не приветствуется из-за сложности отладки.

А: Метапрограммированию, наверное?

АЮ: Ну, и это тоже, да.

E>Разве я что-то говорил про чей-то код?

Это всего лишь означает, что ты не умеешь контролировать их "расползание" по коду...

E>Чем variant отличается от динамического полиморфизма? Тип объекта определяется его значением...

void transformer::handle(channel & reply_ch, const request & req) {
  try {
    auto transformed_data = some_external_function(req.source_data(), req.transformation_params());
    ... // Что-то еще.
    reply_ch.send(reply_t{req.id(), self_id(), successful_result_t{..., std::move(transformed_data), ...});
  }
  catch(const exception & x) {
    ... // Что-то...
    reply_ch.send(reply_t{req.id(), self_id(), failed_result_t{..., x.what(), ...});
  }
}