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

D>Ты смайлик не забыл?
D>Если нет, догадывайся, каков тип q:
D>

D>// auto предлагается в C++0x использовать для указания того, что тип выводится автоматически
D>// ниже, конечно, псевдо-С++: 
D>auto foo()
D>{
D>    auto q(7, 22.3); 
D>    return q;
D>}
D>

D>То есть ответ-то есть: тип с конструктором cons(int,double). Только что с этим обобщённым типом потом делать? Это не шаблонная (в смысле template) обобщенность.

А ФЯ в таком коде смогут вывести тип q? Явно, что тип к таким конструктором, да и дальнейшее использование этой функции можно посмотреть.

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

У меня складывается нехорошее впечатление, что ты пытаешься развести религиозную войну на тему "ФЯ рулез ИЯ сакс".
Зачем? Какое в этом содержание?

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

Не попробуем ли мы перейти к первому пункту?

Вот например, Хиндли-Милнеровская типизация.
Допустим, мы приложили некоторые усилия и сделали диалект С++ с ней.
Императивные трудности нас совершенно не волнуют. И (O)CaML, и Nemerle решили их очень просто: тип переменной выводится в точке объявления, а дальнейшие её изменения или обращения к методам только проверяются на соответствие.
Может быть, это не слишком гибко, где-то неудобно, но во всяком случае решение есть.
Итак, ХМ в С++. Как должен измениться язык? Как должен измениться компилятор?

Вот, для затравки.

