Re[2]: Pure keyword
От: nikov США http://www.linkedin.com/in/nikov
Дата: 13.03.10 21:24
Оценка: 1 (1) +2
Здравствуйте, Аноним, Вы писали:

А>Такой вопрос. Является ли эта функция pure?


А>
А>def isItPure() { System.DateTime.Now }
А>


Нет.
Re[5]: Pure keyword
От: AngeL B. Россия  
Дата: 14.03.10 16:22
Оценка: +2
Здравствуйте, alvas, Вы писали:

AB>>def isItPure( act : void->int ) { act(); 1; }

A>И такая тоже нет

вот если такая тоже нет, то функции filter, map, reduce перестают быть pure. Все функции, которые их вызывают тоже и ценность идеи начинает асимптотически приближаться к нулю.
Re[7]: Pure keyword
От: WolfHound  
Дата: 14.03.10 20:47
Оценка: +1 -1
Здравствуйте, VladD2, Вы писали:

VD>Даже не зависит. Сама функция чистая. А то что ей в качестве параметров может быть передана не чистая функция — это уже вопрос отдельный.

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

VD>Для качественной реализации — да.

А делать не качественно толку нет.

VD>А так в общем-то можно и по месту контролировать.

Угу и получится решето типа const в С++.
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[3]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 16:54
Оценка: 6 (1)
Здравствуйте, alvas, Вы писали:

A>Спасибо. Ты описал что он делает не так, но не написал что это такое? Можно вкратце?


А разве не ясно из описания автора?

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

Такие функции можно гарантированно вызывать параллельно в многопоточном окружении.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.03.10 20:00
Оценка: +1
Здравствуйте, WolfHound, Вы писали:

AB>>>а такая?

AB>>>def isItPure( act : void->int ) { act(); 1; }
AB>>>?
A>>И такая тоже нет
WH>Это зависит от того является ли act pure или нет.

Даже не зависит. Сама функция чистая. А то что ей в качестве параметров может быть передана не чистая функция — это уже вопрос отдельный.

WH>А чтобы четко отделить мух от катлет нам придется завести 2 типа функций...

WH>Короче чтобы сделать все по уму придется как следует надругаться нат системой типов.

Для качественной реализации — да. А так в общем-то можно и по месту контролировать.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Pure keyword
От: VoidEx  
Дата: 14.03.10 21:02
Оценка: :)
Здравствуйте, WolfHound, Вы писали:

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


VD>>Даже не зависит. Сама функция чистая. А то что ей в качестве параметров может быть передана не чистая функция — это уже вопрос отдельный.

WH>Нет. Не отдельный.
WH>Если вызов функции приводит к побочным эффектам то вункция грязная.

Тогда функция, возвращающая список из 1000 единиц тоже грязная.
Термин "побочный эффект" не определён, а вот чистота — вполне.
Re[6]: Pure keyword
От: hardcase Пират http://nemerle.org
Дата: 14.03.10 21:57
Оценка: +1
Здравствуйте, WolfHound, Вы писали:

WH>Короче чтобы сделать все по уму придется как следует надругаться нат системой типов.


В итоге изобретем частный случай Хаскеля.
/* иЗвиНите зА неРовнЫй поЧерК */
Re[13]: Pure keyword
От: WolfHound  
Дата: 15.03.10 20:11
Оценка: +1
Здравствуйте, VladD2, Вы писали:

VD>Хочешь сказать, что в ней может быть ссылка на функцию и не будет возможности узнать чистая она или нет?

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

VD>Это не верное трактование. Функция не становится не чистой если в нее передать не чистую функцию. Вот вычисление созданное на базе смеси чистых и не чистых функций действительно становится не чистым.

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

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

VD>Очень простая формула. Вычисление будет чистым если в нем используются только чистые функции. Это относится как к взовам, так и к ссылкам на функции. Если мы можем гарантировать, что, скажем, в теле функции нет обращений к не чистым функциям (т.е. известно, что все использованные функции (в том числе и по ссылке) чистые), то тело функции, а значит и вся функция тоже является чистой.

А вот скажи вот эта функция чиcтая или нет:
factorial(n : int) : int
{
    mutable res = 1;
    for (mutable i = 1; i <= n; ++i)
        res *= i;
    res;
}

Согласно твоему определению она грязная. Но по факту она чистая.

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

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

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

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

Так я же и говорю привет const_cast...

VD>Ну, дык это иногда нужно. Скажем для логирования.

Зачем тебе логирование внутри чистой функции?

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

Не будет.
Ты просто сделаешь эти изменения неявными.
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[9]: Pure keyword
От: WolfHound  
Дата: 15.03.10 21:55
Оценка: :)
Здравствуйте, VladD2, Вы писали:

WH>>Те чистота функции зависит от деталей реализации?

VD>От своего сдержимого.
Решето.

VD>Ладно. Это разговор не о чем. Лично я эту фичу для первой версии немерла реализовывать не буду. А другие или не в силах будут сделать (как Эмпфирон) или так же не возьмутся от лени (как ты).

Я за эту фичу не возьмусь ибо в рамках .НЕТ ее невозможно качественно реализовать.

VD>А пока что ты бы лучше помог бы товарищу para в работе над PegParser-ом. Там нужно не мало ума приложить в области дизайна чтобы получить быстрый и удобный макрос.

Я уже тебе сказал что либо нужно проектировать сразу с блекджеком и шлюхами либо не делать вообще.
То чем занимается товарищь пустая трата времени.
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[11]: Pure keyword
От: nikov США http://www.linkedin.com/in/nikov
Дата: 17.03.10 16:20
Оценка: +1
Здравствуйте, VladD2, Вы писали:

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


