Здравствуйте, vdimas, Вы писали:

V>Здравствуйте, samius, Вы писали:

S>>Итак, предположим что это работало бы в дотнете.

V>Если язык позиционирует себя как статически-типизируемый, то обязано было бы.
Паскаль статически типизируемый. Попробуй на нем!

S>>Так убери конкурирующую специализацию или переобзови ее другим именем.

V>Напротив, я записал её абсолютно верно, т.е. именно так, как требуется писать в статически-типизируемом языке, поддерживающем (якобы поддерживающем) параметрический полиморфизм.
IndexOf не параметрический метод

S>>Получишь 2 метода, у которых ad-hoc полиморфизм, но хоть они будут компилироваться и работать.

V>А мне надо не два, а один перегруженный метод.
Понятно. То что тебе надо, я отменить не в силах.


S>>Ты можешь его попытаться не использовать, но от ad-hoc ты никак не отделаешься.

V>Да не пытаюсь я отделаться от ad-hoc, мне он нравится.
V>Я лишь показываю, что ad hoc полиморфизм в дотнете недоделан для случая генериков.
Разве я предлагал обсуждать доделанность дотнета, прежде чем мы договоримся о терминах?

V>Т.е. для случая обычных типов — доделан. В случае же генериков — имеем потерю типизации.
V>А коль нет типизации, то нет ad-hoc. Всё просто.
что за потеря типизации? Дженерики стали object-ами или dynamic-ами?

S>>Все что сравнивает — делает это специальным образом для каждого типа.

V>Не для каждого типа, а для каждого семейства типов. Прочувствуйте разницу, как грится.
Разницы нет. Если специально — уже ad hoc, см определение, но не то, которого нет в Hott.

S>>И любой тип, который ты подашь в IndexOf, будет требовать специального сравнения

V>Это уже за рамками рассматриваемого метда.
V>Ведь у нас наблюдается декомпозиция:
V>- есть параметрически полиморфная ф-ия IndexOf над семейством типов IList<T> where T : IEquatable<T>;
нету такой. Есть ad-hoc полиморфная.
V>- есть реализации метода IEquatable<T>.Equals(T other); пусть для конкретных типов или их семейств — не важно, пусть даже на ad hoc.
Это есть, спорить не буду.

V>Тут главное что?
V>Что всё вместе оно начинает работать уже на этапе компиляции и не потребует хакать систему типов в рантайм.
Работает и хакать не требует, верно.

V>В общем, ждем допиливания дотнета до работающего варианта.
Ты жди, а по мне оно УЖЕ работает.

V>>>Нет, не потерял. Параметрический полиморфизм НЕ требует работы ф-ии на ЛЮБЫХ входящих типах. Достаточно работы на более одном типе.
S>>ЧТО??? По-твоему любая мономорфная функция параметрически полиморфна?

V>По-моему, путать "моно-" и "поли-" грешно.
Но функция, работающая на одном типе мономорфна. Или я что-то пропустил?

V>>>Тем не менее, методы каждой из версий класса List<T> параметрически полиморфны прямо по-определению параметрического полиморфизма.
S>>Это не так.

V>Сначала я думал, что ты не понимаешь, что есть ad hoc полиморфизм.
V>Теперь получается, что и с параметрическим засада. ))
V>Приплыли.
Поздравляю. Еще немного и получится, что засада не у меня.

S>>И даже для невыдуманного List<T>. BinarySearch, Contains, IndexOf, LastIndexOf — ad hoc.

V>Я тебя понил. Вопрос: откуда ты вообще взял, что эти виды полиморфизма взаимоисключающи? Не видишь, разве, что это принципиально разные способы, которые нигде не пересекаются и не конфликтуют, т.е. прекрасно работают совместно?
Для деления PP/AH это не верно. PP исключает специальные знания о типе. AH их подразумевает.

V>>>Я показал рядом пример с методами-расширениями в C#. Не компилируется.
S>>Только потому что тебе нужна перегрузка и с ограничением и без одновременно.

V>Э-э-э...
V>Иногда мне сложно понять, где ты издеваешься, а где просто невнимателен.
Здесь я внимателен, ибо тебе действительно нужно и то и другое, и ты об этом написал неоднократно.

V>ОК, пусть будет всегда с ограничением, но ограничения пусть будут разные. Всё-равно тот пример не скомпилируется.
V>Это же не принципиально — я просто показал, что разные ограничения не означают разные типы аргументов.
Пусть ограничения разные. Так что доказывает твой пример в отношении PP/AH?

S>>Естественно. Но это ничего не меняет в отношении ad hoc.

V>Стирание информации о типе — это не естественно. И это МЕШАЕТ нормальному статически-компилируемому ad hoc.
Стирание — это безобразно, конечно.


V>>>В реализации системных библиотек Linq.
V>>>Происходит рантайм-проверка типа аргумента и ветвление алгоритма.
S>>Ах, вот что ты называешь рефлексией? Ну делалось бы это через visitor... Что бы изменилось? Один хрен ad hoc. (ой, чувствую, щас начнется)

V>Ну так, лишний код, всё равно. Чаще всего из контекста виден точный тип (или видно больше деталей-ограничений). Если бы стирания не происходило, то все разруливалось бы статически.
Ну так лишний код — это не принципиальная невозможность.


S>>После хаскельвики и просто вики?

V>После овладения навыками чтения технической литературы.
V>Я тебе привел из твоей же ссылки на вики точные цитаты Стрэчи, ты продолжаешь упрямиться.
V>ОК, дело такое...
Я тебе приводил точные цитаты хаскельвики, и ты продолжаешь упрямиться.

