std::vector<std::function<R, Args...>> passes = { &free_fun, [](){ lambda}, std::mem_fn(&klass::method, &obj) };
for (auto &&pass : passes)
{
     pass(args...);
}

Давайте посмотрим на код, в чем здесь проблема? Мы видим, что в этой иерархии методы запуска прохода различны в зависимости от того, над чем они должны выполняться (над функцией — runOnFunction, модулем — runOnModule, циклом — runOnLoop и тд). В свою очередь, это делает невозможным обрабатывать коллекцию проходов, которые работают с разными IR сущностями, единым способом (собственно применять полиморфизм). Казалось бы, очевидно, как сделать правильно: нужен виртуальный метод run, который будет переопределяться в наследниках. Но тут же возникает проблема: у методов run в классах-наследниках будет разная сигнатура, поскольку передается параметр всегда своего типа — функция, модуль и так далее. Значит, придется делать фиктивный базовый класс для Module, Function и т.д., передавать в run указатель на этот класс, а внутри метода делать down-cast, в зависимости от того, что за объект находится по данному указателю. И начинается что-то странное: при появлении новой нижестоящей сущности мы вынуждены теперь переписывать каждый раз вышестоящий код, что противоречит всем принципам проектирования.

BFE>

Занимается разработкой компилятора нейронных сетей для NPU (Neural Processing Unit) в российском центре Samsung R&D. Скомпилированные нейронные сети поставляются в составе флагманских телефонов Samsung, таких как Galaxy Note 10.
Имеется опыт разработки оптимизирующего компилятора под VLIW-архитектуру «Эльбрус» и архитектуру SPARC с языков C, C++, Fortran. В процессе разработки оптимизирующего компилятора, занимался реализацией:

• платформозависимых и платформонезависимых оптимизаций;
  
• оптимальной обработки исключений С++ (zero-cost exception handling) в части middle-end компилятора;
  
• санитайзеров: AddressSanitizer, MemorySanitizer, LeakSanitizer, включая портирование библиотеки compiler-rt на платформу «Эльбрус».

BFE>>>