Почему? А если эта функция просто добавляет данное значение в immutable список функций? Она вполне может быть чистой, даже если добавляемое значение (принимаемое в качестве аргумента) — функция с побочными эффектами.
Pure keyword
От: alvas  
Дата: 13.03.10 08:50
Оценка:
В англоязычной части интернете шустро обсуждают новое ключевое слово pure.
Кто может вкратце описать суть по русски?
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 15:31
Оценка:
Здравствуйте, alvas, Вы писали:

A>В англоязычной части интернете шустро обсуждают новое ключевое слово pure.

A>Кто может вкратце описать суть по русски?

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

Сама же фича несомненно полезная. Особенно в свете грядущей многопоточности.

Мы планируем ее аналог включить в Nemerle 2.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: Pure keyword
От: Воронков Василий Россия  
Дата: 13.03.10 15:51
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Вкратце — реализация явно идет не по тому пути. Такие фичи нужно делать на стадии типизированного дерева. А он этот макрос как синтаксический пишет. Моего английского не хватает для проведения философских дискуссий и объяснения товарищу почему так делать не надо. Вкратце я ему своем мнение высказал, но он его проигнорировал.

VD>Сама же фича несомненно полезная. Особенно в свете грядущей многопоточности.
VD>Мы планируем ее аналог включить в Nemerle 2.

Вообще такие вещи хотелось бы видеть скорее в виде атрибутов.
Re[3]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 15:52
Оценка:
Здравствуйте, Воронков Василий, Вы писали:

ВВ>Вообще такие вещи хотелось бы видеть скорее в виде атрибутов.


Это уже без разницы. Он налепил ключевых слов. Я говорю о реализации. Реализация там весьма непродуманная.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: Pure keyword
От: Воронков Василий Россия  
Дата: 13.03.10 15:58
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, Воронков Василий, Вы писали:

ВВ>>Вообще такие вещи хотелось бы видеть скорее в виде атрибутов.
VD>Это уже без разницы. Он налепил ключевых слов. Я говорю о реализации. Реализация там весьма непродуманная.

Pure в моем понимании — это контракт. Атрибут как раз и предполагает, что мы не вмешиваемся в синтаксис, но на определенной стадии тело метода должно быть проверено на соответствие контракту (кстати, на какой стадии?). Можно придумать и другие контракты.

А, кстати, как это вообще работает? Каким образом, например, отслеживать то, что функция *вообще* не имеет побочных эффектов (например, консольного вывода)? Или это как бы "более или менее" pure, но без гарантий?
В Бета 1 ничего подобного нет, проверить не могу.
Re[5]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 16:03
Оценка:
Здравствуйте, Воронков Василий, Вы писали:

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


А модификаторы доступа, скажем, к контракту не относятся?
В общем, спор не о чем.

ВВ>(кстати, на какой стадии?)


Это надо делать на стадии идущей за стадией вывода типов. А то и на стадии предшествующей генерации кода, так как до нее происходит множество преобразований кода.

ВВ>А, кстати, как это вообще работает? Каким образом, например, отслеживать то, что функция *вообще* не имеет побочных эффектов (например, консольного вывода)? Или это как бы "более или менее" pure, но без гарантий?


Для функций которые и так pure вопросов не возникает. Остальные надо аннотировать. В приципе это и так сделано (как я понимаю) в 4-ом фрэймворке (для поддержки контрактов).

ВВ>В Бета 1 ничего подобного нет, проверить не могу.


Я думаю, что и в релизе не будет. Кому захочется может использовать этот макрос самостоятельно.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: Pure keyword
От: Воронков Василий Россия  
Дата: 13.03.10 16:09
Оценка:
Здравствуйте, VladD2, Вы писали:

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

VD>А модификаторы доступа, скажем, к контракту не относятся?

Относятся.

VD>В общем, спор не о чем.


Спор действительно ни о чем. Тебе нравится добавление ключевого слова? Таких компайл-тайм контрактов можно довольно много придумать — Nothrow какой-нибудь, например — вводить для каждого ключевое слово несколько избыточно.
Но сама идея хорошая, иногда возникает потребность в чем-то таком.

ВВ>>(кстати, на какой стадии?)

VD>Это надо делать на стадии идущей за стадией вывода типов. А то и на стадии предшествующей генерации кода, так как до нее происходит множество преобразований кода.
ВВ>>А, кстати, как это вообще работает? Каким образом, например, отслеживать то, что функция *вообще* не имеет побочных эффектов (например, консольного вывода)? Или это как бы "более или менее" pure, но без гарантий?

Говоря другими словами, pure должен вызывать только методы, явно помеченные как pure — в противном случае он уже не pure? А как быть при вызове методов из сторонних библиотек или того же дотнета? Метод становится автоматически не pure?
Re[2]: Pure keyword
От: alvas  
Дата: 13.03.10 16:40
Оценка:
Здравствуйте, VladD2, Вы писали:

A>>В англоязычной части интернете шустро обсуждают новое ключевое слово pure.

A>>Кто может вкратце описать суть по русски?

VD>Вкратце — реализация явно идет не по тому пути. Такие фичи нужно делать на стадии типизированного дерева. А он этот макрос как синтаксический пишет. Моего английского не хватает для проведения философских дискуссий и объяснения товарищу почему так делать не надо. Вкратце я ему своем мнение высказал, но он его проигнорировал.


VD>Сама же фича несомненно полезная. Особенно в свете грядущей многопоточности.


VD>Мы планируем ее аналог включить в Nemerle 2.


Спасибо. Ты описал что он делает не так, но не написал что это такое? Можно вкратце?
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re[2]: Pure keyword
От: alvas  
Дата: 13.03.10 16:45
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Вкратце — реализация явно идет не по тому пути. Такие фичи нужно делать на стадии типизированного дерева. А он этот макрос как синтаксический пишет. Моего английского не хватает для проведения философских дискуссий и объяснения товарищу почему так делать не надо. Вкратце я ему своем мнение высказал, но он его проигнорировал.