S>>Мы пока еще не договорились по поводу того, что считать параметрическим.

V>Мы с тобой и не договоримся.
V>Потому что продвижения нет.
V>Ты игноришь аргументы, игноришь цитаты, игноришь ссылки, игноришь всё.
Твои аргументы опираются на определения, который ты не нашел в одной книге и потому сам выдумал. Игнорить их — самое благоразумное.

V>Ты даже игноришь цитаты из своих собственных ссылок. ))
Разве? Я ими руководствуюсь в определении PP/AH.
V>Это намеренный саботаж.

V>>>В дотнете такое не компиллируется.
V>>>А в Хаскеле подобный сценарий — это основа основ современных практик для этого языка.
S>>Пусть, но это ad hoc.

V>Надоело.
О, я только вошел во вкус...

V>Просто обращение к здравому смыслу.
V>Итак. Генерики дотнета считаются параметрическим полиморфизмом. Предлагаю тебе в этом месте прислушаться к мнению того самого "миллиона леммингов".
Генерики дотнета действительно считаются параметрическим полиморфизмом. С поправкой — там где нет ограничений. С ограничениями это bounded PP, см вики, нуба Карделли.

V>Я давал краткое определение параметрического полиморфизма:
V>если тело ф-ии явно или неявно параметризуется аргументом-типом — это параметрический полиморфизм.
Ну я же говорю, что ты их выдумываешь.

V>Твой Карделли называл такие функции "шаблоном". Наверно поэтому появившиеся "шаблоны" в С++ приняли одноимённое название.
V>Всё вместе "оно" называется обобщённым программированием, наверно отсюда растут ноги у термина "генерик" у C# и Джавы.
Вот сам Карделли

The functions that exhibit parametric polymorphism are also called generic functions. For example,
the length function from lists of arbitrary type to integers is called a generic length function. A generic
function is one which can work for arguments of many types, generally doing the same kind of work
independently of the argument type. If we consider a generic function as a single value, it has many
functional types and is therefore polymorphic. Ada generic functions are a special case of this concept of
generic

Только вот Карделли называет параметрическим полиморфизмом не те функции, которые параметризуются явно или неявно аргументом-типом. А

Strachey [Strachey 67] distinguished, informally, between two major kinds of polymorphism.
Parametric polymorphism is obtained when a function works uniformly on a range of types: these types
normally exhibit some common structure. Ad-hoc polymorphism is obtained when a function works, or
appears to work, on several different types (which may not exhibit a common structure) and may behave in
unrelated ways for each type.

Заметь, здесь AH противопоставляется PP.

V>Далее.
V>Вот очередная попытка определения из твоей вики:
V>

V>Параметрический полиморфизм позволяет определять функцию или тип данных обобщённо, так что значения обрабатываются идентично вне зависимости от их типа. Параметрически полиморфная функция использует аргументы на основе поведения, а не значения, апеллируя лишь к необходимым ей свойствам аргументов, что делает её применимой в любом контексте, где тип объекта удовлетворяет заданным требованиям поведения.

V>Улыбнуло. Сказано верно, но само определения явно предназначено для людей, далеких от IT, или для новичков в IT.
V>Наверно потому что вики для всех.
Удивляет, что тебе непонятно в этом определении? Если это сказано верно, то какое отношение к PP имеет твое собственное определение, не подразумевающее "вне зависимости от их типа"?

V>Давай переведём в наши координаты:
V>* "использует аргументы на основе поведения" — тут речь о "типизированном черном ящике", т.е. о "концепте", т.е. о паре { "черный ящик", "набор операций" };
Чушь. набор операций над типом зависим от типа. Все, что использует набор операций (хотья прямо, хоть косвенно через ящик), имеет зависимость от типа.

V>* "делает её применимой в любом контексте, где тип объекта удовлетворяет заданным требованиям поведения" — тут речь о наличии "ограничений" полиморфного аргумента или просто его "типизации" (да, именно так и говорится, и это вполне грамотно); Это одно и то же, что первое, т.е. определение могло быть вдвое короче.
Не находишь странным, что пример к этому определению не содержат ограничений, черных ящиков и вообще любых типоспецифичных операций? Ты утверждаешь что определение указывает на наличие ограничений, так где же ограничения в нижеследующих примерах List a, length и map?

V>Вот тебе очередное определение параметрического полиморфизма.
И там явно упомянута независимость от типа.
V>Ты же упорно и 1-е и 2-е называешь ad hoc. )))
То, что требуует ограничений, я упорно называю AH.

V>Или можно взять начало начал:
V>

V>ML ввел понятие параметризированного полиморфизма в языки.

V>Типы ML могут содержать переменные типов, которые могут быть означены разными типами в разных контекстах. Следовательно возможно частично определять информацию о типах и писать программы основанные на частично определенных типах, которые могут быть использованы на всем диапазоне этих типов.

Это историческая справка. Я не вижу здесь формальной связи между введением понятия ПП и возможностю частично определять информацию. Эта связь появилась с введением bounded PP.
V>Итого, когда ты пишешь в дотнете where T : IEquatable<T> — ты частично определяешь тип T.
Верно.
V>Или когда в Хаскеле пишешь equal_to :: (Eq a) => ... — ты частично определяешь тип a.
Тоже. Но чистый PP не допускает специальных операций над экземпляром типа.

V>Вот это неполное определение типа — это и есть основной/единственный признак именно параметрического полиморфизма, а вовсе не ad hoc.
Ошибаешься. Признак параметрического — отсутствие ограничений.

V>А где появляется ad hoc — я уже много раз тебе писал. Медитировать до просветления, как грится.
После тебя