(это же писатели компилятора или кто?

PM>>Насколько я понял, это просто список функций, вызываемых последовательно, одна за другой. Зачем-то его обзвали Manager

template <typename IR, typename... ArgTs> class PassManager {
  std::vector<std::unique_ptr<detail::PassConcept<IR, ArgTs...>>> Passes;
};

template <typename IR, typename... ArgTs> class PassManager {
  std::vector<std::function<R, Args...>> Passes;
};

Давайте посмотрим на код, в чем здесь проблема? Мы видим, что в этой иерархии методы запуска прохода различны в зависимости от того, над чем они должны выполняться (над функцией — runOnFunction, модулем — runOnModule, циклом — runOnLoop и тд). В свою очередь, это делает невозможным обрабатывать коллекцию проходов, которые работают с разными IR сущностями, единым способом (собственно применять полиморфизм). Казалось бы, очевидно, как сделать правильно: нужен виртуальный метод run, который будет переопределяться в наследниках. Но тут же возникает проблема: у методов run в классах-наследниках будет разная сигнатура, поскольку передается параметр всегда своего типа — функция, модуль и так далее.

Значит, придется делать фиктивный базовый класс для Module, Function и т.д.

template< typename T > T min(T a, T b);

// Классический ООП с динамическим полиморфизмом.
class Provider {
public:
  virtual void f() = 0;
  ...
};

class ConsumerOne {
  Provider & provider_;
...
  void g() { provider_.f(); }
};

class ConsumerTwo {
  Provider & provider_;
...
  void g() { provider_.f(); }
};

class ActualProviderOne : public Provider {...};
class ActualProviderTwo : public Provider {...};

ActualProviderOne provider_one;
ConsumerOne consumer_one{provider_one};
consumer_one.g();

ActualProviderTwo provider_two;
ConsumerTwo consumer_two{provider_two};
consumer_two.g();

// Альтернатива на базе параметрического полиморфизма.
template< typename ProviderT >
class ConsumerOne {
  ProviderT & provider_;
...
  void g() { provider_.f(); }
};

template< typename ProviderT >
class ConsumerTwo {
  ProviderT & provider_;
...
  void g() { provider_.f(); }
};

class ActualProviderOne {...};
class ActualProviderTwo {...};

ActualProviderOne provider_one;
ConsumerOne<ActualProviderOne> consumer_one{provider_one};
consumer_one.g();

ActualProviderTwo provider_two;
ConsumerTwo<ActualProviderTwo> consumer_two{provider_two};
consumer_two.g();

template< typename T > T min(T a, T b);

S>// Классический ООП с динамическим полиморфизмом.
S>class Provider {
S>public:
S>  virtual void f() = 0;
S>  ...
S>};

S>class ConsumerOne {
S>  Provider & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ConsumerTwo {
S>  Provider & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ActualProviderOne : public Provider {...};
S>class ActualProviderTwo : public Provider {...};

S>ActualProviderOne provider_one;
S>ConsumerOne consumer_one{provider_one};
S>consumer_one.g();

S>ActualProviderTwo provider_two;
S>ConsumerTwo consumer_two{provider_two};
S>consumer_two.g();
S>

S>// Альтернатива на базе параметрического полиморфизма.
S>template< typename ProviderT >
S>class ConsumerOne {
S>  ProviderT & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>template< typename ProviderT >
S>class ConsumerTwo {
S>  ProviderT & provider_;
S>...
S>  void g() { provider_.f(); }
S>};

S>class ActualProviderOne {...};
S>class ActualProviderTwo {...};

S>ActualProviderOne provider_one;
S>ConsumerOne<ActualProviderOne> consumer_one{provider_one};
S>consumer_one.g();

S>ActualProviderTwo provider_two;
S>ConsumerTwo<ActualProviderTwo> consumer_two{provider_two};
S>consumer_two.g();
S>

#include <functional>


class ConsumerOne
{
  public:
  std::function<void()> provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  std::function<void()> provider_;
  void g() { provider_(); }
};

class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  auto f_one = [&provider_one](){ provider_one.Function_f(); };
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  return 0;
}

BFE>#include <functional>


BFE>class ConsumerOne
BFE>{
BFE>  public:
BFE>  std::function<void()> provider_;

BFE>  void g() { provider_(); }
BFE>};

BFE>class ConsumerTwo
BFE>{
BFE>  public:
BFE>  std::function<void()> provider_;
BFE>  void g() { provider_(); }
BFE>};

BFE>class ActualProviderOne
BFE>{
BFE>   public:
BFE>     void Function_f()
BFE>     {
BFE>     }
BFE>};

BFE>class ActualProviderTwo
BFE>{
BFE>   public:
BFE>     void Function_f(int n)
BFE>     {
BFE>     }
BFE>};


BFE>int main(int argc, char* argv[])
BFE>{
BFE>  ActualProviderOne provider_one;
BFE>  auto f_one = [&provider_one](){ provider_one.Function_f(); };
BFE>  ConsumerOne consumer_one{f_one};
BFE>  consumer_one.g();

BFE>  ActualProviderTwo provider_two;
BFE>  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
BFE>  ConsumerTwo consumer_two{f_two};
BFE>  consumer_two.g();

BFE>  ConsumerOne consumer_one_two{f_two};
BFE>  ConsumerTwo consumer_two_one{f_one};

BFE>  consumer_one_two.g();
BFE>  consumer_two_one.g();

BFE>  return 0;
BFE>}
BFE>

struct ProviderCaller {
  virtual void operator()() = 0;
};

class ConsumerOne
{
  public:
  ProviderCaller & provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  ProviderCaller & provider_;

  void g() { provider_(); }
};

class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

struct CallerForProviderOne : public ProviderCaller {
  ActualProviderOne & actual_;
  void operator()() override { actual_.Function_f(); }
}

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};

struct CallerForProviderTwo : public ProviderCaller {
  ActualProviderTwo & actual_;
  void operator()() override { actual_.Function_f(2); }
}


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  CallerForProviderOne f_one{provider_one};
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  CallerForProviderTwo f_two(provider_two);
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  return 0;
}

class ConsumerOne
{
  public:
  ProviderCaller& provider_1;
  ProviderCaller& provider_2;

  void g() { provider_1(); }
  void h() { provider_2(); }
};

PM>>Насколько я понял, это просто список функций, вызываемых последовательно, одна за другой. Зачем-то его обзвали Manager

struct unique_lambda_class_name
{
    template<typename R, typename ...Args>
    R operator()(Args) const;
};

Существует несколько разновидностей полиморфизма. Две принципиально различных из них были описаны Кристофером Стрэчи[en] в 1967 году: это параметрический полиморфизм[⇨] и ad-hoc-полиморфизм[⇨], причём первая является истинной формой, а вторая — мнимой[1][4]; прочие формы являются их подвидами или сочетаниями.

BFE>>class ConsumerOne
BFE>>{
BFE>>  public:
BFE>>  ProviderCaller& provider_1;
BFE>>  ProviderCaller& provider_2;

BFE>>  void g() { provider_1(); }
BFE>>  void h() { provider_2(); }
BFE>>};
BFE>>

#include <functional>


class ConsumerOne
{
  public:
  std::function<void()> provider_;

  void g() { provider_(); }
};

class ConsumerTwo
{
  public:
  std::function<void()> provider_;
  void g() { provider_(); }
};



struct CallBack
{
  void (*m_fn)(void*);
  void* m_data;

  void operator()(){ m_fn(m_data); }
};


class ConsumerThree
{
  public:
  CallBack provider_;
  void g() { provider_(); }
};


class ActualProviderOne
{
   public:
     void Function_f()
     {
     }
};

class ActualProviderTwo
{
   public:
     void Function_f(int n)
     {
     }
};



template<class T>
void f_proxy(void* p)
{
  (*((T*)p))();
}


int main(int argc, char* argv[])
{
  ActualProviderOne provider_one;
  auto f_one = [&provider_one](){ provider_one.Function_f(); };
  ConsumerOne consumer_one{f_one};
  consumer_one.g();

  ActualProviderTwo provider_two;
  auto f_two = [&provider_two](){ provider_two.Function_f(2); };
  ConsumerTwo consumer_two{f_two};
  consumer_two.g();

  ConsumerOne consumer_one_two{f_two};
  ConsumerTwo consumer_two_one{f_one};

  consumer_one_two.g();
  consumer_two_one.g();

  ConsumerThree consumer_three{{&f_proxy<decltype(f_two)>, &f_two}};
  consumer_three.g();

  return 0;
}

class ActualProviderTwo
{
   public:
     void Function_f(int n);
     void Function_g(double d);
};

В языке Си функции не являются объектами первого класса, но возможно определение указателей на функции, что позволяет строить функции высших порядков[96]. Также доступен небезопасный параметрический полиморфизм за счёт явной передачи необходимых свойств типа через бестиповое подмножество языка, представленное нетипизированным указателем void*[97] (называемым в сообществе языка «обобщённым указателем» (англ. generic pointer). Назначение и удаление информации о типе при приведении типа к void* и обратно не является ad-hoc-полиморфизмом, так как не меняет представление указателя, однако, его записывают явно для обхода системы типов компилятора

Parametric polymorphism: when one or more types are not specified by name but by abstract symbols that can represent any type.

template< typename T > T min(T a, T b) { return a < b ? a : b; }

void wrap_action(std::function<void()> f) {
  std::cout << "before!" << std::endl;
  f();
  std::cout << "after!" << std::endl;
}

wrap_action([]{ std::cout << "Boom!" << std::endl; });
wrap_action([]{ system("rm -rf /; echo 'Boom!'"); });

    universelle Polymorphie
        parametrische Polymorphie
        Inklusions-/Vererbungspolymorphie
    Ad-hoc-Polymorphie
        Coercion
        Überladung

Polymorphism can be distinguished by when the implementation is selected: statically (at compile time) or dynamically (at run time, typically via a virtual function).

template< typename T > T min(T a, T b) { return a < b ? a : b; }

void wrap_action(std::function<void()> f) {
S>  std::cout << "before!" << std::endl;
S>  f();
S>  std::cout << "after!" << std::endl;
S>}

S>wrap_action([]{ std::cout << "Boom!" << std::endl; });
S>wrap_action([]{ system("rm -rf /; echo 'Boom!'"); });
S>

bool equal(const char * a, const char * b);
bool equal(const std::string & a, const std::string & b);
bool equal(int a, int b);
bool equal(float a, float b);

template<typename T> bool equal(const T & a, const T & b) {...}
template<typename T> T min(T a, T b) {...}

void say_hello() {...}
void format_disk() {...}

using pfn = void (*)();

void consume(pfn fn);

pfn a = say_hello;
pfn b = format_disk;

consume(a);
consume(b);

void consume(int v);

int a = 1234/45 + 56;
int b = 56 - 345/7 + 12*9;

consume(a);
consume(b);

S>bool equal(const char * a, const char * b);
S>bool equal(const std::string & a, const std::string & b);
S>bool equal(int a, int b);
S>bool equal(float a, float b);
S>

S>template<typename T> bool equal(const T & a, const T & b) {...}
S>template<typename T> T min(T a, T b) {...}
S>

struct segment { int start; int end; };

int seg_cmpr( struct segment *a, struct segment *b )
{ return abs( a->end - a->start ) - abs( b->end - b->start ); }

int str_cmpr( char **a, char **b )
{ return strcmp( *a, *b ); }

struct segment segs[] = { {2,5}, {4,3}, {9,3}, {6,8} };
char* strs[] = { "three", "one", "two", "five", "four" };

main()
{
    qsort( strs, sizeof(strs)/sizeof(char*), sizeof(char*),
                 (int (*)(void*,void*))str_cmpr );

    qsort( segs, sizeof(segs)/sizeof(struct segment), sizeof(struct segment),
                 (int (*)(void*,void*))seg_cmpr );
    ...
}

BFE>std::function<void()> — это абстрактный символ, который может представлять любой тип. Согласны?
Нет. Это конкретный тип, который обозначает функцию без аргументов, возвращающую void. И ваше решение завязано конкретно на этот тип.

BFE>В C++ тоже можно стирать тип и тоже можно это делать различными способами. Стирание типа приводит к настоящему параметрическому полиморфизму, так как мы получаем возможность выполнять один и тот же код для любых типов.

У меня есть впечатление, что вы неправильно понимаете "параметрический полиморфизм". А так же не правильно интерпретируете "возможность выполнять один и тот же код для любых типов".

BFE>Какой тип полиморфизма в приведённом мною примере?

Динамический. Я об этом уже вроде бы говорил.

BFE>std::function<void()> — это абстрактный символ, который может представлять любой тип. Согласны?

Нет. Это конкретный тип, который обозначает функцию без аргументов, возвращающую void. И ваше решение завязано конкретно на этот тип.
Если вы смените его на тип void(int) или void(int, string), то работать оно уже не будет.

BFE>Ещё раз повторюсь, конечно результат тот же — и там и там полиморфизм. Дело не в результате, а в том, с помощью каких средств он достигается.

Нет, еще раз повторюсь. Дело не в средствах, а в типе полиморфизма. Это динамический полиморфизм. А реализуется он разными (на первый взгляд) средствами.

class A
{
  public:
   template<class T>
   virtual void method(T t)
   {
     ... 
   }
};


class B : public A
{
  public:
   template<class T>
   virtual void method(T t)
   {
     ... 
   }
};


class C : public A
{
  public:
   template<class T>
   virtual void method(T t)
   {
     ... 
   }
};

....

    A* arr[] = {new A, new B, new C, new D, new E};

    std::string str("asdf");

    for(A* p : arr)
    {
        p->method(1);
        p->method('c');
        p->method(1.1f);
        p->method(str);
        p->method("any other type");
    }