Попроси чтобы и он высказал свое.
Если сможет — значит понимает что делает. Можно будет дальше обсуждать, чтобы прийти к взаимопониманию
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re[3]: Pure keyword
От: Jack128  
Дата: 13.03.10 16:46
Оценка:
Здравствуйте, alvas, Вы писали:

A>Спасибо. Ты описал что он делает не так, но не написал что это такое? Можно вкратце?


Ну, видимо pure говорит о том, что функция "чистая", без побочных эффектов. то есть не меняет состояния окружающего мира, а результат функции однозначно зависит от её параметров.
Re[7]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 16:52
Оценка:
Здравствуйте, Воронков Василий, Вы писали:

ВВ>Относятся.


Ну, и в чем тогда разница?

ВВ>Спор действительно ни о чем. Тебе нравится добавление ключевого слова?


Да мне плевать. Тем более, что ключевые слова можно использовать и в виде атрибутов.

ВВ>Но сама идея хорошая, иногда возникает потребность в чем-то таком.


+1

ВВ>Говоря другими словами, pure должен вызывать только методы, явно помеченные как pure — в противном случае он уже не pure?


Да. Но лучше эти вопросы задавать автору макры.

ВВ>А как быть при вызове методов из сторонних библиотек или того же дотнета? Метод становится автоматически не pure?


Помечать их, если есть уверенность, что они не делают побочных эффектов.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 16:55
Оценка:
Здравствуйте, alvas, Вы писали:

A>Попроси чтобы и он высказал свое.

A>Если сможет — значит понимает что делает. Можно будет дальше обсуждать, чтобы прийти к взаимопониманию

Да пусть делает, что получается. Опыт никогда не лишний.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: Pure keyword
От: alvas  
Дата: 13.03.10 16:59
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А разве не ясно из описания автора?


Похоже мой английский хуже твоего.
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re[7]: Pure keyword
От: FR  
Дата: 13.03.10 17:03
Оценка:
Здравствуйте, Воронков Василий, Вы писали:

ВВ>Говоря другими словами, pure должен вызывать только методы, явно помеченные как pure — в противном случае он уже не pure? А как быть при вызове методов из сторонних библиотек или того же дотнета? Метод становится автоматически не pure?


Библиотеки тоже должны быть помечены. Это как const в C++ имеет вирусную природу
В D pure уже довольно давно ввели, тут http://www.digitalmars.com/d/2.0/accu-functional.pdf описана и мотивация и как все выглядит и работает.
Re[5]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 17:24
Оценка:
Здравствуйте, alvas, Вы писали:

VD>>А разве не ясно из описания автора?


A>Похоже мой английский хуже твоего.


От это вряд ли.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Pure keyword
От: Воронков Василий Россия  
Дата: 13.03.10 17:25
Оценка:
Здравствуйте, VladD2, Вы писали:

ВВ>>Относятся.

VD>Ну, и в чем тогда разница?
ВВ>>Спор действительно ни о чем. Тебе нравится добавление ключевого слова?
VD>Да мне плевать. Тем более, что ключевые слова можно использовать и в виде атрибутов.

Дело действительно не в атрибуте, а скорее в некоей инфраструктуре для создания собственных компайл-тайм контрактов, более высокоуровневой по отношению к макросам.
Завтра захочется кому-нибудь прикрутить модификатор nothrow — тоже на мой взгляд штука полезная, — и начнут лепить очередной синтаксический макрос А ведь реализация очень схожа.
Такие вещи должны быть... единообразно как-то представлены быть что ли.
Re[8]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 17:25
Оценка:
Здравствуйте, FR, Вы писали:

FR>Библиотеки тоже должны быть помечены. Это как const в C++ имеет вирусную природу

FR>В D pure уже довольно давно ввели, тут http://www.digitalmars.com/d/2.0/accu-functional.pdf описана и мотивация и как все выглядит и работает.

В D многое, на мой взгляд, через жопу сделано. Но pure там сделан, пожалуй, лучше чем в любых аналогах.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 13.03.10 17:27
Оценка:
Здравствуйте, Воронков Василий, Вы писали:

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

ВВ>Завтра захочется кому-нибудь прикрутить модификатор nothrow — тоже на мой взгляд штука полезная, — и начнут лепить очередной синтаксический макрос А ведь реализация очень схожа.
ВВ>Такие вещи должны быть... единообразно как-то представлены быть что ли.

Согласен. По уму конечно нужно было еще одину стадию макросов добавить или событие которое вызывалось бы в момент когда все типы выведены.

Событие могу хоть сейчас добавить.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Pure keyword
От: Аноним  
Дата: 13.03.10 21:11
Оценка:
Такой вопрос. Является ли эта функция pure?

def isItPure() { System.DateTime.Now }
Re[2]: Pure keyword
От: hardcase Пират http://nemerle.org
Дата: 14.03.10 11:47
Оценка:
Здравствуйте, Аноним, Вы писали:

А>Такой вопрос. Является ли эта функция pure?


А>
А>def isItPure() { System.DateTime.Now }
А>


Нет не является. Чистая функция это такая, функция результат которой зависит исключительно от переданных ей параметров.
У этой функции нет аргументов, но результат вызова каждый раз разный.
/* иЗвиНите зА неРовнЫй поЧерК */
Re[3]: Pure keyword
От: AngeL B. Россия  
Дата: 14.03.10 14:06
Оценка:
Здравствуйте, hardcase, Вы писали:

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


а такая?
def isItPure( act : void->int ) { act(); 1; }
?
Re[4]: Pure keyword
От: alvas  
Дата: 14.03.10 14:57
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>а такая?

AB>def isItPure( act : void->int ) { act(); 1; }
AB>?

И такая тоже нет
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re[5]: Pure keyword
От: WolfHound  
Дата: 14.03.10 15:14
Оценка:
Здравствуйте, alvas, Вы писали:

