Но это все из другой оперы. Это все для скриптов. А в нормальных ОО-программах типизация должна быть типзацией, а не утиными историями.

Чем больше в системе всяких явно не описанных "соглашений", "умолчаний", "подразумеваний" и т.п., тем меньше у неё шансов добраться до финального релиза. Может быть, я что-то неправильно понял, но вся мощь "утиных историй" проявляется тогда, когда язык программирования не заставляет нас предельно чётко и скрупулёзно описывать понятие "Утка". Один программер что-то там себе подразумевает, а его товарищ может подразумевать что-то чут-чуть другое. Один из них, например, может быть свято уверен, что утки в принципе не умеют летать.

E>

Они взяли наихудшую парадигму из языка и возвели ее в степень догмы. А именно — идею наследования. Наследование — это самая большая провокация в индустрии.

E>
Одобрямс!

На мой взгляд, "утиные истории" — это весьма неуклюжая попытка обойти "деревянную" сущность иерархий наследования. И даже когда язык позволяет делать множественное наследование, проблема всё равно окончательно не снимается, а всего лишь загоняется вглубь.

Пару лет назад, размышляя над этими проблемами, я дошёл до идеи множественной классификации (см. здесь). Лекарство, конечно, слишком сильнодействующее, но я до сих пор не разуверился в том, что рецепт выписан правильно.

Duck* MakeDuck(void *anybody) {
  return (Duck*)anybody;
}

E>Тем не менее, существуют подходы к разработке, когда приложение строится из множество маленьких независимых процессиков, взаимодействующих между собой по IPC. Почему бы внутри каждого из них не использовать duck typing?

V>Duck* MakeDuck(void *anybody) {
V>  return (Duck*)anybody;
V>}
V>

V>

class Duck; def qrack(); end; end
class Dog; def gaff(); end; end

def make_duck(anybody); return anybody; end

duck = make_duck( Dog.new )
duck.qrack()

duck_typing_strong_typing.rb:7: undefined method `qrack' for #<Dog:0x2778060> (NoMethodError)

E>>Тем не менее, существуют подходы к разработке, когда приложение строится из множество маленьких независимых процессиков, взаимодействующих между собой по IPC. Почему бы внутри каждого из них не использовать duck typing?

E>

Ведь в duck typing нет отношения "is-a", а есть что-то типа "like-a" ("can", "respond_to"). Т.е., наследования нет, а полиморфизм, благодоря динамической типизации, есть.

// Как всегда, на вымышленном языке программирования
class Duck { // Утка
 func УтиУтиУти(Somebody: AHuman);
}

class Alive { // Нечто живое, что может двигаться само
 func Move(Direction: ADirection);
}

class Wild {} // нечто дикое

class Domestic {} // нечто домашнее

func (Duck, Alive)::УтиУтиУти(Somebody: AHuman) { // Сваливаем подальше
   MakeSound("Кря-кря");
};

func (Duck, Wild, Alive)::УтиУтиУти(Somebody: AHuman) { // Сваливаем подальше
  Move(CalcOppositeDirection(GetDirectionTo(AHuman)));
};

func (Duck, Domestic, Alive)::УтиУтиУти(Somebody: AHuman) { // Бежим к человеку. Может, пищу дадут...
  Move(GetDirectionTo(AHuman));
};

// где-то в программе...
var
 Duck1: Duck,  // Просто утка
 Duck2: (Duck, Alive), // Живая утка
 Duck3: (Duck, Wild),  // Дикая утка
 Duck4: (Duck, Wild, Alive), // Дикая живая утка
 Duck5: (Duck, Alive, Domestic); // Домашняя живая утка

Duck1.УтиУтиУти(Me); // Ничего не будет. "Кря-кря" не скажет и никуда не двинется.
Duck2.УтиУтиУти(Me); // Скажет "Кря-кря", но никуда не двинется.
Duck3.УтиУтиУти(Me); // Ничего не будет.
Duck4.УтиУтиУти(Me); // Скажет "Кря-кря" и убежит.
Duck5.УтиУтиУти(Me); // Скажет "Кря-кря" и прибежит.

classify Duck2 as Wild; // Смутировали живую утку Duck2. Сделали её дикой.
Duck2.УтиУтиУти(Me); // Теперь не только крякнет, но ещё и убежит.