Re[33]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 16.02.17 05:37
Оценка:
Здравствуйте, vdimas, Вы писали:

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


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


V>Я никому не доверяю, только лишь своему пролетарскому чутью. ))

Принято

V>И ты никому не доверяй, особенно вот таким маленьким статьям по конкретным языкам, навроде Хаскеля, чьё сообщество на сегодня является наиболее консервативным из всех других "живых" сообществ.


V>Ну и тем более не доверяй Вики. ))

Конечно, особенно если она совпадает с классификацией, на которую ссылается. Это особо подозрительно.

V>Я вот всё жду, когда вот эту опенсорсную книгу докончат:

V>https://hott.github.io/book/nightly/hott-online-1075-g3c53219.pdf
V>а потом переведут на русский.
V>Этой книге можно верить.
За ссылку спасибо, буду верить. Но вот что касается конкретно parametric/ad-hoc — там верить нечему, такие наборы букв не встречаются. Сложно руководствоваться книгой для отделения мух от котлет, если ни те ни другие в книге не помянуты.

V>По всей этой теме она пишется наиболее тщательно во всей Истории IT как таковой.

V>Книгу пишет большая группа авторов.
V>Книга пишется на гитхабе.
V>Идет постоянный фидбэк.
V>Идут "ночные сборки", ревью, баги — всё как положено. ))

V>Кста, инициатор проекта и его ведущий — наш русский математик.


V>Согласно неё имеем:

V>- обычные типы (домен значений);
V>- "вселенные" типов (набор доменов);
V>- иерархию вселенных (по признаку включения/пересечения их элементов-доменов);
V>- функциональные типы (мап входного домена на выходной: A->B);
V>- зависимые функциональные типы (мап семейства функций + входного домена из некоторой вселенной на конкретную ф-ию; параметрически полиморфные ф-ии — это разновидность зависимых функциональных типов);
V>- производные типы (типы параметризуются типами);
V>- зависимые типы (типы параметризуются значениями);

V>Похожую классификации я вижу у Пирса, часть её я вижу у Черча.

Ага, и я.
V>А когда некоторые авторы начинают разбирать на молекулы конкретно разновидности всего-навсего параметрического полиморфизма, чудовищно плавая при этом по всему вокруг и повторяя всевозможные заблуждения и городские легенды, то мне становится тошно. ))
Заблуждения при этом это то, с чем твое пролетарское чутье не согласно?

V>В общем, я не думаю, что уже пора собирать и давать ссылки на различные классификации параметрического полиморфизма (я имел ввиду именно их). Я вообще не думаю, что это когда-либо стоить делать кроме как для удовлетворения некоторого любопытства и при обязательном умении посмотреть на всё малость "со стороны".


V>Конкретно у нас я увидел, что мы пока не можем отделить даже сам параметрический полиморфизм от других разновидностей полиморфизма. И конкретно ты тут не при чем. Я заглянул в Вики, почитал чуть "вглубь" — волосы встают дыбом. Тут на форуме встают еще чаще. ))


V>И да. Некоторые авторы в запале "прозрения" называют параметрический полиморфизм "истинным полиморфизмом".

V>В общем случае это не так. В общем случае речь идёт о "зависимом функциональном типе" (упомянут выше).
V>Усё. Остальное зависит от техник, частностей и т.д.

То есть, ты в этой книге упоминания ad-hoc тоже не нашел, и потому все остальные упоминания стали мутными.

V>============

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

V>Итак, начинаем с упомянутой тобой не к ночи Вики:

V>

V>В языках программирования и теории типов полиморфизмом называется способность функции обрабатывать данные разных типов.

V>Существует несколько разновидностей полиморфизма. Две наиболее различных из них: это ad hoc полиморфизм и параметрический полиморфизм.

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

V>Запомним это определение. Оно верное до тех пор, пока "исполнение" будет означать "исполнение по исходнику", а не по машинным кодам. Где-то я даже встречал "физическое исполнение" и тоже ужасался. )) В книге по ссылке говорится:
V>

V>A polymorphic function is one which takes a type as one of its arguments, and then acts on elements of that type.

V>Заметь, и параметрический и ad hoc-полиморфизмы прекрасно подходят под определение.
Ничего нового. Это устоявшееся определение полиморфизма вообще. Например, у Luca Cardelli

Polymorphic functions are functions whose operands (actual parameters) can have more than one type.

Деление на parametric/ad-hoc обычно следует абзацем ниже. Но у HOTT до этого не дошло.

V>В первом случае мы напишем единственное тело ф-ии, которое сможет обслуживать, допустим, все типы из данной вселенной.

V>Во втором случае мы для одной и той же ф-ии напишем несколько версий тел — под разные типы из данной вселенной (или их семейства — подвселенных).
Верно

V>Тут надо сделать паузу и обратить внимание, что в последнем случае, когда речь идёт об обслуживании некоего ограниченного семейства типов из вселенной, то опять получается параметрический полиморфизм, но уже на вселенной меньшего ранга.(*)

Верно. Но ты потерял чистоту квантора ∀.

V>Вот тебе совместная работа параметрического полиморфизма и ad hoc.

Верно, совместная. Но совместная параметрического на ограниченом множестве и ad-hoc в полный рост.
V>Но и это не единственный сценарий их взаимодействия.
V>Идем далее.

V>А далее вики безбожно противоречит самой себе:

V>

V>Определение полиморфизма как «один интерфейс — много реализаций», популяризованное Бьерном Страуструпом, относится к ad hoc полиморфизму.
V>...
V>Параметрический полиморфизм и динамическая типизация намного существеннее, чем ad hoc полиморфизм, повышают коэффициент повторного использования кода, поскольку определенная единственный раз функция реализует без дублирования заданное поведение для бесконечного множества вновь определяемых типов, удовлетворяющих требуемым в функции условиям.
V>...
V>Подтипизация (subtyping), или полиморфизм подтипов (subtype polymorphism), означает, что поведение параметрически полиморфной функции ограничивается множеством типов, ограниченных в иерархию «супертип — подтип».

V>(Например, если имеются типы Number, Rational и Integer, ограниченные отношениями Number :> Rational и Number :> Integer, то функция, определённая на типе Number, также сможет принять на вход аргументы типов Integer или Rational, и её поведение будет идентичным.)

V>Кошмар, не правда ли? ))
V>Ладно бы это были выдержки из разных страниц, но эти противоречивые утверждения я собрал с одной страницы.
Это ровно то, о чем ты написал выше (см. (*)).

V>Вот почему я не очень люблю давать ссылки и практически никогда их не прошу. Я обычно просто благодарен за новую инфу и сам стараюсь подкидывать просто "чистую инфу". Кому интересно — тот осилит. Потому что Интернет не "не может ошибаться", а ровно наоборот — Интернет почти всегда врёт. Каждый раз брать на себя ответственность за это...


V>ОК. Берем один из моих примеров выше, заворачиваем в объявление ф-ии:

V>
V>static class Extensions {
V>    void Draw(this IEnumerable<Widget> widgets, Context context) {
V>        foreach(var w in widgets)
V>            w.Draw(context);
V>    } 
V>}
V>

V>Получаем параметрически полиморфный метод Extensions.Draw, который принимает на вход список полиморфных объектов.
Извини, subtype полиморфизм не относится к параметрическому, т.к. не выполняется ∀ типов. Но можно считать его ограниченно параметрическим. Зато механика исполнения отсылает нас к ad-hoc, выполненному как перегрузка по неявному параметру с рантайм диспетчеризацией, если вспомнить что w.Draw(Context) есть Draw(w, Context).

V>К чему я это? К тому, что вопреки популярным заблуждениям (особенно на этом сайте), "параметрический полиморфизм" — это не только и не столько "шаблоны" и "генерики". Параметрически полиморфна будет любая ф-ия, на которую подаётся переменная полиморфного типа (или производного от такого типа).

Параметрический — это ∀. (точка)
Здесь и далее ты пишешь про inclusion полиморфизм (subtype), называя его параметрическим.

V>Идём далее.

V>В современном программировании принято такие ф-ии объединять в некую сугубо прикладную группу — в классы/интерфейсы/концепты.

V>Исходно же, исторически, "параметрический полиморфизм" означал программирование в т.н. "черных ящиках". Как пример можно привести любой динамически-типизированный функциональный язык (раньше были модные).


V>Далее — у нас есть две основные разновидности такого "ящика":


V>* "Типизированный ящик" или т.н. "концепт" — список операций над ящиком задан "заранее".


V>* "Нетипизированный ящик" — список операций получается "по факту".


V>В последнем случае, если список операций выводится в рантайм, то это динамическая типизация.


V>Если же в последнем случае типизация происходит в компайлтайм (т.е. статическая типизация), тогда все "черные ящики" должны быть "выведены" компилятором до монотипов или до других "типизированных концептов". Так работает компилятор С++.


V>Именно поэтому мы имеем в С++ статическую типизацию на "нетипизированных черных ящиках" и динамическую типизацию на "типизированных концептах" — т.е. абстрактных/виртуальных методах.

V>(тут надо остановиться и попытаться переварить, ы-ы-ы)

Да нечего там переваривать.

V>Далее. Т.н. "структурный полиморфизм".

V>Доступен частично в стандартном Хаскеле — в языке доступна лишь "открытая" структура типов, этой структурой можно оперировать даже тогда, когда элементами структуры является неизвестный тип (вселенная всех типов или некая подвселенная).

V>И совсем хорошо "структурный полиморфизм" доступен в диалекте GHC. Они там ввели "семейства типов" (крайне неудачное наименование, сбивающее с толку, но в терминах Хаскеля теперь придётся юзать).


V>И точно так же, как в случае классов типов, можно задавать как ad hoc специализации хаскелевских "семейств типов", так и "ограничения" на структуру полиморфных типов (такое ограничение образует собсно "семейство" в терминах Хаскеля, как ограничение на список ф-ий образовывало "класс").


V>Любая специализация некоего "семейства" переопределяет "структуру" типа (т.е. конструкцию данных).

V>И опять твой викиучебник по Хаскелю пишет:
V>

V>Indexed type families, or type families for short, are a Haskell extension supporting ad-hoc overloading of data types.

V>Предлагаю здесь опять сделать паузу и напрячь внимание.

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


V>Возвращаясь к нашим баранам — в С++ структурный полиморфизм доступен: в шаблонах можно обращаться к полям типов. Но этот полиморфизм в C++ тоже идёт не типизированный "изкаробки". (Хотя, есть сразу несколько техник приведения его к типизированному. Например, через т.н. "селекторы" можно сводить структурный полиморфизм к полиморфизму над "концептом", а как последний сделать типизированным в реалиях С++ — уже описывал ранее.)

Это все лишь о диспетчеризации, точнее времени ее выполнения (компайл/рантайм). Заметь, диспетчеризация нужна для выполнения специального кода. Для параметрического полиморфизма (с квантором ∀) она не требуется вообще. Ну или почти (если учитывать Value/ref дотнета).

V>============

V>Далее будет совсем смешно (из той же статьи):
V>

V>Наследование в С++ реализуется набором ad hoc-механизмов, однако, его использование называется в сообществе языка «полиморфизмом», а сокрытие полей — «абстракцией».

V>Каких еще в опу "наборов ad hoc-механизмов"??? Что за потёки сознания? ))
V>ad hoc механизм — он один, нет никаких его "наборов".
Как это один? Кто сказал? Твое пролетарское чутье?

V>И откуда взялось про "в сообществе языка"? У кого там так подгорает-то? ))

V>И почему "абстракцией" было названо только лишь сокрытие полей, да еще в обвинительном тоне?
V>Прикол, да?
V>Принципы абстрагирования родились в IT за пол века до первой версии языка С, не то, что даже С++.
Но в неком ограниченном сообществе ушибленных ООП техниками (и не встречавших более широких трактовок этих терминов), действительно имеют место эти использования. В этом можно легко убедиться. Погугли "три кита ООП".

V>И уж инкапсуляцию тоже не в С++ придумали как средство абстрагирования.

Верно.

V>Однако, автор на голубом глазу путает "абстрагирование" как способ проектирования публичных интерфейсов (сокрытие частностей), от абстрагирования на уровне системы типов, когда нам такое абстрагирование нужно сугубо для повторного использования кода (чаще всего абстрагирование от конкретного типа за этим и нужно).

Нене, автор говорит как эти термины используются в неком сообществе не претендуя на истинность такого использования. Ты передергиваешь.

V>В IT оба этих понятия вокруг одного слова "абстракция" довольно четко отделены уже давно, более 70-ти лет (конец 50-х, начало 60-х 20-го века), но поди ж ты!


V>К тому же, любой современный студент знает, что сокрытие полей называется чаще "инкапсуляцией". А когда говорят об "абстракции", то чаще имеют ввиду полиморфизм.

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


S>>С другой стороны, я не ковырял по узкоспециализированнымм инженерным источникам.


V>Ну а я ковырял одно время, пытаясь почерпнуть "знания", угу.

V>Был весьма обескуражен вначале, а потом разозлён из-за потраченного времени.