AB>>а такая?

AB>>def isItPure( act : void->int ) { act(); 1; }
AB>>?
A>И такая тоже нет
Это зависит от того является ли act pure или нет.
А чтобы четко отделить мух от катлет нам придется завести 2 типа функций...
Короче чтобы сделать все по уму придется как следует надругаться нат системой типов.
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[6]: Pure keyword
От: AngeL B. Россия  
Дата: 14.03.10 16:36
Оценка:
Здравствуйте, WolfHound, Вы писали:

AB>>>а такая?

AB>>>def isItPure( act : void->int ) { act(); 1; }
AB>>>?
A>>И такая тоже нет
WH>Это зависит от того является ли act pure или нет.
WH>А чтобы четко отделить мух от катлет нам придется завести 2 типа функций...
WH>Короче чтобы сделать все по уму придется как следует надругаться нат системой типов.

или (идиотски хихикает) компилить для функций c лямбда-параметрами два варианта кода, один на случай pure (с параллельностью и прочей фигней) и один на случае 'не pure' для остальных вызовов.
Pure-ость лямбд может быть получиться выявить на этапе компиляции, а просто функции помечать.

А вдруг
Re[6]: Pure keyword
От: alvas  
Дата: 14.03.10 16:44
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>>>def isItPure( act : void->int ) { act(); 1; }

A>>И такая тоже нет

AB>вот если такая тоже нет, то функции filter, map, reduce перестают быть pure. Все функции, которые их вызывают тоже и ценность идеи начинает асимптотически приближаться к нулю.


Как я понимаю ваш пример = какое бы значение ваша функция не получила в виде параметра она всегда возвращает единицу.

Мое мнение
def isItPure() { 1; } — чистая
def isItPure( act : void->int ) { act(); } — чистая
def isItPure( act : void->int ) { act(); 1; } — нет
def isItPure( act) { 1; } — нет

Прокоментируйте, пожалуйста.
http://alvas.net — Аудио-инструменты для .Net разработчиков
Re[4]: Pure keyword
От: para  
Дата: 14.03.10 17:12
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>а такая?

AB>def isItPure( act : void->int ) { act(); 1; }
AB>?

думаю надо типа того:
PureDelegate[...] : Delegaete[...], IPure
...

def isItPure( act : void->int ) 
requires act is pure //IPure
{ 
  act(); 
  1
}
Re[7]: Pure keyword
От: Jack128  
Дата: 14.03.10 17:22
Оценка:
Здравствуйте, alvas, Вы писали:

A>Здравствуйте, AngeL B., Вы писали:


AB>>>>def isItPure( act : void->int ) { act(); 1; }

A>>>И такая тоже нет

AB>>вот если такая тоже нет, то функции filter, map, reduce перестают быть pure. Все функции, которые их вызывают тоже и ценность идеи начинает асимптотически приближаться к нулю.


A>Как я понимаю ваш пример = какое бы значение ваша функция не получила в виде параметра она всегда возвращает единицу.


A>Мое мнение

A>def isItPure() { 1; } — чистая
A>def isItPure( act : void->int ) { act(); } — чистая
A>def isItPure( act : void->int ) { act(); 1; } — нет
A>def isItPure( act) { 1; } — нет

A>Прокоментируйте, пожалуйста.


даже уже все сказали ( http://rsdn.ru/forum/nemerle/3734760.1.aspx
Автор: WolfHound
Дата: 14.03.10
)

1 и 4ый варинат — всегда чистые,
если act — чистая то 2ой и 3ий варианты тоже чистые, иначе — грязные..
Re[7]: Pure keyword
От: AngeL B. Россия  
Дата: 14.03.10 18:40
Оценка:
Здравствуйте, alvas, Вы писали:

A>Мое мнение

A>def isItPure() { 1; } — чистая
A>def isItPure( act : void->int ) { act(); } — чистая
A>def isItPure( act : void->int ) { act(); 1; } — нет
A>def isItPure( act) { 1; } — нет
A>Прокоментируйте, пожалуйста.

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

отсюда, как уже сказали
Автор: Jack128
Дата: 14.03.10
, вытекает, что 1) и 4) — чистые функции
а вот с 2) и 3) ситуация такова, что для обеспечения чистоты функции isItPure необходимо, чтобы чистой была и функция act(), т.к. если последняя грязная, то сама isItPure производит побочный эффект (путем вызова act()) и считаться чистой не может. Отсюда вывод — для обеспечения чистоты функции необходимо, чтобы ее собственный код был чистым, а также чтобы чистым был код всех вызываемых ею функций/лямдб/делегатов.
Отсюда очевидно вытекает, что для того чтобы isItPure можно было считать чистой в языках со строгой типизацией, параметр act должен быть помечен как чистый, а "чистота" его значения при вызове isItPure должна быть верифицируема компилятором. Следовательно необходимо иметь отдельно делегаты и отдельно "чистые делегаты" — которые должны быть совместимы в одну сторону как это сказано здесь
Автор: para
Дата: 14.03.10
.
Хотя лично мне такой вариант не очень нравиться.
Re[5]: Pure keyword
От: AngeL B. Россия  
Дата: 14.03.10 18:47
Оценка:
Здравствуйте, para, Вы писали:

P>PureDelegate[...] : Delegaete[...], IPure


а зачем у тебя интерфейс используется?
Re[6]: Pure keyword
От: para  
Дата: 14.03.10 18:54
Оценка:
Здравствуйте, AngeL B., Вы писали

P>>PureDelegate[...] : Delegaete[...], IPure


AB>а зачем у тебя интерфейс используется?


что-то замудрил
надо быть проще:
PureDelegate[...] : Delegaete[...]
...
def isItPure( act : pure void->int ) //(act : PureDelegate[void, int])
{ 
  act(); 
  1
}

