Возможно ли избавиться от последовательного выполнения, оставаясь в рамках ФП?

Кстати в книжке по R я примерно это и читал, мне тоже понравилась такая «суть» :)

Тебя обманули. Суть пайпов — это суть ООП. каждый элемент пайпа - объект. Эти объекты обмениваются сообщениями. К ФП это не имеет ни малейшего отношения. Если бы это было ФП, у тебя вычисление должно было бы не прерваться на stdout, а уйти обратно в вызывающий код, то есть, ушел со stdin — туда же и вернулся. FP не допускает прерывания вычислений. Подпрограмма (функция) обязана вернуть результат вызывающему коду.

Суть пайпов — это суть ООП

https://hackage.haskell.org/package/pipes-4.1.5/docs/Pipes-Tutorial.html

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

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

привет anonimous!

Вообще-то наоборот

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

мало ли что там Вася Пупкин пишет. Ему кажется, что это говно похоже на пайпы, пусть думает, тебе то что?

Твое вонючее ФП

Иди гуляй, мои щедрые уроки для тебя закончены.

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

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

Возможно. Лови статейку для изучения https://www.fpcomplete.com/blog/2015/02/primitive-haskell

Думаю немного сложноватно для тебя, но всё очень хорошо объяснено.

Неужели пациент таки принял таблетки (правда, не те), и его теперь клинит по-другому?

Мутабельные объекты не противоречат ФП, если сохраняется ссылочная прозрачность.

Это как?

Я неправильно понимаю, что такое ссылочная прозрачность или просто не могу придумать правильный контрпример? Ссылочная прозрачность, это ведь про то, что неважно передается объект по ссылке или по значению - поведение от этого не меняется.

Как думаете,сколько раз ТС-у кидали эту статью: https://wiki.haskell.org/IO_inside ? А сколько раз он ее прочел?

// ставлю 3 - 0

Ссылочная прозрачность, это ведь про то, что неважно передается объект по ссылке или по значению - поведение от этого не меняется.

Отсюда следует, что ТС прав, получается, фьючер не ложится на чистую ФП-парадигму?

Это как?

Легко, просто и непринуждённо. Например, открываем исходники пакета bytestring и слегка охреневаем от обилия мутабельности.

Если не нравятся байтстринги, посмотри исходники пакета buffer-builder. Его, кстати, используют в самом настоящем хайлоад-продакшене.

Если не нравится буфер-билдер, посмотри исходники пакета hashtables.

Если и это не нравится, то хакейдж тебе в руки, сам ищи.

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

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

Ссылочно-прозрачное выражение - это выражение, которое можно заменить результатом его вычисления

Ну, и как сюда засунуть муттабельный объект, так, чтобы это условие соблюдалось?

Легко, просто и непринуждённо. Например, открываем исходники пакета bytestring и слегка охреневаем от обилия мутабельности.

unsafe
74 matches

unsafePerformIO
5 matches

Точно читать?

Например как в Хаскеле, обернув все в IO.

Ссылочно-прозрачное выражение - это выражение, которое можно заменить результатом его вычисления

array=[1,2,3]
func=function(){return array}
func() ---> array
array.pop()
func() ---> array

Выражение func() ссылочно-прозрачное. В чем проблема?

Например как в Хаскеле, обернув все в IO.

Почему после этого оно становится мутабельным?

Ты не понял, речь о возможности трансформации твоего примера в

array=[1,2,3]
func=function(){return array}
let x = func()
x
array.pop()
x

с сохранением семантики.

Кто становится мутабельным?

Ну, и как сюда засунуть муттабельный объект, так, чтобы это условие соблюдалось?

Ещё раз. Thunk в ленивом языке это мутабельный объект. Просто его изменения контролируемы: вначале он ссылка на замыкание, которое вычисляет некое значение, а когда значение вычислено — ссылка на само значение. Таким образом thunk может быть и фьючер'ом: вначале он ссылка на функцию которая вычисляет значение, затем он ссылка на wait, а в конце ссылка на значение. И никакого IO.

Это разве не детали реализации?

Ну, и как сюда засунуть муттабельный объект, так, чтобы это условие соблюдалось?

Например как в Хаскеле, обернув все в IO.

Почему обернутый в IO объект - мутабельный?

речь о возможности трансформации твоего примера в ... с сохранением семантики.

Ну так она и сохранится.

array=[1,2,3]
func=function(){return array}
func()
array.pop()
func()

// ::: [ 1, 2, 3 ]
// ::: [ 1, 2 ]


array=[1,2,3]
func=function(){return array}
x = func()
x
array.pop()
x

// ::: [ 1, 2, 3 ]
// ::: [ 1, 2 ]

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

ЕМНИП перезапись санка значением — часть концепции ленивого вычисления и редукции графов. Хотя я так понимаю непосредственно к лямбда исчислению оно отношения не имеет.

Естественно не имеет. Это чистой воды реализация.

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

Тем не менее, она не нарушает ссылочной прозрачности.

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

А что не так? Его просили трансформировать пример с сохранением семантики, он это сделал. Или что? Загорелось от того, что ссылочная прозрачность может быть не только в ФП? Ну так учи матчасть, это всем известно. То что тебя на ФП-пропагандисты развели как последнего лоха, это уже другой вопрос.

Увлекся я тут ФП. Очень мне нравиться.

Увлекись-ка русским языком для начала.

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

У тебя каша в голове.

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

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

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

никакого отношения

никакого прямого

Ты опять не понял. Речь не о конкретном выражении, речь о том, что в ФП этот принцип работает для _любых_ выражений. Например,

func=function(){return array}
let x = func()
let y = array.pop()
x
y
x

должно быть эквивалентно предыдущим двум примерам. «Частичная» ссылочная прозрачность есть, наверное, в любом языке.