V>Поэтому и не спешу никуда никого отсылать на совсем уж "глубокие" исследования. Я пока настойчиво призываю относится к подобным "исследованиям" критически. Бо чем глубже такое исследование, тем оно `уже, тем более ангажирован автор на каком-либо языке программирования и засоряет людям моск ненужными тонкостями отличий кормовой свеклы от брюквы (разновидности одного и того же), разве что в рамках разработанной "самой лучшей в мире классификации параметрического полиморфизма", где на самом почетном месте этой классификации будет рекламируемое чудо, а как же! ))

Так что же мог рекламировать Стрэчи в 67м?

S>>Вот я копнул, ты копнул — у нас разногласия.


V>Ну, у нас возникли совсем уж серьезные разногласия — что есть ad hoc.

V>И потребовалось несколько итераций, чтобы ты начал приводить свои источники и я попытался понять, почему ты эти источники понял именно так.

V>В общем, тут рассуждения простые. "Поли-" — это много, "морфизм" — приспособляемость (формы — "морфы").

Хм, никто не спорит.

V>В случае ad hoc полиморфизма у нас должно быть много подходящих под разные типы (или их групп) определений, а в случае параметрического полиморфизма у нас должно быть такое определение, которое умеет работать на множестве типов.

Дада. С оговркой — ∀. Для любого наперед заданного без специальных приседаний.

S>>В хаскеле задать без ограничения можно, но ограничение от этого не пропадет. И указанный в хаскельвики способ все равно его обнаружит. Вот, правда, может быть наоборот, что ограничение было указано избыточно.


V>Что значит "указанно избыточно"?

V>В смысле, не используется явно в коде ф-ии?
Да.
V>Но иногда и не надо, ведь есть много "трюков" — например, для конкретного ограничения можно применить некую специфическую логику.
V>Суть трюка состоит в том, что мы переносим константы (т.е. некие данные, которые неизменны в течении работы программы) в систему типов, избавляясь от if в теле ф-ий, эксплуатируя имеющуюся систему типов используемого языка, чтобы диспетчеризация происходила "сама".

S>>Хрен с ним с рангом. Давай сначала с ad-hoc-ом разберемся.


V>Еще не разобрались? ))

У нас все еще противоречия.

V>>>Отвечу: ad hoc — это наличие конкурирующих специализаций. Это ВЕСЬ мой ответ.

S>>Поверхности у всех разные. На моей поверхности elem и lookup ad-hoc полиморфны. На твоей — я так и не понял из ВСЕГО твоего ответа.

V>ОК.

V>Оба elem и lookup параметрически полиморфны прямо по определению параметрического полиморфизма. На обе эти ф-ии можно подать аргументы несчетного кол-ва типов. Главное, чтобы такой тип принадлежал вселенной Eq ("классу типов" в терминах Хаскеля).
Вот видишь. Ты пишешь об inclusion полиморфизме как об параметрическом.

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



S>>Я тут копчу лишь за то, что компараторы, использующие "натуральные" сравнения ad-hoc полиморфны.


V>"Внизу" почти всегда будет ad hoc. ))

V>Вон как в примере ф-ии верхнего уровня Draw.
V>Само тело ф-ии параметрически полиморфно прямо по определению.
Увы, нет. Ты так и не привел ни одного определения параметрического полиморфизма, согласно которому компаратор (или Draw) был бы параметрически полиморфен.
V>Но из этого тела через рантайм-диспетчеризацию вызываются ad hoc методы Draw, уникальные для каждого наследника Widget (или группы наследников).
Что однозначно определяет ad-hoc.

S>>как и все, что их прямо или косвенно использует. Исключая ФВП, которые используют ad-hoc постольку-поскольку им их явно передали.


V>Э, нет. Это параметрический полиморфизм распространяется "вверх", т.е. тип, производный от полиморфного, тоже будет полиморфным (например, список полиморфных переменных). В противоположность ему, ad hoc применяется только в конкретном месте, и не распространяется ни вверх, ни вниз. Это просто выбор "по-месту" некоей перегрузки (специализации) из множества их.

Согласно определениям, которые я приводил — все наоборот. ad hoc распространяется вверх.
Re[32]: «Собаку съел»
От: vdimas Россия  
Дата: 17.02.17 06:55
Оценка:
Здравствуйте, samius, Вы писали:

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

S>Указание на то, где ad-hoc поддерживается посредством перегрузки функций — не является критерием того, что считать ad-hoc, а что нет. Это лишь пример.

Как раз здесь — это НЕОБХОДИМОЕ условие.
Без поддержки перегрузки ф-ий не бывает ad hoc.

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

Зависимые ф-ии умеют оперировать над аргументами разных типов.
В случае ad hoc полиморфизма в языке должна присутствовать принципиальная возможность определять разные версии одной и той же ф-ии для разных типов аргументов (или групп типов).


S>А классификация (по Стрэчи) предыдущим разделом. Там же указано что ограничение типа аргумента классом типа — есть ad-hoc.


Это ошибка. Или самого Стрэчи или ты вырвал пример из контекста.
Вполне возможно, что речь шла об одной специализации из многих — тогда возникает тот самый ad hoc.

Потому что с т.з. лямбда-исчисления, у нас есть только ф-ии с одним аргументом.
Ф-ии с множеством аргументов приводимы через карринг к ф-иям с одним аргументом.
"Чистые" ф-ии без аргументов эквивалентны константам.
Ф-ии отличаются по их идентификатором.
Итого, всё семейство перегруженных функций от одного аргумента считается одной и той же ф-ией.
Эти моменты надо помнить при чтении тех авторов, которые укушены лямбда-исчислением Черча.
Хотя, ИМХО, лямбда-исчисление — это уровень 0, быть им укушенным — стыдно.
Re[33]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 17.02.17 07:18
Оценка:
Здравствуйте, vdimas, Вы писали:

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


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

S>>Указание на то, где ad-hoc поддерживается посредством перегрузки функций — не является критерием того, что считать ad-hoc, а что нет. Это лишь пример.

V>Как раз здесь — это НЕОБХОДИМОЕ условие.

V>Без поддержки перегрузки ф-ий не бывает ad hoc.
приведение — ad hoc.

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

Одна мономорфная функция + аргументы разного типа — уже полиморфизм.

V>Зависимые ф-ии умеют оперировать над аргументами разных типов.

V>В случае ad hoc полиморфизма в языке должна присутствовать принципиальная возможность определять разные версии одной и той же ф-ии для разных типов аргументов (или групп типов).
Или вызывать одну и ту же функцию с разными типами.


S>>А классификация (по Стрэчи) предыдущим разделом. Там же указано что ограничение типа аргумента классом типа — есть ad-hoc.


V>Это ошибка. Или самого Стрэчи или ты вырвал пример из контекста.

Это классификация самого Стрэчи. Поэтому вряд ли ты можешь ему указывать на ошибку в предложении называть зеленое зеленым. А вот из контекста я мог вырвать. Но найди мне источник, где бы говорилось что ограничение типа аргумента классом типа — есть не ad-hoc, а параметрический.

V>Вполне возможно, что речь шла об одной специализации из многих — тогда возникает тот самый ad hoc.


V>Потому что с т.з. лямбда-исчисления, у нас есть только ф-ии с одним аргументом.

Вообще не понятно, причем тут число аргументов.
Re[34]: «Собаку съел»
От: vdimas Россия  
Дата: 17.02.17 07:47
Оценка:
Здравствуйте, samius, Вы писали:

V>>Без поддержки перегрузки ф-ий не бывает ad hoc.

S>приведение — ad hoc.

Приведение чего куда?


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

S>Одна мономорфная функция + аргументы разного типа — уже полиморфизм.

Противоречишь сам себе.
Полиморфизм — это возможность подавать аргументы разного типа на одну и ту же ф-ию.


V>>Зависимые ф-ии умеют оперировать над аргументами разных типов.

V>>В случае ad hoc полиморфизма в языке должна присутствовать принципиальная возможность определять разные версии одной и той же ф-ии для разных типов аргументов (или групп типов).
S>Или вызывать одну и ту же функцию с разными типами.

Это и есть определение "полиморфизма". Не ad hoc и не параметрического, а как такового.


S>>>А классификация (по Стрэчи) предыдущим разделом. Там же указано что ограничение типа аргумента классом типа — есть ad-hoc.

V>>Это ошибка. Или самого Стрэчи или ты вырвал пример из контекста.
S>Это классификация самого Стрэчи.

Можно целиком?
Потому что есть вероятность, что будет как с тем отрывком из Хаскель-вики.


S>Поэтому вряд ли ты можешь ему указывать на ошибку в предложении называть зеленое зеленым.


И опять ты торопишься.
Если ты не правильно понял — я тебе покажу это.
Если Стрэчи ошибается — я тоже легко это покажу.

А вот эти вещи насчет "зеленого" давай оставим, плиз.


S>А вот из контекста я мог вырвать. Но найди мне источник, где бы говорилось что ограничение типа аргумента классом типа — есть не ad-hoc, а параметрический.


ИМХО, ты всё еще пытаешься жульничать, хотя я уже несколько раз на это отвечал:
единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc.

И сколько раз мне еще надо повторить, что признаком ad hoc является наличие более одной "версии тела" одной и той же ф-ии?
Ну это просто механика такая (одна из механик) реализации полиморфизма.

И сколько раз мне надо повторять, что признаком параметрического полиморфизма является возможность подавать на одну и ту же "версию тела" аргументы разных типов?


V>>Потому что с т.з. лямбда-исчисления, у нас есть только ф-ии с одним аргументом.

S>Вообще не понятно, причем тут число аргументов.

При том, что же следует считать "одной и той же ф-ией"?
Т.е. "что такое полиморфизм"?

Например, если разрешается перегрузка ф-ий по кол-ву аргументов, то ф-ии с разным кол-вом аргументов уже сложно считать "одной и той же ф-ией".

Именно поэтому лямбда-исчисление называет ф-ией такую ф-ию, у которой строго один аргумент. А все остальные варианты (кроме 0-ля аргументов) в рамках этого исчисления сначала приводятся к варианту с 1-м аргументом, а потом уже идут остальные рассуждения.
Отредактировано 17.02.2017 9:00 vdimas . Предыдущая версия .
Re[56]: «Собаку съел»
От: alex_public  
Дата: 17.02.17 10:10
Оценка:
Здравствуйте, samius, Вы писали:

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

_>>Вот в том то и дело что могу. Более того, это будет абсолютно адекватное рассуждение, на которое ни один нормальный программист не возразит. Потому что понятие "поведение" не является каким-то термином и в одном из вариантов его применения к данной ситуации это будет справедливо.
S>Опять кванторы, смысл которых ты не постиг.

Перечитай ещё раз весь текст с начала и разберись уже наконец, кто реально тут не понимает.

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

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

S>Я не говорил, что это строго научный термин. Я говорил что под ним обычно понимают. И не говорил, что однозначно. Скорее, схожим образом (кроме тебя). Терпение. Чуть ниже.

Пролистал до конца сообщения но так и не нашёл определения для "поведения функции". Ни научного, ни даже твоего личного. Где оно?

_>>Т.е. можно быть параметрически полиморфной и при этом иметь в глубинах своего стека вызовов ad hoc код? )

S>Мы это уже проходили неоднократно. Отмотай назад, мое мнение не изменилось. А желание тебе разжевывать — поубавилось.

В прошлом ты пытался выкрутиться из этого противоречия в своём мировоззрение с помощью утверждения, что "apply f" — это уже совсем другая функция с другими свойствами. Когда же ты открыл для себя, что в реальности используется всё та же apply, то начал придумывать новые отмазки, что мол для ФВП надо делать исключения и определять их по другому. Так что конкретно ты имеешь в виду под "своим мнением"? В этом потоке судорожных попыток как-то замять противоречивость никакой чёткой и однозначной позиции я так и не увидел.

_>>Конечно. Но при этом сама функция то не изменится. Получается, что при твоём подходе полиморфизм подобной функции определяется не по её личным свойствам, а по параметрам какого-то постороннего кода.

S>О, только что у apply переданный параметром код был не посторонний.

Ну вот, сам же видишь противоречия в своей позиции. В реальности между работой apply и my_equal_to нет никакой разницы. Причём это вне зависимости от того как на них смотреть, с твоих позиций или с моих — эти функции одинаковы по своему устройству. Только вот с моими взглядами (где всё обсуждаемое параметрически полиморфно) этот факт отлично сочетается, а с твоими (в которых одна из этих функций почему-то ad hoc, а другая нет) наблюдается противоречие.

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

S>Я продемонстрировал вместо "хоть одной" даже две, если не ошибаюсь. Чем должен был поставить тебя в неловкое положение, но ты его сам делаешь еще более неловким, продолжая употреблять кванторы, суть которых пронеслась мимо твоего сознания, как, похоже, и многое другое.

В общем понятно. Мне надоело вытягивать из тебя пример — фиксируем, что не можешь продемонстрировать ничего реального, так что слив засчитан.

_>>my_equal_to сравнивает значения универсальным образом — через оператор равенства типа eq. ) Похоже именно этот момент ты никак не можешь осознать. Хотя вроде как самая элементарная абстракция...

S>Ну раз так, то перегрузка оператора == тоже сравнивает значения универсальным образом: через оператор ==. (Это называется противоречием. Их вроде бы даже раньше школьная программа включала. Жаль, что оно лишь убедит тебя в собственной правоте)

Ничего общего с твоим бредом тут нет. Операторов равенства для разных типов много — это и есть ad hoc. А оператор равенства для eq ровно один.
Re[35]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 17.02.17 14:40
Оценка:
Здравствуйте, vdimas, Вы писали:

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


V>>>Без поддержки перегрузки ф-ий не бывает ad hoc.

S>>приведение — ad hoc.

V>Приведение чего куда?

Приведение типа значения к типу аргумента функции.


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

S>>Одна мономорфная функция + аргументы разного типа — уже полиморфизм.

V>Противоречишь сам себе.

V>Полиморфизм — это возможность подавать аргументы разного типа на одну и ту же ф-ию.
ИИИИ?
double Foo(double x)
{
    return x;
}

// На одну и ту же ф-ию
Foo(42); // подали int
Foo(42f); // подали float;

Полиморфизм! Где противоречие?


V>>>Зависимые ф-ии умеют оперировать над аргументами разных типов.

V>>>В случае ad hoc полиморфизма в языке должна присутствовать принципиальная возможность определять разные версии одной и той же ф-ии для разных типов аргументов (или групп типов).
S>>Или вызывать одну и ту же функцию с разными типами.

V>Это и есть определение "полиморфизма". Не ad hoc и не параметрического, а как такового.

Я про пример вызова мономорфной функции с разными типами. По Стрэчи это ad-hoc, тк. работает для ограниченного множества типов и требует специального кода для приведения.

S>>>>А классификация (по Стрэчи) предыдущим разделом. Там же указано что ограничение типа аргумента классом типа — есть ad-hoc.

V>>>Это ошибка. Или самого Стрэчи или ты вырвал пример из контекста.
S>>Это классификация самого Стрэчи.

V>Можно целиком?

Можно, но не нужно сюда целиком раздел копировать.

V>Потому что есть вероятность, что будет как с тем отрывком из Хаскель-вики.

Я думаю что она стремится к 1.

S>>Поэтому вряд ли ты можешь ему указывать на ошибку в предложении называть зеленое зеленым.


V>И опять ты торопишься.

V>Если ты не правильно понял — я тебе покажу это.
Где-то месяц уже пытаешься

V>Если Стрэчи ошибается — я тоже легко это покажу.

Наверное, так же легко.

V>А вот эти вещи насчет "зеленого" давай оставим, плиз.

хорошо. Но если бы ты дал определение, а потом спустя 50 лет чел бы сказал что ты не прав, так не приведя альтернативного, то как бы ты отнесся к тому что ты бы стал не прав?

S>>А вот из контекста я мог вырвать. Но найди мне источник, где бы говорилось что ограничение типа аргумента классом типа — есть не ad-hoc, а параметрический.


V>ИМХО, ты всё еще пытаешься жульничать, хотя я уже несколько раз на это отвечал:

V>единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc.
Жаль, количество твоих ответов не переходит в качество.

V>И сколько раз мне еще надо повторить, что признаком ad hoc является наличие более одной "версии тела" одной и той же ф-ии?

Сколько угодно, пока ты не убедишь, что твоя классификация лучше чем у Стрэчи. Пока ни одного аргумента не было.

V>Ну это просто механика такая (одна из механик) реализации полиморфизма.

Да, одна из.

V>И сколько раз мне надо повторять, что признаком параметрического полиморфизма является возможность подавать на одну и ту же "версию тела" аргументы разных типов?

То же самое. Приведи классификацию, где это будет верно. А то получается что ad-hoc через приведение типа — это уже параметрический.

V>>>Потому что с т.з. лямбда-исчисления, у нас есть только ф-ии с одним аргументом.

S>>Вообще не понятно, причем тут число аргументов.

V>При том, что же следует считать "одной и той же ф-ией"?

V>Т.е. "что такое полиморфизм"?

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

Хорошее замечание. Годится. Серьезно.

V>Именно поэтому лямбда-исчисление называет ф-ией такую ф-ию, у которой строго один аргумент. А все остальные варианты (кроме 0-ля аргументов) в рамках этого исчисления сначала приводятся к варианту с 1-м аргументом, а потом уже идут остальные рассуждения.

Давай рассуждать о функциях с одним аргументом — кортежем. Если так будет проще рассуждать. Но я не замечал что кто-то из нас (с тобой) пытается соскочить за счет числа аргументов.
Re[57]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 17.02.17 15:34
Оценка:
Здравствуйте, alex_public, Вы писали:

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


S>>Опять кванторы, смысл которых ты не постиг.


_>Перечитай ещё раз весь текст с начала и разберись уже наконец, кто реально тут не понимает.

Нет смысла. Кванторы — твоя слабая сторона.

_>Ну и отдельно замечу, что попытки подобного стиля общения на инженерном форуме от человека, который несколькими сообщениями ранее не сомневался в реализации каррирования в машинных кодах (от одной мысли о подобном любой студент изучивший базовые принципы устройства ЦПУ смеялся бы очень долго), выглядят довольно жалко и убого.

Хы, пропустил я как-то момент, когда студенты начали изучать принципы устройства ЦПУ c реализации каррирования в GHC.
Да и похоже что сам Стрэчи, введя классификацию в 1967м году выглядел бы жалко и убого. Он, бедолага, и Хаскеля-то не видел. Как он вообще мог, не зная частной реализации каррирования в машинных кодах, вводить такие классификации!!!

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

S>>Я не говорил, что это строго научный термин. Я говорил что под ним обычно понимают. И не говорил, что однозначно. Скорее, схожим образом (кроме тебя). Терпение. Чуть ниже.

_>Пролистал до конца сообщения но так и не нашёл определения для "поведения функции". Ни научного, ни даже твоего личного. Где оно?

Тебе надо было листать не мое сообщение, а спецификацию C++. Я вроде бы недвусмысленно указал на это. Да ладно уж.

S>>Мы это уже проходили неоднократно. Отмотай назад, мое мнение не изменилось. А желание тебе разжевывать — поубавилось.


_>В прошлом ты пытался выкрутиться из этого противоречия в своём мировоззрение с помощью утверждения, что "apply f" — это уже совсем другая функция с другими свойствами. Когда же ты открыл для себя, что в реальности используется всё та же apply, то начал придумывать новые отмазки, что мол для ФВП надо делать исключения и определять их по другому. Так что конкретно ты имеешь в виду под "своим мнением"? В этом потоке судорожных попыток как-то замять противоречивость никакой чёткой и однозначной позиции я так и не увидел.

Мне жаль.

_>>>Конечно. Но при этом сама функция то не изменится. Получается, что при твоём подходе полиморфизм подобной функции определяется не по её личным свойствам, а по параметрам какого-то постороннего кода.

S>>О, только что у apply переданный параметром код был не посторонний.

_>Ну вот, сам же видишь противоречия в своей позиции. В реальности между работой apply и my_equal_to нет никакой разницы. Причём это вне зависимости от того как на них смотреть, с твоих позиций или с моих — эти функции одинаковы по своему устройству. Только вот с моими взглядами (где всё обсуждаемое параметрически полиморфно) этот факт отлично сочетается, а с твоими (в которых одна из этих функций почему-то ad hoc, а другая нет) наблюдается противоречие.

Я уже перчислял, чему противоречат твои взгляды. Возможно, тебе стоило бы озадачитьься этим, а не искать противоречие в моих.

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

S>>Я продемонстрировал вместо "хоть одной" даже две, если не ошибаюсь. Чем должен был поставить тебя в неловкое положение, но ты его сам делаешь еще более неловким, продолжая употреблять кванторы, суть которых пронеслась мимо твоего сознания, как, похоже, и многое другое.

_>В общем понятно. Мне надоело вытягивать из тебя пример — фиксируем, что не можешь продемонстрировать ничего реального, так что слив засчитан.

Да пожалуйста. Мне даже льстит немного то, каким людям вместе со мной ты засчитал слив.

_>>>my_equal_to сравнивает значения универсальным образом — через оператор равенства типа eq. ) Похоже именно этот момент ты никак не можешь осознать. Хотя вроде как самая элементарная абстракция...

S>>Ну раз так, то перегрузка оператора == тоже сравнивает значения универсальным образом: через оператор ==. (Это называется противоречием. Их вроде бы даже раньше школьная программа включала. Жаль, что оно лишь убедит тебя в собственной правоте)

_>Ничего общего с твоим бредом тут нет. Операторов равенства для разных типов много — это и есть ad hoc. А оператор равенства для eq ровно один.

функция
myEq a b = a == b
тоже одна. И она ad-hoc.
Re[36]: «Собаку съел»
От: vdimas Россия  
Дата: 19.02.17 11:12
Оценка:
Здравствуйте, samius, Вы писали:

V>>>>Без поддержки перегрузки ф-ий не бывает ad hoc.

S>>>приведение — ad hoc.
V>>Приведение чего куда?
S>Приведение типа значения к типу аргумента функции.

Из вики:

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



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

S>>>Одна мономорфная функция + аргументы разного типа — уже полиморфизм.
V>>Противоречишь сам себе.
V>>Полиморфизм — это возможность подавать аргументы разного типа на одну и ту же ф-ию.
S>ИИИИ?

И всё. Приведение аргументов происходит ВНЕ функции. Сама функция об это не знает.

S>// На одну и ту же ф-ию

S>Foo(42); // подали int
S>Foo(42f); // подали float;
S>Полиморфизм! Где противоречие?

Твои примеры эквивалентны вот этому:
double d1 = 42;
Foo(d1);
double d2 = 42f;
Foo(d2);

Потому что "под капотом" именно это и происходит.
Ad hoc есть, полиморфизма нет. ))


V>>Это и есть определение "полиморфизма". Не ad hoc и не параметрического, а как такового.

S>Я про пример вызова мономорфной функции с разными типами. По Стрэчи это ad-hoc, тк. работает для ограниченного множества типов и требует специального кода для приведения.

По-моему, ты злостно искажаешь Стрэтчи:

Многие языки программирования предоставляют синтаксический механизм для назначения нескольким мономорфным функциям единого имени (идентификатора).

В этом случае, в исходном коде становится возможным осуществлять вызов функции с фактическими параметрами разных типов, но в скомпилированном коде фактически происходит вызов различных функций (см. перегрузка процедур и функций). Стрэчи назвал такую возможность «ad hoc полиморфизмом».


S>>>>>А классификация (по Стрэчи) предыдущим разделом. Там же указано что ограничение типа аргумента классом типа — есть ad-hoc.

V>>>>Это ошибка. Или самого Стрэчи или ты вырвал пример из контекста.
S>>>Это классификация самого Стрэчи.
V>>Можно целиком?
S>Можно, но не нужно сюда целиком раздел копировать.

Ну вот выше цитата по твоей ссылке.

V>>Потому что есть вероятность, что будет как с тем отрывком из Хаскель-вики.

S>Я думаю что она стремится к 1.


V>>И опять ты торопишься.

V>>Если ты не правильно понял — я тебе покажу это.
S>Где-то месяц уже пытаешься

Я только 3 сообщения назад увидел, как ты это понимаешь. ))

В общем, тебе или стоит показать, что именно привело тебя к такому выводу:
"ограничение типа аргумента классом типа — есть ad-hoc полиморфизм".
или уже сделать над собой усилие и поменять для себя смысл этого термина на общепринятый.

Неужели сам не увидел, что из твоей формулировки получается бредовое следствие, а именно — объявление любой мономорфной ф-ии точно так же "есть ad hoc полиморфизм".


V>>Если Стрэчи ошибается — я тоже легко это покажу.

S>Наверное, так же легко.

Ес-но, если дашь цитату, из которой ты сделал вот тот свой вывод.
Ключевое-то слово было "если". ))


V>>А вот эти вещи насчет "зеленого" давай оставим, плиз.

S>хорошо. Но если бы ты дал определение, а потом спустя 50 лет чел бы сказал что ты не прав, так не приведя альтернативного, то как бы ты отнесся к тому что ты бы стал не прав?

Я думаю, что ты сейчас безосновательно обвиняешь меня в неконструктивной критике, а это уже наезд. ))
Причем, наезд какой-то неожиданно ни к месту, ни на что не влияющий и никуда не ведущий.
И тем более нелепый, что все ходы-то записаны: у тебя не получится на этом форуме за все годы найти хоть один момент, где я бы, проявляя несогласие, не озвучивал бы альтернативного варианта.


V>>ИМХО, ты всё еще пытаешься жульничать, хотя я уже несколько раз на это отвечал:

V>>единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc.
S>Жаль, количество твоих ответов не переходит в качество.

Тю, так это не наезд, а в трех соснах заблудился, что ле?

Ключевое выделил:

единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc


Многие языки программирования предоставляют синтаксический механизм для назначения нескольким мономорфным функциям единого имени (идентификатора). В этом случае, в исходном коде становится возможным осуществлять вызов функции с фактическими параметрами разных типов...
Стрэчи назвал такую возможность «ad hoc полиморфизмом»



V>>И сколько раз мне еще надо повторить, что признаком ad hoc является наличие более одной "версии тела" одной и той же ф-ии?

S>Сколько угодно, пока ты не убедишь, что твоя классификация лучше чем у Стрэчи.

Это и есть классификация Стрэчи.


S>Пока ни одного аргумента не было.


Прямое вранье.


V>>И сколько раз мне надо повторять, что признаком параметрического полиморфизма является возможность подавать на одну и ту же "версию тела" аргументы разных типов?

S>То же самое. Приведи классификацию, где это будет верно.

Привел неоднократно.


S>А то получается что ad-hoc через приведение типа — это уже параметрический.


Приведение типа является разновидностью ad hoc полиморфизма только по версии Карделли (по твоей же ссылке).
Стрэтч такого не задвигал.
И вики тоже с Карделли НЕ согласна, хотя приводит его классификацию (в кач-ве сугубо ознакомительной информации, вестимо).


V>>Именно поэтому лямбда-исчисление называет ф-ией такую ф-ию, у которой строго один аргумент. А все остальные варианты (кроме 0-ля аргументов) в рамках этого исчисления сначала приводятся к варианту с 1-м аргументом, а потом уже идут остальные рассуждения.

S>Давай рассуждать о функциях с одним аргументом — кортежем. Если так будет проще рассуждать.

Можно и так. Главное, чтобы ф-ия зависела от единственного типа — от типа единственного аргумента.
Т.е., кортеж — это тип, ОК.

Просто далеко не во всех языках кортеж аргументов — это тип или вообще есть "кортеж".
В большинстве мейнстримовых такой "кортеж" надо объявлять явно — структуру в Паскале, С, С#. И так же явно использовать затем, т.е. возвращаемся к одному аргументу. ))


S>Но я не замечал что кто-то из нас (с тобой) пытается соскочить за счет числа аргументов.


Я и не обвинял тут никого в попытке соскочить через число аргументов.
Просто уточнял тот момент, что считать "перегрузкой ф-ии".

Итого, в исходном виде — это перегрузка такой ф-ии, у которой ровно один аргумент. Т.е. в лямбда-исчислении считается, что если мы объявляем "конкурирующую" специализацию ф-ии, то мы НЕ объявляем новую ф-ию, а добавляем специализацию к имеющейся. Прямо в этом месте и возникает ad hoc полиморфизм.

И да. Если уж начистоту... это не бог весть какой рокет-саенс, чтобы так долго упрямиться. ))
Отредактировано 19.02.2017 11:29 vdimas . Предыдущая версия .
Re[34]: «Собаку съел»
От: vdimas Россия  
Дата: 19.02.17 12:18
Оценка:
Здравствуйте, samius, Вы писали:

V>>Ну и тем более не доверяй Вики. ))

S>Конечно, особенно если она совпадает с классификацией, на которую ссылается. Это особо подозрительно.

Вики противоречит самой себе на одной и той же странице.
Это не подозрительно, это банально смешно. ))


V>>Я вот всё жду, когда вот эту опенсорсную книгу докончат:

V>>https://hott.github.io/book/nightly/hott-online-1075-g3c53219.pdf
V>>а потом переведут на русский.
V>>Этой книге можно верить.
S>За ссылку спасибо, буду верить. Но вот что касается конкретно parametric/ad-hoc — там верить нечему, такие наборы букв не встречаются. Сложно руководствоваться книгой для отделения мух от котлет, если ни те ни другие в книге не помянуты.

Там дана четкая формулировка, что есть полиморфизм:

A polymorphic function is one which takes a type as one of its arguments ...


И оно нам нужно как раз для того, чтобы ты не приводил (как рядом) примеры приведение аргументов как разновидность полиморфизма.


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

S>Заблуждения при этом это то, с чем твое пролетарское чутье не согласно?

Если авторы не согласны друг с другом, то кто-то из них ошибается, верно?
А моё "чутьё" тут лишь выбирает "верную сторону".
Например, книга по ссылке на сегодня — наиболее полная классификация из теории типов.

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


V>>И да. Некоторые авторы в запале "прозрения" называют параметрический полиморфизм "истинным полиморфизмом".

V>>В общем случае это не так. В общем случае речь идёт о "зависимом функциональном типе" (упомянут выше).
V>>Усё. Остальное зависит от техник, частностей и т.д.
S>То есть, ты в этой книге упоминания ad-hoc тоже не нашел, и потому все остальные упоминания стали мутными.

По-моему, я высказался вполне однозначно, что именно является мутным: "Некоторые авторы ... называют параметрический полиморфизм истинным полиморфизмом". Тем более, что здесь ты отвечал на абзац, где уже обсуждалась твоя вики-страница.

V>>Запомним это определение. Оно верное до тех пор, пока "исполнение" будет означать "исполнение по исходнику", а не по машинным кодам. Где-то я даже встречал "физическое исполнение" и тоже ужасался. )) В книге по ссылке говорится:

V>>

V>>A polymorphic function is one which takes a type as one of its arguments, and then acts on elements of that type.

V>>Заметь, и параметрический и ad hoc-полиморфизмы прекрасно подходят под определение.
S>Ничего нового. Это устоявшееся определение полиморфизма вообще. Например, у Luca Cardelli
S>

S>Polymorphic functions are functions whose operands (actual parameters) can have more than one type.


Что НЕ эквивалентно определению из данной мною книги.
Согласно неё полиморфная ф-ия берет два аргумента на входе:

An example is the polymorphic identity function id: ∏(A:U) A → A, which we define by id :≡ λ(A : U).λ(x : A).x.

На всяк случай, запись через лямбда-абстракции эквивалентна вот этому объявлению:
function id(A : U, x : A) : A => x.
Где U — семейство типов, А — конкретный тип, x — единственный аргумент-значение некоей функции с идентификатором id.


S>Деление на parametric/ad-hoc обычно следует абзацем ниже. Но у HOTT до этого не дошло.


Зато "дошло" до отсечения из "полиморфизма" части классификации твоего Луки Карделли.
Причем, легким и непринуждённым движением руки. ))

Я правильно понимаю, что ты ссылаешься на вот эту его работу?
http://www.lucacardelli.name/Papers/TypefulProg.pdf
ы-ы-ы, как грится:

In ad hoc polymorphism a function can behave in arbitrarily different ways on objects of different types. We shall ignore this view here, and consider only generic polymorphism where a function behaves in some uniform way over all the relevant types.

Этот Лука вообще отвергает ad hoc как разновидность полиморфизма, в то время как согласно Hott — это несомненно разновидность полиморфизма.

Видишь как удобно оперировать классификациями, обладающими полнотой, супротив писанины некоих авторов, на которых молятся (непонятно с чего) хаскелисты. ))

И да. Высмеиваемая мною статья из Вики была написана несомненно хаскелистами. Почему-то именно в общении с ними я наблюдал максимальное кол-во предрассудков, упорного мифотворчества и святой веры во всевозможные городские легенды. Все это, в первую очередь, антинаучно. А во-вторую — просто глупо. Один из авторов Хаскеля пару лет назад признался, что сам проект (язык Хаскель) провалился. Он высказывался в том плане, что если на иммутабельных переменных можно проэмулировать работу мутабельных (есть у них такой трюк — State) и уже на эмулируемых мутабельных повторить все те же самые грабли, то вся эта затея, получается, не имела смысла.


V>>В первом случае мы напишем единственное тело ф-ии, которое сможет обслуживать, допустим, все типы из данной вселенной.

V>>Во втором случае мы для одной и той же ф-ии напишем несколько версий тел — под разные типы из данной вселенной (или их семейства — подвселенных).
S>Верно

Ну и слава богу.


V>>Тут надо сделать паузу и обратить внимание, что в последнем случае, когда речь идёт об обслуживании некоего ограниченного семейства типов из вселенной, то опять получается параметрический полиморфизм, но уже на вселенной меньшего ранга.(*)

S>Верно. Но ты потерял чистоту квантора ∀.

Я ничего не терял. Я же сразу тебе сказал, что спор сейчас пойдёт о "необходимом" vs "достаточном".
Сразу — как только увидел твою цитату из хаскель-вики.

Это же было как на ладони, там получались ровно два сценария:
— или ты соглашаешься, что не правильно понял про ad hoc-полиморфизм;
— или начинаешь спекулировать насчет "необходимом" vs "достаточном"... и что самое обидное — так и вышло (С).

Моё предупреждение не сработало. Пичалька...
Отредактировано 19.02.2017 15:00 vdimas . Предыдущая версия .
Re[17]: IEquatable<T>
От: vdimas Россия  
Дата: 19.02.17 13:43
Оценка:
Здравствуйте, samius, Вы писали:

V>>Её просто скоро не будет в свободном доступе. ))

V>>Всё ж к этому идёт.
S>Что всё? Дотнет нейтив? Ну будет на худой конец компилятор указывать тип компарера.

Не будет до тех пор, пока ограничения генериков не станут частью типа.


V>>>>Это отказ от обсуждения систем типов и возможностей параметрического полиморфизма? ))

S>>>List<T> параметрически полиморфен. Что тут еще обсуждать?

V>>Обсуждалась система типов + курьёзы, связанные с т.н. "типизированным параметрическим полиморфизмом", при попытке использовать его в стиле тру-ООП, когда разработчики такой системы типов решают облегчить себе жизнь.

V>>Не работает это...
S>Твой курьез не сработал. Я написал IndexOf извне класса и система типов пережила это.

Да ничего ты не написал. ))
У тебя нет самой возможности писать конкурирующие специализации в C#, типа таких:
class MyExtentions 
{
    public int IndexOf<T>(IList<T> list, T value) {}
    public int IndexOf<T>(IList<T> list, T value) where T : IEquatable<T> {}
}


В С++ такой трюк возможен, в Хаскеле возможен, в C# — нет.

V>>В общем, я тут больше отвечал тем, кто считает, что в С++ обитает "неполноценный параметрический полиморфизм".

S>Конечно обитает. И полноценный параметрический там тоже обитает.

Тут просто надо помнить, в чем был аргумент этих горе-обвинителей. По их мнению, "полноценный" — это который работает на рекурсивно-определяемых типах. Правда, эти обвинители не обратили внимание, что ограничение на рекурсивно-определяемые типы в С/С++ никак не связаны с параметрическим полиморфизмом, что последний унаследовал исходные возможности объявления типов языка.


V>>Там, где ты рядом скипнул, содержалась полная инфа относительно вида параметрического полиморфизма в С++ (он имеет вполне определённую классификацию — т.н. "нетипизированный параметрический полиморфизм"), а так же объяснял, как легко и непринуждённо из нетипизированного сделать типизированный, причем, более полноценный, чем "тру параметрический полиморфизм" в дотнете.

S>С IEquatable ты там кучу кода написал, но од ad-hoc не ушел и к чистому параметрическому не пришел.

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

Так-то в С++ можно придумать овердохрена способов всевозможнейших ограничений.
См. type traits и function traits.



V>>Нужна, но это невозможно для ситуации, если речь идёт об автоматически подставляемом компилятором генерик-компараторе. Тут даже не важно, value-type или ref будет этот компаратор. Соответствующий сниппет я уже приводил. Не компиллируется.

S>Он не компилируется лишь от того, что ты вкорячил его в List<T>, которому не захотел ограничивать T.

Я не "не захотел". Я не смог.
И ты не сможешь.
Потому что нельзя породить несколько версий List<T> с разными ограничениями на T. Или в одном List<T> нельзя давать методы с разными ограничениями на T.


S>Если вынести — все компилируется. Но это все равно ad-hoc.


Курьёз в том и состоит, что как пример ad hoc-полиморфизма ты мне приводил в Хаскеле как раз те примеры, где ограничение на тип является частью полиморфного типа.

Т.е., курьёз у тебя происходит классический: тут смотрим, тут не смотрим, тут рыбу заворачиваем. ))

В Хаскеле для ad hoc полиморфизма тебе потребовалось ограничение внести в систему типов, в C# уже не требуется, "это всё равно ad-hoc".
Сорри, детсад.
В случае обеих языков ad hoc происходит не там.


V>>Это не мне. Это системе типов дотнета.

V>>В Хаскель и С++ запросто сделать отдельные специализации для IEquatable<> и для любых других мыслимых "концептов".
S>Специализации! слово-то какое. Прям — ad-hoc.

Верно.
Просто не надо путать "специализацию" и "ad-hoc полиморфизм".

Я сразу же тебе и сказал, что ad-hoc полиморфизм достигается через специализацию.

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


V>>Речь сугубо о выразительности библиотек, об отсутствиии необходимости плодить ручную работу (клонирование) — рядом приводил уже ссылки на автогенерённый код, повторить ссылки? В общем, с учётом обсуждения рядом Net Native и ограничений на рефлексию — вопрос не праздный.

S>Да уперся ты в рефлексию!

Я привел её как пример дурных следствий из недоработанной системы типов дотнета.
Если бы были допустимы конкурирующие определения для IndexOf, данные мною выше в этом же посте, то никакая рефлексия была бы не нужна.
Хаскель же как-то работает без рефлексии?


V>>>>Ну вот представь, что рефлексия (т.е. хак системы типов) недоступна.

V>>>>И сразу станет принципиально.
S>>>Представил.
V>>Кодогенерацию через T4? ))
S>Тоже не повлияет на классификацию

Ну я-то не на классификацию пытаюсь повлиять, а на тебя. ))
Потому что так смешно вышло, что в дотнете отсутствуют те ср-ва, которые ты назвал необходимыми и достаточными для ad hoc полиморфизма в Хаскеле. Неужели в дотнете нет ad hoc полиморфизма? ))

Или неужели ты не видишь, к чему я давно клоню — что раз в дотнете есть ДРУГИЕ ср-ва для организации ad hoc полиморфизма, чем упомянутый трюк в Хаскель-вики, так может, признаком ad hoc является что-то другое?


V>>Тогда можно было бы использовать т.н. "специализацию" (ad hoc), чтобы иметь возможность автоматически распространять ограничения текущего контекста вычислений для низлежащего вызываемого кода.

S>Напиши код, плиз. Только подробно, чего ты хочешь добиться, и почему это не получается.

Одного объявления мало, что ле?
Ну вот с телами:
static class MyExtentions 
{
    static public int IndexOf<T>(this IList<T> list, T value)
    {
        for (int i = 0; i < list.Count; i++)
            if (Object.Equals(list[i], value))
                return i;

        return -1;
    }

    static public int IndexOf<T>(this IList<T> list, T value) where T : IEquatable<T>
    {
        for (int i = 0; i < list.Count; i++)
            if (list[i].Equals(value))
            return i;

        return -1;
    }
}


И вот никакая динамическая диспетчеризация через абстрактный компарер уже не требуется для большинства сценариев.
А значит, не требуется и кодогенерация через T4 под эти сценарии.


V>>Сейчас же в дотнете НЕТ никакой возможности распространить такие ограничения дальше.

V>>И не надо защищать систему типов C# только за то, что это C#. Будь объективен.
S>Я не защищаю (пока). Я просто понять пока не могу, что не так с IndexOf, который вне списка.

А какая разница, внутри или вне?
Если сделать как показал выше, то получим ошибку:

error CS0111: Type 'MyExtentions1' already defines a member called 'IndexOf' with the same parameter types


Если разнести эти определения по разным MyExtentions1 и MyExtentions2 и потом попытаться использовать ad-hoc полиморфизм на IndexOf:
int[] ints = { 1, 2, 3 };
int index = ints.IndexOf(2);

то получим ошибку:

error CS0121: The call is ambiguous between the following methods or properties: 'MyExtentions1.IndexOf<T>(IList<T>, T)' and 'MyExtentions2.IndexOf<T>(IList<T>, T)'



V>>Речь идёт вот о такой предполагаемой фишке:

V>>
V>>class List<T> : IList<T> 
V>>{...}

V>>class List<T> : IList<T> where T : IEquatable<T> 
V>>{...}
V>>

V>>Разные типы. Пример совместной работы ad hoc и параметрического полиморфизма (рядом ты тоже малость путал одно с другим).
S>Нету тут совместной работы. Потрял квантор всеобщности у T => нет параметрического полиморфизма.

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


S>То что получилось — специализация через ограничения. А это ad-hoc.


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


V>>Или вот о такой:

V>>
V>>class List<T> : IList<T> 
V>>{
V>>    public IndexOf(T value) {}

V>>    public IndexOf(T value) where T : IEquatable<T> {}
V>>}
V>>

V>>Разные методы, опять совместная работа разных видов полиморфизма.
S>Вынеси метод и все будет.

Вынес. Ничего не было.


S>В Хаскеле список не тащит ограничений на тип элемента.


Я показал рядом пример с методами-расширениями в C#. Не компилируется.


V>>Обрати внимание, что в дотнете последняя техника особо мощно смотрелась бы в сочетании с техникой методов-расширений. Это была бы просто киллер-фича, натурально.

S>Я тебе предложил метод расширение IndexOf, но не пойму, что ты от него нос воротишь.

До тех пор, пока не компилируется, имею право, как бэ. ))


V>>А то сейчас на код методов-расширений порой без слёз не взглянешь, когда они пытаются через рефлексию отделить массив от List<T> и от IEnumarable<T>. Согласен, порой и такое полезно, когда произошло стирание типа аж до IEnumerable<>, но уж в случае более полных специализаций можно было бы подставлять совсем эффективный код.

S>Не понял, где там рефлексия в отделении массива от IEnumerable<T>.

В реализации системных библиотек Linq.
Происходит рантайм-проверка типа аргумента и ветвление алгоритма.


V>>Они уже есть от авторов Хаскеля. В Хаскеле работает т.н. "предикативный/пренексный полиморфизм", совместно с той фишкой, что ограничения на полиморфный аргумент являются частью типа (ес-но!) этого аргумента.

S>предекативность перепендикулярна. Это просто другой признак, а не другая конкурирующая классификация деления parametric/ad-hoc.

Будь внимательней, я говорил о всяких классификациях внутри 1-го ранга одного лишь параметрического полиморфизма.
А плане ad hoc полиморфизма разногласий обычно нет.
Ты первый. )))


V>>В дотнете ограничения на тип НЕ являются частью типа. Ну вот попытайся ты хаскелистам объяснить, как так у вас вышло, что параметрические аргументы методов или типов навроде `Eq a` и `Num a` с т.з. системы типов неразличимы.

V>>Услышишь много интересного.
S>не распарсил

А зря. По всей этой ветке это был тот самый единственный, который необходимый и достаточный аргумент, дающий исчерпывающий мой поинт относительно проблем параметрического полиморфизма в C#.

ОК, вот точный аналог упомянутого в дотнете:
static class MyModule 
{
    static public T Foo<T>(T value) where T : Eq<T> {}

    static public T Foo<T>(T value) where T : Num<T> {}
}

В дотнете такое не компиллируется.
А в Хаскеле подобный сценарий — это основа основ современных практик для этого языка.


V>>Просто нашел собеседника, которому можно подобное озвучивать и он достоверно поймёт, о чем речь. ))

S>Ошибся, походу.

Да уж...
Отредактировано 19.02.2017 13:47 vdimas . Предыдущая версия .
Re[37]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 19.02.17 17:44
Оценка:
Здравствуйте, vdimas, Вы писали:

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


V>>>>>Без поддержки перегрузки ф-ий не бывает ad hoc.

S>>>>приведение — ad hoc.
V>>>Приведение чего куда?
S>>Приведение типа значения к типу аргумента функции.

V>Из вики:

V>

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

Все верно. Но ты погляди, они приведение типов классифицируют как ad-hoс, однако при этом пишут "Действительно, ad hoc полиморфизм не является истинным полиморфизмом" за две строчки до твоей цитаты. Вряд ли ты это не заметил. И да, они истинным полиморфизмом называют параметрический.


V>>>Противоречишь сам себе.

V>>>Полиморфизм — это возможность подавать аргументы разного типа на одну и ту же ф-ию.
S>>ИИИИ?

V>И всё. Приведение аргументов происходит ВНЕ функции. Сама функция об это не знает.

Какое совпадение! Перегруженные функции тоже не знают о том, что компилятор вызываает каждую из них как мономорфную. Кстати, вот это твое выделенное определение полиморфизма полностью исключает ad-hoc, т.к. перегруженные функции формально разные, просто у них имя совпадает, да? Ну т.е. фиговое у тебя определение.

V>Твои примеры эквивалентны вот этому:

V>
V>double d1 = 42;
V>Foo(d1);
V>double d2 = 42f;
V>Foo(d2);
V>

V>Потому что "под капотом" именно это и происходит.
V>Ad hoc есть, полиморфизма нет. ))
В широком понимании полиморфизма (не полиморфизма функции) — полиморфизм есть.

V>>>Это и есть определение "полиморфизма". Не ad hoc и не параметрического, а как такового.

S>>Я про пример вызова мономорфной функции с разными типами. По Стрэчи это ad-hoc, тк. работает для ограниченного множества типов и требует специального кода для приведения.

V>По-моему, ты злостно искажаешь Стрэтчи:

V>

V>Многие языки программирования предоставляют синтаксический механизм для назначения нескольким мономорфным функциям единого имени (идентификатора).

V>В этом случае, в исходном коде становится возможным осуществлять вызов функции с фактическими параметрами разных типов, но в скомпилированном коде фактически происходит вызов различных функций (см. перегрузка процедур и функций). Стрэчи назвал такую возможность «ad hoc полиморфизмом».

Все верно, но это не единственная возможность проявления ad hoc. Или Стрэчи где-то написал обратное?

V>Ну вот выше цитата по твоей ссылке.

И?


S>>Где-то месяц уже пытаешься


V>Я только 3 сообщения назад увидел, как ты это понимаешь. ))


V>В общем, тебе или стоит показать, что именно привело тебя к такому выводу:

V>"ограничение типа аргумента классом типа — есть ad-hoc полиморфизм".
Не знаю, где ты взял, может быть я так и выразился. Но само ограничение — не есть полиморфизм. Но является признаком его. Ограничение указывает на наличие специального поведения для некого типа. А специальное поведение — признак ad-hoc. Вообще, универсальным образом (не зная ничего о типе) можно сделать довольно немного вещей. Отобразнить сам в себя, положить в коробку, достать из коробки (кстати, это не касается C++). Ну и там найти длину списка. Все остальное (математические операции, сравнение и т.п.) требует специального знания о типе. Разве это не очевидно?

V>или уже сделать над собой усилие и поменять для себя смысл этого термина на общепринятый.

Я думаю что тебе надо сделать усилие.
V>Неужели сам не увидел, что из твоей формулировки получается бредовое следствие, а именно — объявление любой мономорфной ф-ии точно так же "есть ad hoc полиморфизм".
Ну, во-первых, не моей. Ты можешь прочитать об этом в той же русской вики. Во-вторых — да, для слаботипизированных языков мономорфные функции позволяют демонстрировать ad-hoc полиморфизм через приведение типа. И да, он не настоящий, не истинный. Истинным называется параметрический.

V>>>Если Стрэчи ошибается — я тоже легко это покажу.

S>>Наверное, так же легко.

V>Ес-но, если дашь цитату, из которой ты сделал вот тот свой вывод.

V>Ключевое-то слово было "если". ))
Точную цитату Стрэчи, я, конечно, не дам. Не смог найти его лекции. Но вот все, кто на него ссылаются, трактуют его единым образом. Возьми, хотя бы русскую вики.

S>>хорошо. Но если бы ты дал определение, а потом спустя 50 лет чел бы сказал что ты не прав, так не приведя альтернативного, то как бы ты отнесся к тому что ты бы стал не прав?


V>Я думаю, что ты сейчас безосновательно обвиняешь меня в неконструктивной критике, а это уже наезд. ))

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


V>>>ИМХО, ты всё еще пытаешься жульничать, хотя я уже несколько раз на это отвечал:

V>>>единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc.
S>>Жаль, количество твоих ответов не переходит в качество.

V>Тю, так это не наезд, а в трех соснах заблудился, что ле?

Так что ты называешь соснами? Ты вот не плутаешь, а классификацию так и не привел.

V>Ключевое выделил:

V>

V>единичная ф-ия с аргументом конкретного типа или класса типов — это не есть признак ad hoc, но это и не есть признак отсутствия ad hoc


V>

V>Многие языки программирования предоставляют синтаксический механизм для назначения нескольким мономорфным функциям единого имени (идентификатора). В этом случае, в исходном коде становится возможным осуществлять вызов функции с фактическими параметрами разных типов...
V>Стрэчи назвал такую возможность «ad hoc полиморфизмом»


Ты отвечал вот на это "Но найди мне источник, где бы говорилось что ограничение типа аргумента классом типа — есть не ad-hoc, а параметрический." и промахнулся.


V>>>И сколько раз мне еще надо повторить, что признаком ad hoc является наличие более одной "версии тела" одной и той же ф-ии?

S>>Сколько угодно, пока ты не убедишь, что твоя классификация лучше чем у Стрэчи.

V>Это и есть классификация Стрэчи.

О, значит у тебя своеобразное понимание Стрэчи.


S>>Пока ни одного аргумента не было.


V>Прямое вранье.

Возможно я твои аргументы считаю водой...


V>>>И сколько раз мне надо повторять, что признаком параметрического полиморфизма является возможность подавать на одну и ту же "версию тела" аргументы разных типов?

S>>То же самое. Приведи классификацию, где это будет верно.

V>Привел неоднократно.

Так где же в твоей классификации место приведению типов?


S>>А то получается что ad-hoc через приведение типа — это уже параметрический.


V>Приведение типа является разновидностью ad hoc полиморфизма только по версии Карделли (по твоей же ссылке).

Ну как? А вики?
V>Стрэтч такого не задвигал.
Пруф
V>И вики тоже с Карделли НЕ согласна, хотя приводит его классификацию (в кач-ве сугубо ознакомительной информации, вестимо).
Не согласна?

V>>>Именно поэтому лямбда-исчисление называет ф-ией такую ф-ию, у которой строго один аргумент. А все остальные варианты (кроме 0-ля аргументов) в рамках этого исчисления сначала приводятся к варианту с 1-м аргументом, а потом уже идут остальные рассуждения.

S>>Давай рассуждать о функциях с одним аргументом — кортежем. Если так будет проще рассуждать.

V>Можно и так. Главное, чтобы ф-ия зависела от единственного типа — от типа единственного аргумента.

V>Т.е., кортеж — это тип, ОК.

V>Просто далеко не во всех языках кортеж аргументов — это тип или вообще есть "кортеж".

V>В большинстве мейнстримовых такой "кортеж" надо объявлять явно — структуру в Паскале, С, С#. И так же явно использовать затем, т.е. возвращаемся к одному аргументу. ))
Пусть к одному


S>>Но я не замечал что кто-то из нас (с тобой) пытается соскочить за счет числа аргументов.


V>Я и не обвинял тут никого в попытке соскочить через число аргументов.

V>Просто уточнял тот момент, что считать "перегрузкой ф-ии".

V>Итого, в исходном виде — это перегрузка такой ф-ии, у которой ровно один аргумент. Т.е. в лямбда-исчислении считается, что если мы объявляем "конкурирующую" специализацию ф-ии, то мы НЕ объявляем новую ф-ию, а добавляем специализацию к имеющейся. Прямо в этом месте и возникает ad hoc полиморфизм.


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

Да, завязывай упрямиться.
Re[35]: «Собаку съел»
От: samius Япония http://sams-tricks.blogspot.com
Дата: 19.02.17 18:24
Оценка:
Здравствуйте, vdimas, Вы писали:

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


V>Вики противоречит самой себе на одной и той же странице.

V>Это не подозрительно, это банально смешно. ))
Ну посмеялись.


V>Там дана четкая формулировка, что есть полиморфизм:

V>

V>A polymorphic function is one which takes a type as one of its arguments ...

V>И оно нам нужно как раз для того, чтобы ты не приводил (как рядом) примеры приведение аргументов как разновидность полиморфизма.
Съезжаешь? Ты говоришь что формулировка определяет полиморфизм, но она определяет полиморфную функцию. Давай для начала определимся... "Polymorphic function" — Это полиморфизм, или полиморфная функция?

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

S>>Заблуждения при этом это то, с чем твое пролетарское чутье не согласно?

V>Если авторы не согласны друг с другом, то кто-то из них ошибается, верно?

V>А моё "чутьё" тут лишь выбирает "верную сторону".
V>Например, книга по ссылке на сегодня — наиболее полная классификация из теории типов.
Жаль, твоя наиболее полная классификация не содержит указаний по отделению ad-hoc от параметрического. Зато множество других — содержат.

V>Некоторые же виденные неоднократно классификации внутри параметрического полиморфизма 1-го ранга не обладают вообще никакой полнотой и более того — практической ценности подобные "знания" не дают. Тем более, повторюсь, что порой противоречат друг другу.

Я что-то уже забыл. Что там противоречило? Может быть оно противоречит только при твоем толковании?

V>>>И да. Некоторые авторы в запале "прозрения" называют параметрический полиморфизм "истинным полиморфизмом".

V>>>В общем случае это не так. В общем случае речь идёт о "зависимом функциональном типе" (упомянут выше).
V>>>Усё. Остальное зависит от техник, частностей и т.д.
S>>То есть, ты в этой книге упоминания ad-hoc тоже не нашел, и потому все остальные упоминания стали мутными.

V>По-моему, я высказался вполне однозначно, что именно является мутным: "Некоторые авторы ... называют параметрический полиморфизм истинным полиморфизмом". Тем более, что здесь ты отвечал на абзац, где уже обсуждалась твоя вики-страница.

Ну да, называют параметрический истинным. Ты против?

V>>>Запомним это определение. Оно верное до тех пор, пока "исполнение" будет означать "исполнение по исходнику", а не по машинным кодам. Где-то я даже встречал "физическое исполнение" и тоже ужасался. )) В книге по ссылке говорится:

V>>>

V>>>A polymorphic function is one which takes a type as one of its arguments, and then acts on elements of that type.

V>>>Заметь, и параметрический и ad hoc-полиморфизмы прекрасно подходят под определение.
S>>Ничего нового. Это устоявшееся определение полиморфизма вообще. Например, у Luca Cardelli
S>>

S>>Polymorphic functions are functions whose operands (actual parameters) can have more than one type.


V>Что НЕ эквивалентно определению из данной мною книги.

V>Согласно неё полиморфная ф-ия берет два аргумента на входе:
V>

V>An example is the polymorphic identity function id: ∏(A:U) A → A, which we define by id :≡ λ(A : U).λ(x : A).x.

V>На всяк случай, запись через лямбда-абстракции эквивалентна вот этому объявлению:
V>function id(A : U, x : A) : A => x.
V>Где U — семейство типов, А — конкретный тип, x — единственный аргумент-значение некоей функции с идентификатором id.
Так ты все-таки решил съехать через число аргументов? А зачем же соломку стелил?

S>>Деление на parametric/ad-hoc обычно следует абзацем ниже. Но у HOTT до этого не дошло.


V>Зато "дошло" до отсечения из "полиморфизма" части классификации твоего Луки Карделли.

V>Причем, легким и непринуждённым движением руки. ))

V>Я правильно понимаю, что ты ссылаешься на вот эту его работу?

V>http://www.lucacardelli.name/Papers/TypefulProg.pdf
на эту
http://lucacardelli.name/Papers/OnUnderstanding.A4.pdf
V>ы-ы-ы, как грится:
V>

V>In ad hoc polymorphism a function can behave in arbitrarily different ways on objects of different types. We shall ignore this view here, and consider only generic polymorphism where a function behaves in some uniform way over all the relevant types.

V>Этот Лука вообще отвергает ad hoc как разновидность полиморфизма,
Да не отвергает, а не рассматривает ее в пределах указанной тобой статьи.
V>в то время как согласно Hott — это несомненно разновидность полиморфизма.
Несомненно, вот только я упоминания термина не нашел.

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

Удобно оперировать тем, о чем не упомянуто в книге. Согласен.

V>И да. Высмеиваемая мною статья из Вики была написана несомненно хаскелистами. Почему-то именно в общении с ними я наблюдал максимальное кол-во предрассудков, упорного мифотворчества и святой веры во всевозможные городские легенды. Все это, в первую очередь, антинаучно. А во-вторую — просто глупо. Один из авторов Хаскеля пару лет назад признался, что сам проект (язык Хаскель) провалился. Он высказывался в том плане, что если на иммутабельных переменных можно проэмулировать работу мутабельных (есть у них такой трюк — State) и уже на эмулируемых мутабельных повторить все те же самые грабли, то вся эта затея, получается, не имела смысла.

Ну дык если ты по разному с людьми трактуешь термины, то будь готов к недопониманию. Открой секрет, ты вообще хоть с кем-нибудь нашел понимание в этом вопросе?

V>>>В первом случае мы напишем единственное тело ф-ии, которое сможет обслуживать, допустим, все типы из данной вселенной.

V>>>Во втором случае мы для одной и той же ф-ии напишем несколько версий тел — под разные типы из данной вселенной (или их семейства — подвселенных).
S>>Верно

V>Ну и слава богу.


V>>>Тут надо сделать паузу и обратить внимание, что в последнем случае, когда речь идёт об обслуживании некоего ограниченного семейства типов из вселенной, то опять получается параметрический полиморфизм, но уже на вселенной меньшего ранга.(*)

S>>Верно. Но ты потерял чистоту квантора ∀.

V>Я ничего не терял. Я же сразу тебе сказал, что спор сейчас пойдёт о "необходимом" vs "достаточном".

V>Сразу — как только увидел твою цитату из хаскель-вики.

V>Это же было как на ладони, там получались ровно два сценария:

V>- или ты соглашаешься, что не правильно понял про ad hoc-полиморфизм;
V>- или начинаешь спекулировать насчет "необходимом" vs "достаточном"... и что самое обидное — так и вышло (С).

V>Моё предупреждение не сработало. Пичалька...

Сладко поешь. Но это ты не понял про ad hoc полиморфизм в хаскельвики. Это у тебя elem параметрически полиморфна. А в хаскельвики она ad-hoc.
Re[18]: IEquatable<T>
От: samius Япония http://sams-tricks.blogspot.com
Дата: 19.02.17 18:40
Оценка:
Здравствуйте, vdimas, Вы писали:

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


S>>Что всё? Дотнет нейтив? Ну будет на худой конец компилятор указывать тип компарера.


V>Не будет до тех пор, пока ограничения генериков не станут частью типа.

Что мешает?


V>>>>>Это отказ от обсуждения систем типов и возможностей параметрического полиморфизма? ))

S>>>>List<T> параметрически полиморфен. Что тут еще обсуждать?

V>>>Обсуждалась система типов + курьёзы, связанные с т.н. "типизированным параметрическим полиморфизмом", при попытке использовать его в стиле тру-ООП, когда разработчики такой системы типов решают облегчить себе жизнь.

V>>>Не работает это...
S>>Твой курьез не сработал. Я написал IndexOf извне класса и система типов пережила это.

V>Да ничего ты не написал. ))

V>У тебя нет самой возможности писать конкурирующие специализации в C#, типа таких:
Так ты хотел именно конкурирующие специализации? Извини, из твоих постов я это не понял. А к чему они нужны, что они доказывают?
V>
V>class MyExtentions 
V>{
V>    public int IndexOf<T>(IList<T> list, T value) {}
V>    public int IndexOf<T>(IList<T> list, T value) where T : IEquatable<T> {}
V>}
V>


V>В С++ такой трюк возможен, в Хаскеле возможен, в C# — нет.

Верно, нет. Но если бы было возможно, это был бы ad-hoc. Так к чему это все?

V>>>В общем, я тут больше отвечал тем, кто считает, что в С++ обитает "неполноценный параметрический полиморфизм".

S>>Конечно обитает. И полноценный параметрический там тоже обитает.

V>Тут просто надо помнить, в чем был аргумент этих горе-обвинителей. По их мнению, "полноценный" — это который работает на рекурсивно-определяемых типах. Правда, эти обвинители не обратили внимание, что ограничение на рекурсивно-определяемые типы в С/С++ никак не связаны с параметрическим полиморфизмом, что последний унаследовал исходные возможности объявления типов языка.

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

V>>>Там, где ты рядом скипнул, содержалась полная инфа относительно вида параметрического полиморфизма в С++ (он имеет вполне определённую классификацию — т.н. "нетипизированный параметрический полиморфизм"), а так же объяснял, как легко и непринуждённо из нетипизированного сделать типизированный, причем, более полноценный, чем "тру параметрический полиморфизм" в дотнете.

S>>С IEquatable ты там кучу кода написал, но од ad-hoc не ушел и к чистому параметрическому не пришел.

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

Дотнет тоже умеет использовать ad-hoc.

V>Так-то в С++ можно придумать овердохрена способов всевозможнейших ограничений.

V>См. type traits и function traits.
Ну можно.

V>>>Нужна, но это невозможно для ситуации, если речь идёт об автоматически подставляемом компилятором генерик-компараторе. Тут даже не важно, value-type или ref будет этот компаратор. Соответствующий сниппет я уже приводил. Не компиллируется.

S>>Он не компилируется лишь от того, что ты вкорячил его в List<T>, которому не захотел ограничивать T.

V>Я не "не захотел". Я не смог.

V>И ты не сможешь.
V>Потому что нельзя породить несколько версий List<T> с разными ограничениями на T. Или в одном List<T> нельзя давать методы с разными ограничениями на T.
А ЗАЧЕМ?


S>>Если вынести — все компилируется. Но это все равно ad-hoc.


V>Курьёз в том и состоит, что как пример ad hoc-полиморфизма ты мне приводил в Хаскеле как раз те примеры, где ограничение на тип является частью полиморфного типа.

Какая разница? elem — ad hoc. IndexOf — ad hoc. Что именно меняет то, на что ты упираешь?

V>Т.е., курьёз у тебя происходит классический: тут смотрим, тут не смотрим, тут рыбу заворачиваем. ))

И там и там смотрим — видим ad-hoc. Рыба у тебя какая-то с параметрическим elem.

V>В Хаскеле для ad hoc полиморфизма тебе потребовалось ограничение внести в систему типов, в C# уже не требуется, "это всё равно ad-hoc".

V>Сорри, детсад.
Детсад — это утверждение что система типов каким-то образом влияет на то, ad hoc или нет. Покажи, откуда это вообще следует?
V>В случае обеих языков ad hoc происходит не там.
нене, языки тут не при чем. Это в твоей голове ad hoc происходит не там.


V>>>Это не мне. Это системе типов дотнета.

V>>>В Хаскель и С++ запросто сделать отдельные специализации для IEquatable<> и для любых других мыслимых "концептов".
S>>Специализации! слово-то какое. Прям — ad-hoc.

V>Верно.

V>Просто не надо путать "специализацию" и "ad-hoc полиморфизм".
Как раз надо. Специальное знание о типе — и есть ключевое отличие от параметрического, где это знание не требуется.

V>Я сразу же тебе и сказал, что ad-hoc полиморфизм достигается через специализацию.

Разве ж я с этим спорил?

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

Вот набор операций — это уже специализация. Параметрический полиморфизм не требует набора операций.

V>>>Речь сугубо о выразительности библиотек, об отсутствиии необходимости плодить ручную работу (клонирование) — рядом приводил уже ссылки на автогенерённый код, повторить ссылки? В общем, с учётом обсуждения рядом Net Native и ограничений на рефлексию — вопрос не праздный.

S>>Да уперся ты в рефлексию!

V>Я привел её как пример дурных следствий из недоработанной системы типов дотнета.

V>Если бы были допустимы конкурирующие определения для IndexOf, данные мною выше в этом же посте, то никакая рефлексия была бы не нужна.
V>Хаскель же как-то работает без рефлексии?
Ну пусть система типов дотнета недоработана. Я с этим не спорю. Я лишь утверждаю что это не имеет отношения к ad hoc/параметричности полиморфизма.

V>>>Кодогенерацию через T4? ))

S>>Тоже не повлияет на классификацию

V>Ну я-то не на классификацию пытаюсь повлиять, а на тебя. ))

V>Потому что так смешно вышло, что в дотнете отсутствуют те ср-ва, которые ты назвал необходимыми и достаточными для ad hoc полиморфизма в Хаскеле. Неужели в дотнете нет ad hoc полиморфизма? ))
Жжошь напалмом! Есть в дотнете. Перегрузка операторов и функций, приведение типа, переопределение виртуальных методов, ограничения дженериков. И это все ad hoc. Аналогом хаскелевский классов типа я считаю ограничения дженериков. Кстати, обращу твое внимание, Хаскель появился двадцать с лишним лет спустя после введения классификации Стрэчи. По-твоему до этого не было языков с ad hoc полиморфизмом?

V>Или неужели ты не видишь, к чему я давно клоню — что раз в дотнете есть ДРУГИЕ ср-ва для организации ad hoc полиморфизма, чем упомянутый трюк в Хаскель-вики, так может, признаком ad hoc является что-то другое?

Конечно, является. Как ты догадался? В вики прочитал?

V>>>Тогда можно было бы использовать т.н. "специализацию" (ad hoc), чтобы иметь возможность автоматически распространять ограничения текущего контекста вычислений для низлежащего вызываемого кода.

S>>Напиши код, плиз. Только подробно, чего ты хочешь добиться, и почему это не получается.

V>Одного объявления мало, что ле?

V>Ну вот с телами:
V>
V>static class MyExtentions 
V>{
V>    static public int IndexOf<T>(this IList<T> list, T value)
V>    {
V>        for (int i = 0; i < list.Count; i++)
V>            if (Object.Equals(list[i], value))
V>                return i;

V>        return -1;
V>    }

V>    static public int IndexOf<T>(this IList<T> list, T value) where T : IEquatable<T>
V>    {
V>        for (int i = 0; i < list.Count; i++)
V>            if (list[i].Equals(value))
V>            return i;

V>        return -1;
V>    }
V>}
V>


V>И вот никакая динамическая диспетчеризация через абстрактный компарер уже не требуется для большинства сценариев.

V>А значит, не требуется и кодогенерация через T4 под эти сценарии.
Все стало только хуже.
Итак, предположим что это работало бы в дотнете. (я вообще не против такой возможности, я просто не понимаю, какое отношение она в твоей голове имеет к ad-hoc). Одна диспетчеризация производится компилятором в момент проверки наличия ограничения для конкретного T. Уже диспетчеризация и уже использование специального знания о T. Уже ad-hoc как с выбором оверлоад метода. Далее, в первом методе идет вызов Object.Equals, который обращается к виртуальному методу Equals. Еще одна диспетчеризация, но уже времени выполнения. Второй метод с ограничением указывает на то, что для значения типа T определен СПЕЦИАЛЬНЫЙ код для выполнения сравнения. Тут ad-hoc полиморфны все варианты без вариантов.

V>>>Сейчас же в дотнете НЕТ никакой возможности распространить такие ограничения дальше.

V>>>И не надо защищать систему типов C# только за то, что это C#. Будь объективен.
S>>Я не защищаю (пока). Я просто понять пока не могу, что не так с IndexOf, который вне списка.

V>А какая разница, внутри или вне?

Я же тебе об этом и говорю.
V>Если сделать как показал выше, то получим ошибку:
V>

V>error CS0111: Type 'MyExtentions1' already defines a member called 'IndexOf' with the same parameter types

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

V>Если разнести эти определения по разным MyExtentions1 и MyExtentions2 и потом попытаться использовать ad-hoc полиморфизм на IndexOf:

Ты не можешь его попытаться использовать. Ты можешь его попытаться не использовать, но от ad-hoc ты никак не отделаешься. IndexOf обречен, т.к. сравнивает экземпляры/значения. Все что сравнивает — делает это специальным образом для каждого типа. И любой тип, который ты подашь в IndexOf, будет требовать специального сравнения, а значит, специального кода для типа T. Не говоря об ReferehceEquals. И вот уже то, что для разных типов по-разному — уже указывает на ad hoc.

V>>>Речь идёт вот о такой предполагаемой фишке:

V>>>
V>>>class List<T> : IList<T> 
V>>>{...}

V>>>class List<T> : IList<T> where T : IEquatable<T> 
V>>>{...}
V>>>

V>>>Разные типы. Пример совместной работы ad hoc и параметрического полиморфизма (рядом ты тоже малость путал одно с другим).
S>>Нету тут совместной работы. Потрял квантор всеобщности у T => нет параметрического полиморфизма.

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

ЧТО??? По-твоему любая мономорфная функция параметрически полиморфна?


S>>То что получилось — специализация через ограничения. А это ad-hoc.


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

Это не так. И даже для невыдуманного List<T>. BinarySearch, Contains, IndexOf, LastIndexOf — ad hoc.
V>Итого — совместная работа.
На разных наборах методов.

V>>>Или вот о такой:

V>>>
V>>>class List<T> : IList<T> 
V>>>{
V>>>    public IndexOf(T value) {}

V>>>    public IndexOf(T value) where T : IEquatable<T> {}
V>>>}
V>>>

V>>>Разные методы, опять совместная работа разных видов полиморфизма.
S>>Вынеси метод и все будет.

V>Вынес. Ничего не было.

Так тебе же все сразу...


S>>В Хаскеле список не тащит ограничений на тип элемента.


V>Я показал рядом пример с методами-расширениями в C#. Не компилируется.

Только потому что тебе нужна перегрузка и с ограничением и без одновременно. Естественно. Но это ничего не меняет в отношении ad hoc.


V>>>Обрати внимание, что в дотнете последняя техника особо мощно смотрелась бы в сочетании с техникой методов-расширений. Это была бы просто киллер-фича, натурально.

S>>Я тебе предложил метод расширение IndexOf, но не пойму, что ты от него нос воротишь.

V>До тех пор, пока не компилируется, имею право, как бэ. ))

Право имеешь.


V>>>А то сейчас на код методов-расширений порой без слёз не взглянешь, когда они пытаются через рефлексию отделить массив от List<T> и от IEnumarable<T>. Согласен, порой и такое полезно, когда произошло стирание типа аж до IEnumerable<>, но уж в случае более полных специализаций можно было бы подставлять совсем эффективный код.

S>>Не понял, где там рефлексия в отделении массива от IEnumerable<T>.

V>В реализации системных библиотек Linq.

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


V>Будь внимательней, я говорил о всяких классификациях внутри 1-го ранга одного лишь параметрического полиморфизма.

V>А плане ad hoc полиморфизма разногласий обычно нет.
V>Ты первый. )))
После хаскельвики и просто вики?


V>>>В дотнете ограничения на тип НЕ являются частью типа. Ну вот попытайся ты хаскелистам объяснить, как так у вас вышло, что параметрические аргументы методов или типов навроде `Eq a` и `Num a` с т.з. системы типов неразличимы.

V>>>Услышишь много интересного.
S>>не распарсил

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

Мы пока еще не договорились по поводу того, что считать параметрическим. Ты привел примеры ad hoc. И в C# они тоже ad hoc.

V>ОК, вот точный аналог упомянутого в дотнете:

V>
V>static class MyModule 
V>{
V>    static public T Foo<T>(T value) where T : Eq<T> {}

V>    static public T Foo<T>(T value) where T : Num<T> {}
V>}
V>

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


V>>>Просто нашел собеседника, которому можно подобное озвучивать и он достоверно поймёт, о чем речь. ))

S>>Ошибся, походу.

V>Да уж...

Точно.
Re[38]: «Собаку съел»
От: vdimas Россия  
Дата: 20.02.17 03:35
Оценка:
Здравствуйте, samius, Вы писали:

S>Но ты погляди, они приведение типов классифицируют как ad-hoс,


Я уже писал:

И вики тоже с Карделли НЕ согласна, хотя приводит его классификацию (в кач-ве сугубо ознакомительной информации, вестимо).


S>однако при этом пишут "Действительно, ad hoc полиморфизм не является истинным полиморфизмом"


Является прямо по определению полиморфизма.
Тут Карделли показал, что он нуб, заплутал малость.


V>>И всё. Приведение аргументов происходит ВНЕ функции. Сама функция об это не знает.

S>Какое совпадение! Перегруженные функции тоже не знают о том, что компилятор вызываает каждую из них как мономорфную.

Верно, каждая из них при ad hoc полиморфизме может быть и не полиморфной.
Но при этом можно рассуждать о зависимости ф-ии от типа аргумента ф-ии, а в теории типов только это и важно.

И напротив, в случае автоматического приведения типов аргумента у нас всегда остаётся одна и та же ф-ия, а не множество их, т.е. зависимости от типа аргумента нет. Т.е., нет полиморфизма прямо по определению.


S>Кстати, вот это твое выделенное определение полиморфизма полностью исключает ad-hoc, т.к. перегруженные функции формально разные, просто у них имя совпадает, да? Ну т.е. фиговое у тебя определение.


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


S>В широком понимании полиморфизма (не полиморфизма функции) — полиморфизм есть.


В "широком" — это не в IT-области? ))
Полиморфизмом еще называют "нечто", скажем в Физике и Химии, что может иметь разные св-ва, будучи при этом "одним и тем же".

В случае приведения типов у нас будут одни и те же св-ва, так как функция одна и та же.


V>>По-моему, ты злостно искажаешь Стрэтчи:

V>>

V>>Многие языки программирования предоставляют синтаксический механизм для назначения нескольким мономорфным функциям единого имени (идентификатора).

V>>В этом случае, в исходном коде становится возможным осуществлять вызов функции с фактическими параметрами разных типов, но в скомпилированном коде фактически происходит вызов различных функций (см. перегрузка процедур и функций). Стрэчи назвал такую возможность «ad hoc полиморфизмом».

S>Все верно, но это не единственная возможность проявления ad hoc. Или Стрэчи где-то написал обратное?

Стрэчи ввел сам термин "ad hoc полиморфизм", поэтому я отдаю право толкования этого термина ему.

Единственно что — я могу лишь уточнять, что в конкретном случае является собственно полиморфизмом, а что нет, согласно вот той ссылке на книгу по теории типов.

А так-то да, из начального термина обособился мем "ad hoc" и стал довольно-таки популярным даже без связи с "полиморфизмом". Но я и на это уже обращал твоё внимание, что речь тут идёт о разновидностях полиморфизма, а не о сленге среди программеров.


V>>Ну вот выше цитата по твоей ссылке.

S>И?

И то, что твоё словесное описание содержащегося по ссылке не сходится с её фактическим содержимым.


V>>В общем, тебе или стоит показать, что именно привело тебя к такому выводу:

V>>"ограничение типа аргумента классом типа — есть ad-hoc полиморфизм".
S>Не знаю, где ты взял, может быть я так и выразился.

Это твоя точная цитата, ты дважды просил меня опровергнуть именно такую твою формулировку.


S>Но само ограничение — не есть полиморфизм.


Бинго! ))


S>Но является признаком его.


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

А так-то многие примеры из мира Хаскеля откровенно глупы, увы.
Например, часто противопоставляют ф-ии с ограничениями ф-иям без ограничений. Якобы. Потому что часто авторы таких "противопоставлений" пихают пример работы со списком как якобы пример без ограничений. Какой кошмар. )) Список — это уже готовый концепт, это некий класс типов List и связанные с ним определения и ф-ии.


S>Ограничение указывает на наличие специального поведения для некого типа.


Ограничение указывает на обобщённый код, в котором будет использоваться типизированный концепт.
То бишь, ограничение — это ВСЕГДА параметрический полиморфизм.
Что в C#, что в Хаскеле.


S>А специальное поведение — признак ad-hoc.


Да я сразу понял ход твоих рассуждений.
Поэтому сразу же привел все признаки ad hoc полиморфизма.
Нужны все сразу. По одному эти признаки не канают.))


S>Вообще, универсальным образом (не зная ничего о типе) можно сделать довольно немного вещей. Отобразнить сам в себя, положить в коробку, достать из коробки (кстати, это не касается C++).


Положить в коробку без ограничений нельзя.
Работает "структурный полиморфизм", однако.


S>Ну и там найти длину списка.


Найти длину списка без ограничений тоже нельзя. Работает параметрический полиморфизм.


S>Все остальное (математические операции, сравнение и т.п.) требует специального знания о типе. Разве это не очевидно?


Твои рассуждения очевидны.
Но беспощадность спора была обоснованной — спор-то терминологический. ))


V>>или уже сделать над собой усилие и поменять для себя смысл этого термина на общепринятый.

S>Я думаю что тебе надо сделать усилие.
V>>Неужели сам не увидел, что из твоей формулировки получается бредовое следствие, а именно — объявление любой мономорфной ф-ии точно так же "есть ad hoc полиморфизм".
S>Ну, во-первых, не моей. Ты можешь прочитать об этом в той же русской вики. Во-вторых — да, для слаботипизированных языков мономорфные функции позволяют демонстрировать ad-hoc полиморфизм через приведение типа.

Для Хаскеля определение обобщенной ф-ии в ограничениях и мономорфной отличается не сильно.
Поэтому, даже вот без этого приведения типов, получается так, что если в Хаскеле определили некую мономорфную ф-ию — то обязательно получаем ad hoс полиморфизм? ))


S>И да, он не настоящий, не истинный. Истинным называется параметрический.


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


V>>Ес-но, если дашь цитату, из которой ты сделал вот тот свой вывод.

V>>Ключевое-то слово было "если". ))
S>Точную цитату Стрэчи, я, конечно, не дам. Не смог найти его лекции. Но вот все, кто на него ссылаются, трактуют его единым образом. Возьми, хотя бы русскую вики.

ОК, давай трактовку.
Потому что последние 20 лет я видел тоже вполне однозначное толкование ad hoc полиморфизма и был малость удивлён, встретившись с твоей интерпретацией.


V>>Я думаю, что ты сейчас безосновательно обвиняешь меня в неконструктивной критике, а это уже наезд. ))

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

Привел не раз.
Причем, местами совсем уж не раз. ))


S>Ни разу. Вот конкретно по этому вопросу. Нет нужды искать за годы.


Ну вот в каждом сообщении в этом споре, постоянно повторяя себя.


V>>Тю, так это не наезд, а в трех соснах заблудился, что ле?

S>Так что ты называешь соснами?

Это противоположное рокет-саенсу.


S>Ты вот не плутаешь, а классификацию так и не привел.


Я приводил определения как параметрического, так и ad hoc полиморфизма.
Приводил их многократно.
Вот даже в этом сообщении, на которое ты отвечаешь — минимум дважды было сказано что есть полиморфизм вообще и что есть ad hoc полиморфизм.

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


S>Ты отвечал вот на это "Но найди мне источник, где бы говорилось что ограничение типа аргумента классом типа — есть не ad-hoc, а параметрический." и промахнулся.


Так я тебе сразу дал хорошую ссылку: "типизированный параметрический полиморфизм", "концепт".
Эта вся ссылка. Причем, по состоянию Интернета на 2017-й год — исчерпывающая.

По крайней мере в тех работах, в которых говорится о типизированном параметрическом полиморфизме, ОБЯЗАТЕЛЬНО будет присутствовать "ограничение" типа-аргумента тем или иным способом. Потому что это не "ограничение" нифига (корявая терминология дотнета), а именно что "типизация" концепта.


V>>>>И сколько раз мне еще надо повторить, что признаком ad hoc является наличие более одной "версии тела" одной и той же ф-ии?

S>>>Сколько угодно, пока ты не убедишь, что твоя классификация лучше чем у Стрэчи.
V>>Это и есть классификация Стрэчи.
S>О, значит у тебя своеобразное понимание Стрэчи.

Ты уже второе сообщение подряд жилишь, спекулируешь, устраиваешь словесный бесполезный пинг-понг.
В отличие от такого бестолкового времяпрепровождения я скопировал в сообщение, на которое ты отвечаешь, определения самого Стэчи. Изволь отвечать по процитированному, или давай свои цитаты или переставай паясничать.


V>>Прямое вранье.

S>Возможно я твои аргументы считаю водой...

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


V>>Привел неоднократно.

S>Так где же в твоей классификации место приведению типов?

А нету.
Потому что не относится к полиморфизму по определению полиморфизма.


V>>Приведение типа является разновидностью ad hoc полиморфизма только по версии Карделли (по твоей же ссылке).

S>Ну как? А вики?

Вики рассказывает о разных версиях, упоминает версию Карделли.
Что не так?
До тех пор, пока Вики не говорит "от своего лица" с неё взятки гладки.


V>>Стрэтч такого не задвигал.

S>Пруф

Пруф что не задвигал?
Если бы мы обменивались остротами, было бы смешно.


V>>И вики тоже с Карделли НЕ согласна, хотя приводит его классификацию (в кач-ве сугубо ознакомительной информации, вестимо).

S>Не согласна?

Конечно не согласна. ))
Когда согласна, пишет от первого лица.
Re[36]: «Собаку съел»
От: vdimas Россия  
Дата: 20.02.17 03:59
Оценка:
Здравствуйте, samius, Вы писали:

V>>Там дана четкая формулировка, что есть полиморфизм:

V>>

V>>A polymorphic function is one which takes a type as one of its arguments ...

V>>И оно нам нужно как раз для того, чтобы ты не приводил (как рядом) примеры приведение аргументов как разновидность полиморфизма.
S>Съезжаешь?

Откуда куда?


S>Ты говоришь что формулировка определяет полиморфизм, но она определяет полиморфную функцию. Давай для начала определимся... "Polymorphic function" — Это полиморфизм, или полиморфная функция?


Это полиморфизм и есть. Он один в IT, других не завезли.
Всегда, когда речь идёт о полиморфизме, речь идёт про полиморфные ф-ии.
Барбара Лисков так же рассмотрела кортежи таких функций и принципы подстановки этих кортежей.


S>Жаль, твоя наиболее полная классификация не содержит указаний по отделению ad-hoc от параметрического.


Потому что это несущественно.


V>>Некоторые же виденные неоднократно классификации внутри параметрического полиморфизма 1-го ранга не обладают вообще никакой полнотой и более того — практической ценности подобные "знания" не дают. Тем более, повторюсь, что порой противоречат друг другу.

S>Я что-то уже забыл. Что там противоречило?

Авторы классификаций вводят каждый свою терминологию. Разные термины под одно и то же — противоречие.


S>Может быть оно противоречит только при твоем толковании?


Вопрос риторический? ))


V>>По-моему, я высказался вполне однозначно, что именно является мутным: "Некоторые авторы ... называют параметрический полиморфизм истинным полиморфизмом". Тем более, что здесь ты отвечал на абзац, где уже обсуждалась твоя вики-страница.

S>Ну да, называют параметрический истинным. Ты против?

Да, я против безграмотности.
Я общался одно время с западными "специалистами" плотно, ничего удивительного, кароч...
Нубство на нубстве.

На самом деле там всё еще узколобее, кто задвигает подобное.
"Они" (укушенные ML и Ко) называют истинным полиморфизмом только типизированный параметрический полиморфизм. Вот что бывает, когда в базовых знаниях дыра.

V>>Что НЕ эквивалентно определению из данной мною книги.

V>>Согласно неё полиморфная ф-ия берет два аргумента на входе:
S>Так ты все-таки решил съехать через число аргументов? А зачем же соломку стелил?

Затем, что аргумент-значение — один.
Другим аргументом идёт тип.
И это важно.

V>>Этот Лука вообще отвергает ad hoc как разновидность полиморфизма,

S>Да не отвергает, а не рассматривает ее в пределах указанной тобой статьи.

Это самая известная его статья, кста.


V>>в то время как согласно Hott — это несомненно разновидность полиморфизма.

S>Несомненно, вот только я упоминания термина не нашел.

Зачем тебе термин, если есть формальное определение полиморфизма?
Я уже скоро начну явзить в таких ситуациях, бо давно уже не смешно.

Прежде чем вообще спорить о том, какой вид полиморфизма получается в том или ином случае, было бы неплохо для начала убедиться, что мы имеем дело именно с полиморфизмом, не? И вот эту простую мысль я до тебя никак не могу донести. Жесть и пипец.


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

S>Удобно оперировать тем, о чем не упомянуто в книге. Согласен.

Удобно жилить, игнорить аргументы, троллить и строить из себя не понимающего.
В книге даны чудесные формальные определения.
Ты признался, что ты их до сих пор НЕ понял.
Хотя после такого подробного обсуждения поняли уже студенты 1-го курса. ))
ОК.
Пусть так.
Не выходит? — бывает.
Не всем даётся.


V>>Моё предупреждение не сработало. Пичалька...

S>Сладко поешь. Но это ты не понял про ad hoc полиморфизм в хаскельвики. Это у тебя elem параметрически полиморфна. А в хаскельвики она ad-hoc.

Ф-ия elem именно что параметрически полиморфна.
А вот ad hoc она полиморфна при этом или нет — зависит от того, есть ли конкурирующие её определения.
Это азбучные вещи.
Ты в них плаваешь.
Не понимаешь нифига.
Не можешь прочесть пяток слов по английски не потеряв смысла.
Вот, уже наговариваешь на Хаскель вики.
Ищешь виноватых.
Кошмар...
Re[19]: IEquatable<T>
От: vdimas Россия  
Дата: 20.02.17 12:34
Оценка:
Здравствуйте, samius, Вы писали:

S>>>Что всё? Дотнет нейтив? Ну будет на худой конец компилятор указывать тип компарера.

V>>Не будет до тех пор, пока ограничения генериков не станут частью типа.
S>Что мешает?

Загадка, если честно.
Должно было сразу же быть как надо.
Причем, такие изменения можно сделать не ломая имеющийся код.


V>>Да ничего ты не написал. ))

V>>У тебя нет самой возможности писать конкурирующие специализации в C#, типа таких:
S>Так ты хотел именно конкурирующие специализации? Извини, из твоих постов я это не понял.

А к чему нужны точно так же как нужна перегрузка ф-ий.
Без неё тяжело, верно.
Тут аналогично — это просто перегрузка ф-ий по типу аргумента.


S>А к чему они нужны, что они доказывают?


Странно ты вопросы формулируешь. ))
Наверно они доказывали бы наличие головы у авторов языка.


V>>В С++ такой трюк возможен, в Хаскеле возможен, в C# — нет.

S>Верно, нет. Но если бы было возможно, это был бы ad-hoc.

Да. Это был бы ad hoc сверху параметрического полиморфизма, как в любом современном языке с поддержкой типизированного параметрического полиморфизма. На то она и типизированность, чтобы отличать типы друг от друга.


V>>Тут просто надо помнить, в чем был аргумент этих горе-обвинителей. По их мнению, "полноценный" — это который работает на рекурсивно-определяемых типах. Правда, эти обвинители не обратили внимание, что ограничение на рекурсивно-определяемые типы в С/С++ никак не связаны с параметрическим полиморфизмом, что последний унаследовал исходные возможности объявления типов языка.

S>Вот зачем ты мне рассказываешь про каких-то горе-обвинителей? Они не смогли оценить твою победу над ними и ты хочешь что бы я сделал это за них?

Сама эта ветка родилась по результату сравнения св-в параметрического полиморфизма в С++ и дотнете.
И мне только в том сообщении, на которое ты отвечаешь, похоже, удалось донести — что не так-то в дотнетном варианте... ))
Тяжело... ))


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

S>Дотнет тоже умеет использовать ad-hoc.

Только в монотипах. И это удобно, ес-но.
Более того, работает вариативность/ковариативность.
Хотелось бы в параметрически-зависимых ф-иях тоже и тоже с учётом правил вариативности.


V>>Так-то в С++ можно придумать овердохрена способов всевозможнейших ограничений.

V>>См. type traits и function traits.
S>Ну можно.

Ну. В C# — нельзя.

Это я к тому, что в отличие от С++, в случае дотнета в сам язык/платформу надо включать много чего, для повышения выразительности.
Например, см. идиому С++ enable_if — она работает сугубо за счёт уже имеющихся ср-в языка.


V>>Потому что нельзя породить несколько версий List<T> с разными ограничениями на T. Или в одном List<T> нельзя давать методы с разными ограничениями на T.

S>А ЗАЧЕМ?

Зачем типизировать T? ))
Да еще статически-типизированном языке?

Странные ты опять вопросы задаешь...
Затем, вестимо, чтобы не происходило стирание типов. Чтобы больше сценариев удавалось разресолвить в момент компиляции, без всяких рефлексий и кодогенераций. Помнишь, в эпоху до генериков народ упражнялся в автогенерации "типизированных коллекций"? Или ты не застал эти времена?


V>>Курьёз в том и состоит, что как пример ad hoc-полиморфизма ты мне приводил в Хаскеле как раз те примеры, где ограничение на тип является частью полиморфного типа.

S>Какая разница? elem — ad hoc. IndexOf — ad hoc. Что именно меняет то, на что ты упираешь?

Дудки. Твой IndexOf не в состоянии быть ad hoc, потому что ты не можешь подать на него разные обобщенные типы.
И да, обе ф-ии параметрически полиморфны, сначала. А потом уже, в случае Хаскеля, возможен ad hoc. Потому что elem определена не только для обобщенных типов, но и для монотипов — для пустого списка, например.

V>>Т.е., курьёз у тебя происходит классический: тут смотрим, тут не смотрим, тут рыбу заворачиваем. ))

S>И там и там смотрим — видим ad-hoc. Рыба у тебя какая-то с параметрическим elem.

Верно. Среди нескольких (ровно двух) ad hoc определений elem есть вариант параметрически-полиморфного определения.
И можно добавлять свои параметрически-полиморфные определения для, скажем, неких своих моделей списков.
Оно так и должно работать.


S>Детсад — это утверждение что система типов каким-то образом влияет на то, ad hoc или нет.


Детсад — что-то утверждать за оппонента.


S>Покажи, откуда это вообще следует?


Покажи сие странное утверждение.


V>>В случае обеих языков ad hoc происходит не там.

S>нене, языки тут не при чем. Это в твоей голове ad hoc происходит не там.

Ясно.
За своей головой лучше бы посмотрел.

Потому что потом вообще идёт жесть и закономерный финал:

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

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

ЧТД. Ниасилил? Бывает. ))
Re[58]: «Собаку съел»
От: alex_public  
Дата: 20.02.17 14:24
Оценка:
Здравствуйте, samius, Вы писали:

_>>Перечитай ещё раз весь текст с начала и разберись уже наконец, кто реально тут не понимает.

S>Нет смысла. Кванторы — твоя слабая сторона.

Мда, так и не понял. Сочувствую. )

_>>Ну и отдельно замечу, что попытки подобного стиля общения на инженерном форуме от человека, который несколькими сообщениями ранее не сомневался в реализации каррирования в машинных кодах (от одной мысли о подобном любой студент изучивший базовые принципы устройства ЦПУ смеялся бы очень долго), выглядят довольно жалко и убого.

S>Хы, пропустил я как-то момент, когда студенты начали изучать принципы устройства ЦПУ c реализации каррирования в GHC.

Ты похоже уже забыл, что я тебе уже писал. Для того, чтобы посмеяться над идеей каррирования в машинных кодах не надо ничего знать про какие-то реализации Хаскеля и т.п. Это смешно само по себе, если знать устройство современных процессоров (попробуй просто представить себе что потребуется сгенерировать компилятору и как будет выглядеть вызов всего этого скажем в случае функции 5-и переменных). И то, что ты по прежнему этого не понимаешь, прямо поражает. Ты вообще в курсе таких вещей как аппаратный стек, пролог и эпилог функции и т.п. базовые вещи, знакомые каждому студенту? )

S>Да и похоже что сам Стрэчи, введя классификацию в 1967м году выглядел бы жалко и убого. Он, бедолага, и Хаскеля-то не видел. Как он вообще мог, не зная частной реализации каррирования в машинных кодах, вводить такие классификации!!!


The name "currying", coined by Christopher Strachey in 1967, is a reference to logician Haskell Curry.

_>>Пролистал до конца сообщения но так и не нашёл определения для "поведения функции". Ни научного, ни даже твоего личного. Где оно?

S>Тебе надо было листать не мое сообщение, а спецификацию C++. Я вроде бы недвусмысленно указал на это. Да ладно уж.

Ну т.е. ты так и не можешь представить своё определение понятия "поведение функции"? Хотя при этом говоришь что все его понимают одинаковым образом (так каким же тогда?)...

_>>В прошлом ты пытался выкрутиться из этого противоречия в своём мировоззрение с помощью утверждения, что "apply f" — это уже совсем другая функция с другими свойствами. Когда же ты открыл для себя, что в реальности используется всё та же apply, то начал придумывать новые отмазки, что мол для ФВП надо делать исключения и определять их по другому. Так что конкретно ты имеешь в виду под "своим мнением"? В этом потоке судорожных попыток как-то замять противоречивость никакой чёткой и однозначной позиции я так и не увидел.

S>Мне жаль.

Ну т.е. и насчёт противоречия с apply тебе сказать нечего? ) Что-то ты совсем сдулся как оппонент. )

_>>Ну вот, сам же видишь противоречия в своей позиции. В реальности между работой apply и my_equal_to нет никакой разницы. Причём это вне зависимости от того как на них смотреть, с твоих позиций или с моих — эти функции одинаковы по своему устройству. Только вот с моими взглядами (где всё обсуждаемое параметрически полиморфно) этот факт отлично сочетается, а с твоими (в которых одна из этих функций почему-то ad hoc, а другая нет) наблюдается противоречие.

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

И тут тебе сказать нечего. В общем всё понятно.

_>>Ничего общего с твоим бредом тут нет. Операторов равенства для разных типов много — это и есть ad hoc. А оператор равенства для eq ровно один.

S>функция
S>myEq a b = a == b
S>тоже одна. И она ad-hoc.

Глупости какие. Если убрать библиотечный сахар (реализуемый через МП) в C++ варианте и синтаксический сахар (посмотреть на внутреннюю реализацию классов типов) Хаскеля, то легко увидеть, что в обоих вариантах эти функции в реальности выглядят как-то так:
bool my_equal_to(void* a, void* b, bool (*f)(void*, void*))
{
    return f(a, b);
}

а значение f автоматически подставляется компилятором (по определению работы Хаскеля/по МП коду в конструкторе eq в варианте C++) в точках вызова my_equal_to в соответствие с передаваемыми там типами. Никакого принципиального отличия от обсуждаемой тут apply эти реализации не имеют. Но при этом они у тебя ad hoc полиморфные, а apply параметрически полиморфная.
Re[20]: IEquatable<T>
От: alex_public  
Дата: 20.02.17 14:42
Оценка:
Здравствуйте, vdimas, Вы писали:

V>Ну. В C# — нельзя.

V>Это я к тому, что в отличие от С++, в случае дотнета в сам язык/платформу надо включать много чего, для повышения выразительности.
V>Например, см. идиому С++ enable_if — она работает сугубо за счёт уже имеющихся ср-в языка.

Это конечно верно. Но всё же enable_if была достаточно некомфортна для повседневной работы, т.к. требовалось определять новые специализации и т.п. Поэтому теперь (с C++17) у нас имеется крайне удобная конструкция "if constexpr" (явно спёртый из D "static if"), которая позволяет элементарно писать такие вещи:
template <typename T> auto get_value(T t)
{
    if constexpr (is_pointer_v<T>) return *t;
    else return t;
}


Это естественно без проблем записывается и через enable_if, но гораздо менее удобно. )
Re[21]: IEquatable<T>
От: vdimas Россия  
Дата: 20.02.17 16:12
Оценка:
Здравствуйте, alex_public, Вы писали:

_>Это естественно без проблем записывается и через enable_if, но гораздо менее удобно. )


ИМХО, enable_if более "чиста" с т.з. системы типов.

Т.е. мы сразу вычеркиваем неподходящее тело ф-ии целиком, а не пытаемся "отключить" невалидную часть тела ф-ии. Потому что этот фокус режет глаз... С другой стороны, ХЗ, может дело привычки...
Re[19]: IEquatable<T>
От: vdimas Россия  
Дата: 20.02.17 17:52
Оценка:
Здравствуйте, samius, Вы писали:

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


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


V>>Если сделать как показал выше, то получим ошибку:

V>>

V>>error CS0111: Type 'MyExtentions1' already defines a member called 'IndexOf' with the same parameter types

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

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


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


А мне надо не два, а один перегруженный метод.


V>>Если разнести эти определения по разным MyExtentions1 и MyExtentions2 и потом попытаться использовать ad-hoc полиморфизм на IndexOf:

S>Ты не можешь его попытаться использовать.

Верно не могу.
Именно это и порицается.
Потому что в Хаскеле и в С++ — могу.


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


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

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


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


Не для каждого типа, а для каждого семейства типов. Прочувствуйте разницу, как грится.


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


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

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

В общем, ждем допиливания дотнета до работающего варианта.


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

S>ЧТО??? По-твоему любая мономорфная функция параметрически полиморфна?

По-моему, путать "моно-" и "поли-" грешно.


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

S>Это не так.

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


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


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


V>>Я показал рядом пример с методами-расширениями в C#. Не компилируется.

S>Только потому что тебе нужна перегрузка и с ограничением и без одновременно.

Э-э-э...
Иногда мне сложно понять, где ты издеваешься, а где просто невнимателен.

ОК, пусть будет всегда с ограничением, но ограничения пусть будут разные. Всё-равно тот пример не скомпилируется.
Это же не принципиально — я просто показал, что разные ограничения не означают разные типы аргументов.


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


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


V>>В реализации системных библиотек Linq.

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

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


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


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


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

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

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


V>>В дотнете такое не компиллируется.

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

Надоело.

Просто обращение к здравому смыслу.
Итак. Генерики дотнета считаются параметрическим полиморфизмом. Предлагаю тебе в этом месте прислушаться к мнению того самого "миллиона леммингов".

Я давал краткое определение параметрического полиморфизма:
если тело ф-ии явно или неявно параметризуется аргументом-типом — это параметрический полиморфизм.

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

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

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

Улыбнуло. Сказано верно, но само определения явно предназначено для людей, далеких от IT, или для новичков в IT.
Наверно потому что вики для всех.

Давай переведём в наши координаты:
* "использует аргументы на основе поведения" — тут речь о "типизированном черном ящике", т.е. о "концепте", т.е. о паре { "черный ящик", "набор операций" };
* "делает её применимой в любом контексте, где тип объекта удовлетворяет заданным требованиям поведения" — тут речь о наличии "ограничений" полиморфного аргумента или просто его "типизации" (да, именно так и говорится, и это вполне грамотно); Это одно и то же, что первое, т.е. определение могло быть вдвое короче.

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

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

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

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

Итого, когда ты пишешь в дотнете where T : IEquatable<T> — ты частично определяешь тип T.
Или когда в Хаскеле пишешь equal_to :: (Eq a) => ... — ты частично определяешь тип a.

Вот это неполное определение типа — это и есть основной/единственный признак именно параметрического полиморфизма, а вовсе не ad hoc.

А где появляется ad hoc — я уже много раз тебе писал. Медитировать до просветления, как грится.
Отредактировано 20.02.2017 17:53 vdimas . Предыдущая версия .
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.