Класс [Животное]
{
   virtual срать() = 0;
}

Класс [Лошадь] : [Животное]
{
   virtual срать()
   {
      поднять_хвост();
      навалить_яблок();
   }
}

Класс [Собака] : [Животное]
{
   virtual срать()
   {
      присесть();
      навалить();
   }
}

Класс [Ферма]
{
   //Список зверей на ферме
   std::list<Животное *> звери;
   
   //Конструктор фермы
   Ферма()
   {
      //Добавляем зверей
      звери.append(new Лошадь());
      звери.append(new Собака());
   }

   //все срём по рассписанию
   void дефекация()
   {
      for_each(Животное * зверь, звери)
      {
        зверь->срать();
        //Каждое животное будет срать по своему
        //Обрати внимание что в списке у нас Животное 
        //а добавляем мы конкретных зверей
        //но срать заставляем через указатель на Животное
        //это и есть полиморфизм
      }
   }
}

void QLayout::addWidget ( QWidget * w )

#include <QApplication>
#include <QHBoxLayout>
#include <QSlider>
#include <QSpinBox>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QWidget *window = new QWidget;
    window->setWindowTitle("Enter Your Age");

    QSpinBox *spinBox = new QSpinBox;
    QSlider *slider = new QSlider(Qt::Horizontal);
    spinBox->setRange(0, 130);
    slider->setRange(0, 130);

    QObject::connect(spinBox, SIGNAL(valueChanged(int)),
                     slider, SLOT(setValue(int)));
    QObject::connect(slider, SIGNAL(valueChanged(int)),
                     spinBox, SLOT(setValue(int)));
    spinBox->setValue(35);

    QHBoxLayout *layout = new QHBoxLayout;

    // ПОЛИМОРФИЗМ
    layout->addWidget(spinBox);
    layout->addWidget(slider);

    window->setLayout(layout);

    window->show();

    return app.exec();
}

print( 10 ); // <= операция print выполняется над числом.
print( "опа" ); // <= операция print выполняется над строкой.
//  Полиморфизм, однако.

class Figure
{
    ...
    void Draw() const;
}; 
class Circle : public Figure
{
    ...
    void Draw() const;
};

Circle *c = new Circle(0,0,5);
Figure *f = c; // Всё ok: Figure — базовый класс для Circle
c->Draw();
f->Draw();

Polymorphism enables one common interface for many implementations, and for objects to act differently under different circumstances.

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

Ещё в 1960-х гг. Р. Хиндли (Roger Hindley) исследовал типизацию в комбинаторной логике. Его проблемной областью была типизация в языках, основанных на теории лямбда-исчисления. Позднее, в конце 1960-х годов, тот же учёный исследовал полиморфные системы типов. Позже, в 1970-х годах, Робин Милнер предложил практическую реализацию расширенной системы полиморфной типизации для языка функционального программирования ML.

There are several fundamentally different kinds of polymorphism

V>>то получается нельзя путать разные варианты полиморфизма между собой. Т.е. нельзя говорить, что Ad-hoc polymorphism является упрощенным вариантом Subtype polymorphism. Это математически некорректно, как и упоминание полиморфизма вообще без конкретизации по его контексту

В 1970-е годы более сотни специалистов по теории групп образовали своеобразный консорциум, целью которого было представить полную классификацию простых конечных групп.
...
Но даже если проект увенчается исчерпывающим итоговым докладом, в мире, наверное, не найдется и десяти математиков, которые будут вправе утверждать, что они понимают хотя бы основные линии многотомного доказательства.

V>>Есть разные полиморфизмы. А программист мысля разные объекты единообразно должен еще сообразить как запихнуть свое единообразное мышление в программу с помощью того, этого или другого полиморфизма. Или ну его вообще этот полиморфизм который так галимо отражает наше естественное мышление