хотя может когда-нибудь и понадобится интерфейс...
я думаю все эти идеи надо бы в snippets положить и хорошенько обдумать много аспектов..
Re[4]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.03.10 19:59
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>а такая?

AB>def isItPure( act : void->int ) { act(); 1; }
AB>?

А эта чистая. Только бессмысленная, так как возвращаемое значение act теряется. Учитывая, что для общей чистоты act обязана так же быть чистой функцией, приведенный код является глупостью.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.03.10 20:03
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>при этом не важно действительно ли ее результат основывается на параметрах или нет.


Важно. Просто когда функция для любых аргументов всегда возвращает одно значение, то это все равно одно и то же значение для конкретных параметров. Так что все ОК.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 14.03.10 20:52
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Нет. Не отдельный.

WH>Если вызов функции приводит к побочным эффектам то вункция грязная.

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

VD>>Для качественной реализации — да.

WH>А делать не качественно толку нет.

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

VD>>А так в общем-то можно и по месту контролировать.

WH>Угу и получится решето типа const в С++.

Не получится. В С++ есть две проблемы. Они 1) контролирую не совсем то что нужно, 2) допускают обход системы типов (не безопасные приведения типов). Первое — это вопрос реализации. Второго Немерле не допускает априори.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re: Pure keyword
От: Flem1234  
Дата: 14.03.10 22:12
Оценка:
Здравствуйте, alvas, Вы писали:

A>В англоязычной части интернете шустро обсуждают новое ключевое слово pure.

A>Кто может вкратце описать суть по русски?

Мммм... А можно вопрос вдогонку?
Если есть функция:

public A(i: int): IEnumerable[T]
{
   yield i + 1;
   yield i + 2;
}

Так вот, эта функция с побочными эффектами или нет?
Re[2]: Pure keyword
От: hardcase Пират http://nemerle.org
Дата: 14.03.10 22:17
Оценка:
Здравствуйте, Flem1234, Вы писали:

F>
F>public A(i: int): IEnumerable[T]
F>{
F>   yield i + 1;
F>   yield i + 2;
F>}
F>

F>Так вот, эта функция с побочными эффектами или нет?

Сама функция — нет. А вот генератор, который она возвращает уже имеет побочные эффекты — автомат состоянии.
/* иЗвиНите зА неРовнЫй поЧерК */
Re[9]: Pure keyword
От: WolfHound  
Дата: 15.03.10 11:51
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Отдельный, отдельный. К побочным эффектам приводит не сама функция, а то что ей передают в качестве параметра.

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

VD>Так что достаточно в месте вызова проверить, то что параметры передаваемые чистой функции так же чистые.

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

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

Те проверки времени исполнения и исключения?
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[10]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 15:09
Оценка:
Здравствуйте, WolfHound, Вы писали:

VD>>Отдельный, отдельный. К побочным эффектам приводит не сама функция, а то что ей передают в качестве параметра.

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

А причем тут глобальные переменные?

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


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

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

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

VD>>Так что достаточно в месте вызова проверить, то что параметры передаваемые чистой функции так же чистые.

WH>А сделать это можно только если добавить в систему типов чистые и грязные функции.

Не только. См. выше.

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

WH>Те проверки времени исполнения и исключения?

Нет. Проверка времени компиляции. Работает простое правило. Если вызывать только чистые функции и передавать им только чистые функции, то и работа выполненная ими будет без побочных эффектов. По-моему — это очевидно.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Pure keyword
От: WolfHound  
Дата: 15.03.10 15:41
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А причем тут глобальные переменные?

При том что это один из способов организовать побочные эффекты.

VD>Вовсе нет. Если функция порождает побочный эффект, то она априори не чистая.

С твоим определением тут возникают неоднозначности.

VD>Чистую функцию можно вызывать из не чистой

Это да.

VD> передавая ей так же не чистую функцию.

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

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

Кручу, верчу запутать хочу... Ничего не понял.

VD>Конечно можно запихнуть признак чистоты прямо в систему типов. Но тогда чистую функцию будет вообще нельзя вызвать из нечистого контекста. А это вряд ли то что хотят пользователи. На хрен нам еще один Хаскель?

Наоборот.
Чистою функцию из грязной вызывать можно.
Но грязную из чистой вызывать нельзя.

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

VD>Нет. Проверка времени компиляции. Работает простое правило. Если вызывать только чистые функции и передавать им только чистые функции, то и работа выполненная ими будет без побочных эффектов. По-моему — это очевидно.

Те таки изменение системы типов?
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[12]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 15:55
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>При том что это один из способов организовать побочные эффекты.


Хочешь сказать, что в ней может быть ссылка на функцию и не будет возможности узнать чистая она или нет?

WH>Ибо чистота функции начинает зависеть от того что в нее передают.

WH>А это само по себе весьма странно.

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

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

WH>Кручу, верчу запутать хочу... Ничего не понял.

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

WH>Чистою функцию из грязной вызывать можно.

WH>Но грязную из чистой вызывать нельзя.

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

WH>Ты же настаиваешь на возможности передать в чистую функцию грязную и вызвать ее.


Ну, дык это иногда нужно. Скажем для логирования.

VD>>Нет. Проверка времени компиляции. Работает простое правило. Если вызывать только чистые функции и передавать им только чистые функции, то и работа выполненная ими будет без побочных эффектов. По-моему — это очевидно.

WH>Те таки изменение системы типов?

Изменение системы типов позволит упростить определение того чистая функция или нет для ссылок на функции. Но в принципе это будет работать и без изменения системы типов.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: Pure keyword
От: AngeL B. Россия  
Дата: 15.03.10 16:57
Оценка:
Здравствуйте, VladD2, Вы писали:

AB>>а такая?

AB>>def isItPure( act : void->int ) { act(); 1; }
AB>>?