Во-первых, мы теряем ad-hoc-полиморфизм — ту самую фичу, которая принесла славу С++. Что взамен? Как меняется синтаксис?
— рожаем новые операторы на все случаи жизни (подобно ML'овской целочисленной и вещественной арифметике)
— вводим typeclasses (подобно Haskell'овским) и рассовываем все полиморфные имена по ним
— учимся разделять и совмещать оба подхода: вот здесь С++ный односторонний вывод типов, а вот здесь ХМ

Во-вторых, функция с полиморфным типом — это, на самом деле, шаблон. Оставим пока за скобками работу по нахождению формальных (в точке определения) и фактических (в точках применения) параметров. Я хочу подчеркнуть, что компилятор выполняет тройную работу по кодированию:
— сперва превращает текст на входном языке во внутреннее представление (AST или какой-то промежуточный код шаблона)
— затем в точках воплощения подставляет туда фактические параметры и транслирует представление шаблона в конкретный код backend'а
— наконец, backend транслирует в целевой машинный код (в том числе выполняет оптимизации)
Чем больше конкретных функций (перегруженных или уникальных), тем меньше работы компилятору.
Сейчас тема экспорта шаблонов (т.е. сохранения промежуточного кода) задвинута. Но как только шаблоны станут халявными (сделаем-таки автоматический вывод), придётся об этом побеспокоиться.

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

К>Вот например, Хиндли-Милнеровская типизация.
К>Допустим, мы приложили некоторые усилия и сделали диалект С++ с ней.
Принципиально невозможно. Систему типов C++ и типизацию Х-М никак не совместить. Классы надо сделать утино-типизированными(как в OCaml), выкинуть перегрузку, неявные приведения итд(то есть полностью забить на систему типов C++); либо забыть о Х-М. А лучше оставить C++ в покое.

К>Императивные трудности нас совершенно не волнуют. И (O)CaML, и Nemerle решили их очень просто: тип переменной выводится в точке объявления, а дальнейшие её изменения или обращения к методам только проверяются на соответствие.
Нет, в Nemerle это сделано совершенно иначе. Алгоритм Хиндли-Милнера действительно может сразу вывести тип в точке объявления, но только потому, что работает он со структурированными системами типов, где в типе выражения просто не может быть никакой неоднозначности и присутствует полная информация необходимая для немедленного вывода типа, пусть и полиморфного типа(фактически полиморфные типы выводятся направо и налево, при каждом удобном случае).

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

Поэтому Nemerle выводит тип переменной/функции из той точки, из которой он вообще может быть выведен(т.е. произвольной ), а не из точки объявления(глобальный вывод типов правда запрещен, в том числе и по этой причине, иначе можно была бы возможность писать крайне запутанный код).

Пример вполне валидного кода на Nemerle:

using Nemerle.Collections
module Main
    foo(bar : ref int) : void
        bar++
    Main() : void
        mutable x
        // Nemerle.Collections.Hashtable это дженерик тип с двумя параметрами
        def y = Hashtable()
        // здесь мы еще не знаем ни тип x, ни точный тип y
        x = y.GetValueOrDefault("somekey")
        // вот из этой строчки и будет выведен тип x
        foo(ref x)
        // напечатает 1
        System.Console.WriteLine(x)

Еще один пример, на этот раз разруливание перегрузки:

module Main
    foo(_ : int) : void { }
    foo(_ : float) : void { }
    bar() : int { 1 }
    Main() : void
        // какой именно foo нам нужен?
        def f = foo
        // вот здесь компилятор это выяснит
        f(bar())
        // более сложный случай
        def foobar = (f,b) => f(b())
        foobar(foo,bar)

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

К>Во-первых, мы теряем ad-hoc-полиморфизм — ту самую фичу, которая принесла славу С++. Что взамен? Как меняется синтаксис?
Совсем не обязательно. В Nemerle фактически есть ad-hoc полиморфизм, с помощью макросов. Теоретически, мне кажется, нет никаких препятствий для добавления в Nemerle шаблонов a-la C++, кроме того конечно, что в этом крайне мало смысла.

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

Спасибо всем (отдельно Кодту за обычную содержательность). Был неправ. Хотел поставить себе минус, но не обнаружил такой возможности.

Разаработчикам: поддержите возможность самокритики

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

VD>>Если написать:
К>

VD>>def do_smth(p)
VD>>{
VD>>  def s("Вася", 33)
VD>>  def q = 3;
VD>>}
К>

VD>>то ни один супер язык не выведет типы верно. И С++ тут не причем. В этом коде банально нехватает информации.

К>Почему же. Хватает. Функция принимает что угодно и ничего не возвращает. Следовательно, do_smth : 'a -> unit

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

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

К>К императивности отношения не имеет вообще. Хотя бы потому, что этот подход распространяется и на язык шаблонов (чисто декларативный), в котором вообще царит утиная типизация.

Кстати, Хиндли-Милер по крайней мере из ОКамла — это тоже утиная типизация.

К>printf не в виде макроса, а в виде функции. Замучаетесь и обломитесь!)

Надо признать что printf как раз замечательная задача именно для продвинутых макросов. А универсальными средствами языка printf получается очень плохо (как в С, например).

К>В Лиспе типизация утиная, а ведь тоже ФЯ...

Лисп вообще динамически типизированный язык. С необязательной аннотацией типов (в некоторых диалектах). Но собственно это только подтверждает, что ассоциировать вывод типов с парадигмой нельзя.

ЗЫ

Вообще, количество алогизмов и отновенного обамана в области популяризации ФП просто поражает. Меня вот интересут вопрос. Это такое количество безвинных заблудших овечек или это генеральная линия партии проталкивать ФП любыми (в том числе не корректными) средствами? Уж больно странно видеть такие детские логические ошибки от такого количества народу претендующего на звание гуру.

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

LCR>О, да, известный Борец-С-Ветряными-Мельницами.

Скорее с демагогами и болоболами.

LCR>В чём смысл борьбы то?

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

LCR>Борьба с неверными () али движение за мировое господство "ТхеРигхтТхинга" ()?

С безграмотными алогизмами и отровенной ложью.

LCR>В принципе я бы мог потратить время и ответить подробно, с примерами и пояснениями

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

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

Используйте принцип — логика пре выше всего. И все будет ОК. Не надо делать столь очевидно ошибочных утверждений. Не надо связвать с функциональной парадигмой все что появилось или развилось в функциональных языка. Ведь так же просто. Если мы считаем ML функциональным языком, а в нем нет линивости, и есть возожность менять переменные, то разговор о том что то и другое являются неотемлиыми частами ФЯ надо закрыть. Это просто свойства конкретного языка. Не больше и не менее.

LCR> (btw, строгого доказательства в принципе сделать невозможно, поскольку речь идёт о человеке и вопрос "легче/труднее" часто субъективен и неформален), почему с ростом сложности систем сложность реализации ленивых вычислений в условиях mutable state растёт экспоненциально, но увы, после таких доводов

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

Ну, тогда зачем тут обвинять меня в чем-то? Если вы верующие и я нарушаю ваши религиозные убеждения, то не надо со мной вообще беседовать. И на этом сайте не стоит ошбщаться. По крайней мере вне рамок религиозных войн. Вера не технический вопрос. Это вопрос социологии и психологии, а то и психиатрии. Вот найдите соотвесвующие ресурсы и там развивайте эту тему. А здесь пожалуйста не надо всего этого религиозного булшита. Если есть логически корректные объяснения и темболее доказательства, то милости просим ими пделиться. Но их нет и быть не может, так как все они разбиваются о простой логический вывод — 90% ФЯ не поддерживают ленивсти, значит ленивость не может быть определяющим критерием ФЯ. Если у меня есть логическая ошибка в этом суждении, то, плиз, продемонстрируйте мне ее. Если нет, то будьте добры один раз и на всегда согласиться с тем, что ваше суждение ошибочно. Но нет же вы с пеной у рта в сотый раз повторяете ничтожное суждение ссылаясь при этом на авторитетов и применя другие приемы ничего не дающие делу.

LCR>

VD>>... Чущь это...
VD>>... Это тоже ахинея.

LCR>легко экстраполируется результат "дискуссии".

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

LCR>Так что приходится выбирать из двух зол
LCR>

LCR>
• или превращать эту ветку в очередной отстойник (а ля "ФП vs ООП"),
  
  Да кто хоть слово то сказал против ФП? Зачем добавлят еще ахинеи и чуши в итак бессмысленные суждения. С вами несогласны по соврешенно конкретным вопросам. Не надо наклеивать ярлыки и обощать до безобразия.
  
  LCR>
• или стерпеть эти выпады, зная что:
  LCR>
  
  LCR>
  1. читатель разумен и фильтрует любые сообщения, в т.ч. и это
     LCR>
  2. RSDN — это далеко неединственный источник информации
     LCR>

LCR>а эту ветку сохранить как техническое обсуждение контента данной статьи.
LCR>

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

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

LCR>Я выбираю второй путь, а поговорить про "рулит ленивость или нет" можно как-нибудь потом в философии — там самое место, имо.

Я даже не хочу обсуждать рулит ленивость или нет. Я утверждаю, что линивость не имеет прямой связи с ФЯ. Это качество конкретного зяка. И зачем к банльному логическому выводу прицеплять положение RSDN в рунете или разумность читателя я не знаю. Кстати, судя по тому, что религиозный булшит поражает кучу неокрепших мозгов я сильно сомневаюсь, что утверждение "читатель разумен и фильтрует любые сообщения" всегда и не для всех верно.

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

К>Императивные трудности нас совершенно не волнуют. И (O)CaML, и Nemerle решили их очень просто: тип переменной выводится в точке объявления, а дальнейшие её изменения или обращения к методам только проверяются на соответствие.

Как минимум для Nemerle это не верно. Этот язык выводит тип перменных и функций из ближайшего использования. Причем иногда может вывести базовый тип (хотя там есть ограничения связанные с тем что ситуция в кторой выведен очень общий тип чаща бывает ошибкой). Так что точнее будет сказать "тип выводится из использования и/или объявления". Классический пример:

def h = Hashtable();
h.Add("aaa", 1);

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

VK>Совсем не обязательно. В Nemerle фактически есть ad-hoc полиморфизм, с помощью макросов.

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

Просто шаблоны С++ изобилуют пергрузкой. Но в их случае скорее нужно говорить об утиной типизации которой действительно в Nemerle можно добиться только если использовать шаблоны или методы-расширения.

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

VD>Насколько я понимаю терминт ad-hoc-полиморфизм означет банальную перегрузку. Так что Nemerle полностью и без проблем поддерживает ad-hoc-полиморфизм. Причем делает это напрямую.
Ну это был бы не я, если бы в чем-нибудь не ошибся. Жаль уже сообщение исправить нельзя. А ведь главное что когда-то видел определение этого термина, просто в памяти не отложилось.

VD>Просто шаблоны С++ изобилуют пергрузкой.
Да, мне кажется шаблоны, их специализация, и перегрузка в C++ действительно очень тесно связаны. И я думаю, что Немерловский вывод типов вполне совместим с системой типов вроде системы типов C++(ну может разве что чуть-чуть упростить ее нужно). Собственно примерно в этом исходная мысль и заключалась.

Правда язык с шаблонами C++ и выводом типов Nemerle это было бы нечто монстрообразное. А если туда еще и макросы.

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

VD>Используйте принцип — логика пре выше всего. И все будет ОК. Не надо делать столь очевидно ошибочных утверждений. Не надо связвать с функциональной парадигмой все что появилось или развилось в функциональных языка. Ведь так же просто. Если мы считаем ML функциональным языком, а в нем нет линивости, и есть возожность менять переменные, то разговор о том что то и другое являются неотемлиыми частами ФЯ надо закрыть. Это просто свойства конкретного языка. Не больше и не менее.

Какое свойство ФП не назови — оно или будет в каком то ИЯ, или его не будет в каком то ФЯ.
Вот тогда по твоему, что такое ФП? Каковы его отличительные особенности? И что такое ФЯ?

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

L>Какое свойство ФП не назови — оно или будет в каком то ИЯ, или его не будет в каком то ФЯ.
L>Вот тогда по твоему, что такое ФП? Каковы его отличительные особенности? И что такое ФЯ?

Есть одно четкое свойство выделяющее ФЯ — запись программы в виде выражений (expressions), а не statements.

Так же все ФЯ отличаются расширенной поддержкой функций высшего порядка: замыканий, локальных и/или анонимных функций.

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

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

VD>Есть одно четкое свойство выделяющее ФЯ — запись программы в виде выражений (expressions), а не statements.

Т.е. программа — это одна большая функция.

VD>Так же все ФЯ отличаются расширенной поддержкой функций высшего порядка: замыканий, локальных и/или анонимных функций.

VD>Но чето практически правада — это что все кроме того что функция в таких языках является первоклассным значением и то что функции строются из выражений не является частным достоянем функциональных языков.

Честно говоря, частным достоянием и это не является.

Я что сказать хочу. Чистота функций (отсутствие сайд эффекта), ФВП, рекурсия — это особенности ФП. Они есть и в ИЯ и в ФЯ (деление на ИЯ и ФЯ ведь достаточно условно, все это понимают?) От того, что они есть в ИЯ не делает их не ФП-шными фичами. Это я к твоей фразе о том, что "ФП — это отсутствие побочных эффетов — ахинея". ФП, конечно, это не отсутсвие сайд эффектов, но отсутствие сайд эффектов — отличительная черта ФП. И то, что можно без сайд эффектов писать на ИЯ, и то, что есть ФЯ с сайд эффектами — ни о чем не говорит. ФЯ — всего лишь язык, облегчающий программирование в ФП-стиле.

Про ленивость, полагаю, не так. Это черта конкретных языков (но! нефункиональные языки не знаю). Имеется в виду по дефолту, разумеется, т.е. поддержка языком non-strict evaluation.

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

L>Т.е. программа — это одна большая функция.

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

L>Честно говоря, частным достоянием и это не является.

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

L>Я что сказать хочу. Чистота функций (отсутствие сайд эффекта), ФВП, рекурсия — это особенности ФП.

Особености?

L>Они есть и в ИЯ и в ФЯ (деление на ИЯ и ФЯ ведь достаточно условно, все это понимают?)

Все? Да, постоянно ленивость объясляется чуть ли не основпологающей особенностью ФЯ. И этот бред несется на фоне прославления того же Эрлэнга в соседних ветках. Так что отнюдь не все. Большинство людей начитались религиозных агиток и несут форменную ахинею.

Есть огромная разница между утверждением "является обязательным в..." и "часто применяется в..." или "появилось в...".

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

L>От того, что они есть в ИЯ не делает их не ФП-шными фичами.

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

Определяющим же свойством ФЯ является исключительно то что программа строится как выражение. А уже все остальное в плодь до побочных эффектов является следствием этого.

Но вот такие вещи как паттерн-матчинг или ленивость никак не связанные с этой особенностью и являются исклюичтельно выбором дизайнеров языка.

L>Это я к твоей фразе о том, что "ФП — это отсутствие побочных эффетов — ахинея". ФП, конечно, это не отсутсвие сайд эффектов, но отсутствие сайд эффектов — отличительная черта ФП.

Конечно же отличительной чертой это не является, так как большая часть ФЯ позволяют менять переменные, и немало ИЯ имеют синтаксис для создания неизменяемых переменных. Если сказать, что это отилчительная черта, то С++ — это ФЯ.

Скажем так — любой ФЯ (в отличии от ИЯ) имеет синтаксис для создания неизменяемых переменных и обеспечивает возможность программировать вообще не используя изменяемые переменные.

L>И то, что можно без сайд эффектов писать на ИЯ, и то, что есть ФЯ с сайд эффектами — ни о чем не говорит.

Это говорит о том, что твое утверждение неверно. Более не о чем.

L>ФЯ — всего лишь язык, облегчающий программирование в ФП-стиле.

Именно. Но это определение почему-то сильно не устраивает многих любителей ФП.

L>Про ленивость, полагаю, не так.

Линивость вообще приплетена по недоразумению. Собственно это и есть та логическая ошибка о которой я говорил. Ни ФЯ, ни ИЯ не обязаны иметь линивую семантику вообще, и не обязаны ее пддерживать. В прочем ни что не мешает ее поддерживать любому языку. Правдой является только одно утверждение — В чистых ФЯ проще реализовать ленивую семантику, так как вообще не надо думать о побочных эффектах.

L>Это черта конкретных языков (но! нефункиональные языки не знаю). Имеется в виду по дефолту, разумеется, т.е. поддержка языком non-strict evaluation.

Читайте Красного дракона Аха. Там как раз разбираются принципы предачи параметров в процедуры и как один из них разбирается способ передачи аналогичный тому что называется ленивым в облати ФЯ. Причем там же говорится о языках где это встречалось в первые и то том, что это было не очень хорошо именно потому, что в следствии побочных эффектов приводило к сложности понимания происходящего.

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

L>>Это я к твоей фразе о том, что "ФП — это отсутствие побочных эффетов — ахинея". ФП, конечно, это не отсутсвие сайд эффектов, но отсутствие сайд эффектов — отличительная черта ФП.

VD>Конечно же отличительной чертой это не является, так как большая часть ФЯ позволяют менять переменные, и немало ИЯ имеют синтаксис для создания неизменяемых переменных. Если сказать, что это отилчительная черта, то С++ — это ФЯ.

Вот тут Вы сами логику нарушаете. В Си++ нет отсутствия побочных эффектов. Без них можно писать, но отсутствия там нет.
Хотя Ваш оппонент тоже логику нарушает так как если это отличительная черта, то она должна быть свойственна всем ФЯ.

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

П.С. Под отсутствием побочных эффектов, само собой, подразумевается не тотальное их отстутствие (иначе на таком языке и программу-то не напишешь), а такое, как например в Хаскеле.

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

VE>Хотя Ваш оппонент тоже логику нарушает так как если это отличительная черта, то она должна быть свойственна всем ФЯ.

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

Я говорил, что это отличительная черта ФП, а не ФЯ. Программировать в функиональном стиле — это значит писать код с ФВП и чистыми функциями. Примерно так. Влад вот тоже часто путает ФЯ и ФП.

Ну и во вторых, фраза о том, что в С++ нет отсутствия побочных эффектов, к сожалению, имеет мало смысла (в контексте разговора, конечно!). Главное, что на С++ можно написать программу без сайд эффектов.

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

L>>Я что сказать хочу. Чистота функций (отсутствие сайд эффекта), ФВП, рекурсия — это особенности ФП.

VD>Особености?

Э-э-э, да... Что смущает?

L>>От того, что они есть в ИЯ не делает их не ФП-шными фичами.

VD>Делает, делае.

ФВП — не ФП фича? Не думаю, что могу согласится с этим. Это же два способа делать одно и то же — состояния в ИЯ и ФВП в ФП.
Использование ФВП, кстати, вытекает из того, что программа есть выражение, а не набор стейтментов.

L>>Это я к твоей фразе о том, что "ФП — это отсутствие побочных эффетов — ахинея". ФП, конечно, это не отсутсвие сайд эффектов, но отсутствие сайд эффектов — отличительная черта ФП.

VD>Конечно же отличительной чертой это не является, так как большая часть ФЯ позволяют менять переменные, и немало ИЯ имеют синтаксис для создания неизменяемых переменных. Если сказать, что это отилчительная черта, то С++ — это ФЯ.

ФЯ — это язык, "облегчающий писать в ФП стиле", а не "позволяющий писать в ФП стиле".

VD>Скажем так — любой ФЯ (в отличии от ИЯ) имеет синтаксис для создания неизменяемых переменных и обеспечивает возможность программировать вообще не используя изменяемые переменные.

На С++ всё это, как ты уже заметил, тоже есть. Про "обеспечивает возможность", правда, не уверен, потому что не понимаю, что это значит. Но позволяет, да.

L>>И то, что можно без сайд эффектов писать на ИЯ, и то, что есть ФЯ с сайд эффектами — ни о чем не говорит.

VD>Это говорит о том, что твое утверждение неверно. Более не о чем.

Ты вот постоянно аппелируешь к логике, но сам ей пользуешься нечасто. Берем твое утверждение о том, что ФП — это когда программа записана в виде выражений. Записываем так на С++. Опа! С++ — ФЯ! Так что ли?

VD>Читайте Красного дракона Аха.

Читали

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

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

VD>>Если написать:
К>

VD>>def do_smth(p)
VD>>{
VD>>  def s("Вася", 33)
VD>>  def q = 3;
VD>>}
К>

VD>>то ни один супер язык не выведет типы верно. И С++ тут не причем. В этом коде банально нехватает информации.

К>Почему же. Хватает. Функция принимает что угодно и ничего не возвращает. Следовательно, do_smth : 'a -> unit

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

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

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

VD>>Конечно же отличительной чертой это не является, так как большая часть ФЯ позволяют менять переменные, и немало ИЯ имеют синтаксис для создания неизменяемых переменных. Если сказать, что это отилчительная черта, то С++ — это ФЯ.

VE>Вот тут Вы сами логику нарушаете. В Си++ нет отсутствия побочных эффектов. Без них можно писать, но отсутствия там нет.

Я логику не нарушаю. Это делает явно кто-то другой. Я не утверждал что С++ непозволяте делать побочных эффектов. Я утверждал, что как и любой ФЯ он позволяет писать код без побочных эффектов.

VE>Хотя Ваш оппонент тоже логику нарушает так как если это отличительная черта, то она должна быть свойственна всем ФЯ.

Именно.

VE>Можно сказать так, отличительной чертой ФЯ является то, что некоторые из них имеют отсутствие побочных эффектов.

Не может быть отилчительной чертой вида черта встречающаяся не у всех представителей класса.

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

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

Так что разумно говорить, что ФП — это программирование в выражениях которое стимулирует программирование без побочных эффектов. Причем именно ФП, а не ФЯ! ФЯ же не более чем класс языков полноценно (и с достаточным удобством) поддерживающих программирование в выражениях.

VE>П.С. Под отсутствием побочных эффектов, само собой, подразумевается не тотальное их отстутствие (иначе на таком языке и программу-то не напишешь), а такое, как например в Хаскеле.

По-моему — это все пуританство. Разумно было бы ввести в язык некую аннотацию функций гарантирующую отсуствие в них побочных эффетов. Но заниматься такой ахинейй как монады в Хаскеле — это явно чересчур.

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

L>Я говорил, что это отличительная черта ФП, а не ФЯ. Программировать в функиональном стиле — это значит писать код с ФВП и чистыми функциями. Примерно так. Влад вот тоже часто путает ФЯ и ФП.

Примеры такой путанницы, плиз, приведи.

L>Ну и во вторых, фраза о том, что в С++ нет отсутствия побочных эффектов, к сожалению, имеет мало смысла (в контексте разговора, конечно!). Главное, что на С++ можно написать программу без сайд эффектов.

Кстати, фраза "что в С++ нет отсутствия побочных эффектов" это банальное перевирание моих слов. Я такого не говорил.