//parametric polymorphism
TItem[] Concat<TCollection, T>(T[] items1, TCollection items2) where TCollection:IEnumerable<T>
{
  var result = new List<T>();
  compile-if (TCollection is ICollection<T>)
  {
     result.Capacity = items1.Length + items2.Count;
  }
  else
  {
    result.Capacity = items1.Length;
  }
  result.AddRange(items1);
  compile-if (TCollection is Array<T>)
  {
    result.AddRange(items2);
  }
  else
  {
    foreach (var item in items2)
      result.Add(item);
  }
  return result.ToArray();
}

//ad-hoc polymorphism
T[] Concat<T>(T[] items1, T[] items2)
{
  var result = new List<T>();
  result.Capacity = items1.Length + items2.Count;

  result.AddRange(items1);
  result.AddRange(items2);

  return result.ToArray();
}
T[] Concat<T>(T[] items1, ICollection<T> items2)
{
  var result = new List<T>();
  result.Capacity = items1.Length + items2.Count;

  result.AddRange(items1);

  foreach (var item in items2)
    result.Add(item);

  return result.ToArray();
}
T[] Concat<T>(T[] items1, IEnumerable<T> items2)
{
  var result = new List<TItem>();

  result.AddRange(items1);

  foreach (var item in items2)
      result.Add(item);

  return result;
}

int[] F1()
{
  return new[]{1, 4, 5};
}
IEnumerable<int> F2()
{
  for (int i = 0; i < 5; ++i)
   yield return i;
}

var s = new int[]{4, 6, 7};
var f1 = F1();
var f2 = F2();

var x1 = Concat(s, f1);//здесь выбирается функция для Array
var x2 = Concat(s, f2);//здесь для IEnumerable

var f = new Random().Next() > 0.5 ? F1() : F2();
var x = Concat(s, f);

T[] Concat_Enumerable_Or_Array<T>(T[] items1, IEnumerable<T> items2)
{
  if (items2 is T[])
    return Concat(items1, (T[])items2);
  return Concat(items1, items2);
}

var x = Concat_Enumerable_Or_Array(s, f);

T[] V_Concat(T[] items)
{
  return Concat(items, (T[])this);
}

//subtype полиморфизм
T[] V_Concat(T[] items)
{
  return Concat(items, (ICollection<T>)this);
}

T[] V_Concat(T[] items)
{
  return Concat(items, (IEnumerable<T>)this);
}

return x = f.V_Concat(s);

Using parametric polymorphism, a function or a data type can be written generically so that it can handle values identically without depending on their type. Such functions and data types are called generic functions and generic datatypes respectively and form the basis of generic programming.

ad-hoc polymorphism is a kind of polymorphism in which polymorphic functions can be applied to arguments of different types, because a polymorphic function can denote a number of distinct and potentially heterogeneous implementations depending on the type of argument(s) to which it is applied.
...
This is in contrast to parametric polymorphism, in which polymorphic functions are written without mention of any specific type, and can thus apply a single abstract implementation to any number of types in a transparent way. This classification was introduced by Christopher Strachey in 1967.

The interesting question is how does .NET compile the generic IL of the server to machine code. It turns out that the actual machine code produced depends on whether the specified types are value or reference type. If the client specifies a value type, then the JIT compiler replaces the generic type parameters in the IL with the specific value type, and compiles it to native code. However, the JIT compiler keeps track of type-specific server code it already generated. If the JIT compiler is asked to compile the generic server with a value type it has already compiled to machine code, it simply returns a reference to that server code. Because the JIT compiler uses the same value-type-specific server code in all further encounters, there is no code bloating.

If the client specifies a reference type, then the JIT compiler replaces the generic parameters in the server IL with Object, and compiles it into native code. That code will be used in any further request for a reference type instead of a generic type parameter. Note that this way the JIT compiler only reuses actual code. Instances are still allocated according to their size off the managed heap, and there is no casting.