VD>А эта чистая. Только бессмысленная, так как возвращаемое значение act теряется. Учитывая, что для общей чистоты act обязана так же быть чистой функцией, приведенный код является глупостью.


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

вот например


def A(act : int->int) { act(5)+2; }
def B(act : int->int) { A(act); }

main() { 
    ArrayList ar = ArrayList();
    B(x => x*2);              
    B(x => { ar.Add(x); x*2; }
}


а вот теперь ответь на вопрос. Функция A чистая или нет?
А как ты это определил? А каким алгоритмом пользовался?
Re[6]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 19:41
Оценка:
Здравствуйте, AngeL B., Вы писали:


AB>вот например


AB>
AB>def A(act : int->int) { act(5)+2; }
AB>def B(act : int->int) { A(act); }

AB>main() { 
AB>    ArrayList ar = ArrayList();
AB>    B(x => x*2);              
AB>    B(x => { ar.Add(x); x*2; }
AB>}
AB>


AB>а вот теперь ответь на вопрос. Функция A чистая или нет?


Да. А вот лямбда "x => { ar.Add(x); x*2; }" — нет. Стало быть второй вызов функции B недопустим. Точнее допустим только если передаваемую в него лямбду пометить неким специальным образом. Например, поместить в некий макрос. Такая пометка будет выключать проверку осуществляемую компилятором и тем самым позволять программисту создавать условно-чистые функции (т.е. проблемы от некорректной работы которых программист будет брать на себя).

AB>А как ты это определил? А каким алгоритмом пользовался?


В ней не используется операторов которые могут изменить состояние.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: Pure keyword
От: WolfHound  
Дата: 15.03.10 20:11
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Да. А вот лямбда "x => { ar.Add(x); x*2; }" — нет. Стало быть второй вызов функции B недопустим. Точнее допустим только если передаваемую в него лямбду пометить неким специальным образом. Например, поместить в некий макрос. Такая пометка будет выключать проверку осуществляемую компилятором и тем самым позволять программисту создавать условно-чистые функции (т.е. проблемы от некорректной работы которых программист будет брать на себя).

А вот и const_cast... здравствуй дырявый С++...

VD>В ней не используется операторов которые могут изменить состояние.

Те чистота функции зависит от деталей реализации?
Тебе не кажется это несколько странным в статически типизированном языке?
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[8]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 20:21
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Те чистота функции зависит от деталей реализации?


От своего сдержимого.

WH>Тебе не кажется это несколько странным в статически типизированном языке?


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

Но эту информацию можно положить в те самые переменные.

ЗЫ

Ладно. Это разговор не о чем. Лично я эту фичу для первой версии немерла реализовывать не буду. А другие или не в силах будут сделать (как Эмпфирон) или так же не возьмутся от лени (как ты).

Так предлагаю перенести это обсуждение на момент когда будем проектировать и реализовывать второй немерле.

А пока что ты бы лучше помог бы товарищу para в работе над PegParser-ом. Там нужно не мало ума приложить в области дизайна чтобы получить быстрый и удобный макрос.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: Pure keyword
От: AngeL B. Россия  
Дата: 15.03.10 20:40
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Да. А вот лямбда "x => { ar.Add(x); x*2; }" — нет. Стало быть второй вызов функции B недопустим.

чем дальше тем веселее обсуждать
а если код вот такой
def pure A(act : int->int) { act(5)+2; }  //pure
def B(act : int->int) { A(act); }         //не pure

main() { 
    ArrayList ar = ArrayList();
    B(x => x*2);              
    B(x => { ar.Add(x); x*2; }
}


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

AB>>А как ты это определил? А каким алгоритмом пользовался?

VD>В ней не используется операторов которые могут изменить состояние.
эмммм?? то есть вызов внешней функции, которая непонятно что содержит, это уже не оператор "который может изменить состояние"?
Re[14]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 20:49
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Вообще в любом случае любое обращение к глобальной переменной делает функцию грязной.


Да ну? Даже если переменная не изменяемая и указывает на неизменяемое значение?

WH>Функция становится грязной если в нее передают любые грязные данные.

WH>Причем не важно что это за данные. Хешьтаблица, грязная функция или неявно передаваемые глобальные переменные.

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

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

WH>В тоже время функция остается чистой если в нее не передают грязные данные даже если внутри происходят грязные вычисления. См ниже.


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

WH>А вот скажи вот эта функция чиcтая или нет:

WH>
WH>factorial(n : int) : int
WH>{
WH>    mutable res = 1;
WH>    for (mutable i = 1; i <= n; ++i)
WH>        res *= i;
WH>    res;
WH>}
WH>


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

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


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

WH>Таким образом мы приходим к тому что чистота функции определяется исключительно сигнатурой функции.


Чушь. Если в функции меняется, скажем, поле класса или глобальная перменная, то она грязная.

WH>Но тут под ногами начинают путаться глобальные переменные.

WH>Они собаки такие передаются неявно и везде не оставляя следов в сигнатуре функции.

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

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

WH>Так я же и говорю привет const_cast...

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

VD>>Ну, дык это иногда нужно. Скажем для логирования.

WH>Зачем тебе логирование внутри чистой функции?

Для отладки. Это только в сказках ФП и чистые мат.вычисления делают не нужной отладку.

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

WH>Не будет.
WH>Ты просто сделаешь эти изменения неявными.

Ну, называй как хочешь только в печку не ставь.

Ладно. Я эту дискуссию завязал. Практического смысла в ней пока нет.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 15.03.10 20:59
Оценка:
Здравствуйте, AngeL B., Вы писали:

AB>а если код вот такой

AB>
AB>def pure A(act : int->int) { act(5)+2; }  //pure
AB>def B(act : int->int) { A(act); }         //не pure

AB>main() { 
AB>    ArrayList ar = ArrayList();
AB>    B(x => x*2);              
AB>    B(x => { ar.Add(x); x*2; }
AB>}
AB>


AB>тогда что?


Тогда в последней строчке ошибка будет.

AB>предложишь запретить вызов чистых из грязных?


Предложу запретить передачу грязных данных (к которым относится и ссылки на функции) без явного приказа программиста. Скажем, вот так:
def ar = List();
B(MrkAsPure(x => { ar.Add(x); x * 2; }))

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

AB>и заодно грязных из чистых?


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

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


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

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

AB>эмммм?? то есть вызов внешней функции, которая непонятно что содержит, это уже не оператор "который может изменить состояние"?


Нет, конечно. Из чистых функций можно вызвать только чистые функции или помеченные как чистые.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[15]: Pure keyword
От: WolfHound  
Дата: 15.03.10 21:42
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Да ну? Даже если переменная не изменяемая и указывает на неизменяемое значение?

Тогда это не переменная, а именованная константа.
ИМХО разница существенная.

VD>Еще раз функция от этого грязнее не становится. Она как порождала одно и то же значение для одного и того же набора параметров, так и будет порождать. Другое дело, что если входные данные меняются во время исполнения, то конечно вычисление будет грязным.

Проблема в том что с твоим подходом мы не можем это проконтролировать.

VD>Но на практике это как раз не проблема. Проблема отследить тонны кода в котором проблему может вызвать любой оператор. А "контролируемая грязь" — это как раз даже хорошо. Без этого не всегда можно добиться оптимальной производительности.

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

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

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

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

VD>Функция — несомненно. Вычисление — может стать грязным. Но вина в том не функции, а какой-то другой функции.
Чушь! Если в функцию не передали грязь то она не может стать грязной никак и ни когда.

WH>>Таким образом мы приходим к тому что чистота функции определяется исключительно сигнатурой функции.

VD>Чушь. Если в функции меняется, скажем, поле класса или глобальная перменная, то она грязная.
Так я про то и говорю. Если мы в функцию передали грязь то она грязная.

VD>Никаких проблем в них нет, если они указывают на неизменяемые структуры данных или если пользователь сам пометил их как безопасные.

Ты говоришь ровно как С++ники. У них тоже ни с чем проблем нет... А на практике решето.

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

Ты сам то веришь в то что сказал?
Вот это код явно посылает гарантии системы типов
B(MrkAsPure(x => { ar.Add(x); x * 2; }))

и исключает оптимизиции ибо мы не можем оптимизировать код вида
    def a = act(1);
    def b = act(1);

тк результат работы приложения начнет зависить от колличества вызовов act...

WH>>Зачем тебе логирование внутри чистой функции?

VD>Для отладки. Это только в сказках ФП и чистые мат.вычисления делают не нужной отладку.
Если отладка это единственная причина то специально для отладки можно встроить в платформу хак.

VD>Ладно. Я эту дискуссию завязал. Практического смысла в ней пока нет.

Если мы говорим про язык плотно интегрированный в .NET то в этом вообще смысла нет.
Ибо там везьде тонны грязи и все пронизано глобальными переменными.
... << RSDN@Home 1.2.0 alpha 4 rev. 1305>>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[9]: Pure keyword
От: para  
Дата: 16.03.10 06:20
Оценка:
Здравствуйте, VladD2, Вы писали:

почему просто не потребовать, чтоб на вход чистой функции подавались чистые делегаты:
def pure B(act : pure int->int) { A(act); }

чистый делегат можно создать из чистой функции лимбо из лямбды
А макрос MrkAsPure — проверяет чистоту лямбды и возвращает чистый делегат
def ar = List();
B(MrkAsPure(x => { ar.Add(x); x * 2; }))

да и наверняка, можно сделать это автоматически без явного вызова MrkAsPure
Re[6]: Pure keyword
От: FR  
Дата: 16.03.10 07:47
Оценка:
Здравствуйте, WolfHound, Вы писали:

AB>>>а такая?

AB>>>def isItPure( act : void->int ) { act(); 1; }
AB>>>?
A>>И такая тоже нет
WH>Это зависит от того является ли act pure или нет.
WH>А чтобы четко отделить мух от катлет нам придется завести 2 типа функций...

В D так и сделано, жестко разделено, например такое:

int Tst(int delegate () f) pure
{
    return f();
}


Выдаст ошибку компиляции:
Error: pure function 'Tst' cannot call impure delegate 'f'


А такое:

int Tst(int delegate () pure f) pure
{
    return f();
}


нормально скомпилируется.
Re[14]: Pure keyword
От: FR  
Дата: 16.03.10 07:53
Оценка:
Здравствуйте, WolfHound, Вы писали:

VD>>Хочешь сказать, что в ней может быть ссылка на функцию и не будет возможности узнать чистая она или нет?

WH>Как вариант.
WH>Вообще в любом случае любое обращение к глобальной переменной делает функцию грязной.

Если глобальная переменная не мутабельная можно спокойно обращаться, в D так и сделано.
Re[10]: Pure keyword
От: AngeL B. Россия  
Дата: 16.03.10 08:18
Оценка:
Здравствуйте, para, Вы писали:

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


P>почему просто не потребовать, чтоб на вход чистой функции подавались чистые делегаты:

P>
P>def pure B(act : pure int->int) { A(act); } 
P>

а вот зачем ты меняешь написанное? Функция B у меня в примере грязная. И в этом все дело.
она получает грязный делегат, и вызывает чистую функцию.
Re[9]: Pure keyword
От: AngeL B. Россия  
Дата: 16.03.10 08:23
Оценка:
Здравствуйте, VladD2, Вы писали:

AB>>а если код вот такой

AB>>
AB>>def pure A(act : int->int) { act(5)+2; }  //pure
AB>>def B(act : int->int) { A(act); }         //не pure

AB>>main() { 
AB>>    ArrayList ar = ArrayList();
AB>>    B(x => x*2);              
AB>>    B(x => { ar.Add(x); x*2; }
AB>>}
AB>>

AB>>тогда что?
VD>Тогда в последней строчке ошибка будет.

это по какому такому правилу ошибка будет?
функция B — грязная, и я могу передавать туда все что захочу.
так что единственным местом где может быть ошибка это код самой B в моменте вызова A (как в примере из языка D).
это и будет шлюзом между мирами, но формально он будет соответствовать const_cast-у, как его не назови.

P.S. Кстати, а как эту проблему в D решают?
Re[10]: Pure keyword
От: FR  
Дата: 16.03.10 08:27
Оценка:
Здравствуйте, AngeL B., Вы писали:


AB>P.S. Кстати, а как эту проблему в D решают?


В D два типа делегатов чистые и обычные, так что не скомпилируется, если я правильно понял.
Re[10]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 16.03.10 10:34
Оценка:
Здравствуйте, para, Вы писали:

P>почему просто не потребовать, чтоб на вход чистой функции подавались чистые делегаты:

P>
P>def pure B(act : pure int->int) { A(act); } 
P>


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

P>чистый делегат можно создать из чистой функции лимбо из лямбды

P>А макрос MrkAsPure — проверяет чистоту лямбды и возвращает чистый делегат
P>
P>def ar = List();
P>B(MrkAsPure(x => { ar.Add(x); x * 2; }))
P>

P>да и наверняка, можно сделать это автоматически без явного вызова MrkAsPure

MrkAsPure нужен для передачи не чистой (или функции чистота которой не установлена) функции.
С чистыми все и так ясно. Сложность здесь скорее будет в том, что функции могут формироваться динамически (из кучи лямбд и замыканий).
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Pure keyword
От: nikov США http://www.linkedin.com/in/nikov
Дата: 21.03.10 17:37
Оценка:
Здравствуйте, VladD2, Вы писали:

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

VD>Тут вопрос стоит как это контролировать. Можно засунуть информацию о чистоте в тип функционального типа, а можно контролировать это дело только при вызове.

А как контролировать при вызове? Что делать, если функциональный аргумент — это результат вызова другого метода, или если он извлекается из коллекции (массива, списка и т.д.)? По-моему, без изменения системы типов тут не обойтись.
Re[12]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 21.03.10 18:00
Оценка:
Здравствуйте, nikov, Вы писали:

N>А как контролировать при вызове? Что делать, если функциональный аргумент — это результат вызова другого метода, или если он извлекается из коллекции (массива, списка и т.д.)?


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

N>По-моему, без изменения системы типов тут не обойтись.


В прнципе можно, но пожалуй проще заложить данную информацию в тип. Проблема такого решения заключается в том, что ее придется кодировать в получаемых сборках и она будет доступна только для сборок созданных на этом же языке.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: Pure keyword
От: nikov США http://www.linkedin.com/in/nikov
Дата: 21.03.10 18:03
Оценка:
Здравствуйте, VladD2, Вы писали:

N>>По-моему, без изменения системы типов тут не обойтись.


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


А вправе ли чистый метод кидать исключение?
Re[14]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 21.03.10 18:07
Оценка:
Здравствуйте, nikov, Вы писали:

N>А вправе ли чистый метод кидать исключение?


Если не страдать пароноей, то по-моему — да. Я рассматривю исключение как остановку вычислений и считаю их не приемлемыми для штатной передачи управления внтури кода.

Вот ловить исключения — это несколько другой вопрос. Это можно и запретить. Тогда исключение внутри чистого кода будет по любому приводить управление в грязный код который имеет право делать все что ему взбредет в голову.

В многопоточном окружении исключения весьма частый зверь. Так что без них никуда.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[15]: Pure keyword
От: VoidEx  
Дата: 21.03.10 21:54
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Вот ловить исключения — это несколько другой вопрос. Это можно и запретить. Тогда исключение внутри чистого кода будет по любому приводить управление в грязный код который имеет право делать все что ему взбредет в голову.


Ну прямо Хаскель получается. Остаётся рассмотреть, как сделано в Хаскеле всё остальное, монаду IO убрать, а все чистые пометить Pure. Будет недохаскель с одной монадой.
Re[16]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 21.03.10 22:30
Оценка:
Здравствуйте, VoidEx, Вы писали:

VE>Ну прямо Хаскель получается. Остаётся рассмотреть, как сделано в Хаскеле всё остальное, монаду IO убрать, а все чистые пометить Pure. Будет недохаскель с одной монадой.


Ты чаем форумом не ошибся?

Просьба, недохаскели осбуждать где-нибудь в другом месте.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[17]: Pure keyword
От: VoidEx  
Дата: 22.03.10 09:03
Оценка:
Здравствуйте, VladD2, Вы писали:

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


VE>>Ну прямо Хаскель получается. Остаётся рассмотреть, как сделано в Хаскеле всё остальное, монаду IO убрать, а все чистые пометить Pure. Будет недохаскель с одной монадой.


VD>Ты чаем форумом не ошибся?

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

VD>Просьба, недохаскели осбуждать где-нибудь в другом месте.

Да где ж, как не здесь.
Re[18]: Pure keyword
От: VladD2 Российская Империя www.nemerle.org
Дата: 22.03.10 12:20
Оценка:
Здравствуйте, VoidEx, Вы писали:

VD>>Просьба, недохаскели осбуждать где-нибудь в другом месте.

VE>Да где ж, как не здесь.

В Философии. На крайняк в Декларативном программировании.

А вообще, если нет чего сказать конструктивного, то можно и воздержаться. Лично мне на подобные выпады даже реагировать не хочется. Потратишь кучу времени на объяснение прописных истин и в итоге все равно ничего кроме флэйма не получишь.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: Pure keyword
От: Воронков Василий Россия  
Дата: 22.03.10 16:45
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Ну, дык это иногда нужно. Скажем для логирования.


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