//parametric polymorphism
TItem[] Concat<TCollection, T>(T[] items1, TCollection items2) where TCollection:IEnumerable<T>
{
  var result = new List<T>();
  compile-if (TCollection is ICollection<T>)
  {
     result.Capacity = items1.Length + items2.Count;
  }
  else
  {
    result.Capacity = items1.Length;
  }
  result.AddRange(items1);
  compile-if (TCollection is Array<T>)
  {
    result.AddRange(items2);
  }
  else
  {
    foreach (var item in items2)
      result.Add(item);
  }
  return result.ToArray();
}

//parametric polymorphism
TItem[] Concat<TCollection, T>(T[] items1, TCollection items2) where TCollection:IEnumerable<T>
{
  var result = new List<T>();
  result.Capacity = items1.Length + Capacity(items2);
  result.AddRange(items1);
  AddRange(result, items2);
  return result.ToArray();
}
//ad-hoc polymorphism
int Capacity<T>(IEnumerable<T> items)
{
  return 0;
}
int Capacity(ICollection<T> items)
{
  return items.Count;
}
//ad-hoc polymorphism
void AddRange<T>(List<T> result, T[] items)
{
  result.AddRange(items);
}
void AddRange<T>(List<T> result, IEnumerable<T> items)
{
  foreach (var item in items)
    result.Add(item);
}

DG>//parametric polymorphism
DG>TItem[] Concat<TCollection, T>(T[] items1, TCollection items2) where TCollection:IEnumerable<T>
DG>{
DG>  var result = new List<T>();
DG>  result.Capacity = items1.Length + Capacity(items2);
DG>  result.AddRange(items1);
DG>  AddRange(result, items2);
DG>  return result.ToArray();
DG>}
DG>//ad-hoc polymorphism
DG>int Capacity<T>(IEnumerable<T> items)
DG>int Capacity(ICollection<T> items)
DG>//ad-hoc polymorphism
DG>void AddRange<T>(List<T> result, T[] items)
DG>void AddRange<T>(List<T> result, IEnumerable<T> items)
DG>

Ad-hoc полиморфизм и subtype-полиморфизм являются частным случаем Parametric полиморфизма.

class B:A{..}

.. F(A a, ...)
{
  ..
}

.. F<T>(T a, ..) where T: A or B
{
 ..
}

f: A -> B and f: A' -> B' => A = A' and B = B' // A Gentle Introduction to Category Theory

Each morphism f has a unique source object a and target object b where a and b are in ob(C).

IEnumerable<T> is IEnumerable<T> = true
ICollection<T> is IEnumerable<T> = true
T[] is IEnumerable<T> = true
IEnumerable<T> is ICollection<T> = false
ICollection<T> is ICollection<T> = true
T[] is ICollection<T> = true
IEnumerable<T> is T[] = false
ICollection<T> is T[] = false
T[] is T[] = true

IEnumerable<T> -> IEnumerable<T>
ICollection<T> -> IEnumerable<T>
T[] -> IEnumerable<T>
ICollection<T> -> ICollection<T>
T[] -> ICollection<T>
T[] -> T[]

TItem[] Concat<TCollection, T>(T[] items1, TCollection items2) where TCollection:IEnumerable<T>
{
  var result = new List<T>();
  compile-if (TCollection is ICollection<T>)
  {

T Sum<T>(this IEnumerable<T> items) where T:int/double/string/decimal и т.д.
{
  var res = Empty(T);
  foreach (var item in items)
  {
    res = res + item;
  }
  return res;
}

static void Write(int i) { Console.WriteLine("integer"); }
static void Write(object v) { Console.WriteLine("object"); }

static void WriteT<T>(T value) { Write((dynamic)value); }

static void Main()
{
    WriteT(0);   // integer
    WriteT("0"); // object
}

DG>T Sum<T>(this IEnumerable<T> items) where T:int/double/string/decimal и т.д.
DG>

import std.stdio;

T Sum(T)(T items[]) if(is(T == int) || is(T == float))
{
return T.init;
}

void main()
{
static assert(__traits(compiles, Sum!int));
static assert(__traits(compiles, Sum!float));
    
static assert(!__traits(compiles, Sum!string));
}