Это какая-то нереальная толщина.

Тонко.

Ты, реально, открыл мне глаза на ФП. Я серьезно.

ладно с чистотой, а вот функция как перврклассная сушность тоже не нужна пацанам?

Спасибо, посмеялся, хорошая попытка.

Но что ты сказать-то хотел? Твоя f - чистая, да.

ладно с чистотой, а вот функция как перврклассная сушность тоже не нужна пацанам?

Не помешают, но это из другой оперы.

Манфред фон Тун, перелогиньтесь.

Спасибо, похихикал в кулак.

Да любая функция чистая, потому как дефолтно функция оперирует символами. Если бы не было этих неявных вычислений, которые создают иллюзию того, что «функция НЕ ВСЕГДА возвращает одинаковый выход при одинаковом входе», про чистоту бы вообще не трындели.

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

шах и мат

Да любая функция чистая

func = rand

Да любая функция чистая

f = time()

Твоя f - чистая, да.

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

f = time()

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

Лор какой-то не тот: во всем Ынтерпрайзе сейчас мейнстрим это ООП,а fp - just for fun, на лоре почему-то все с точностью на оборот.

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

Зачем этот понос в development? Перенесите уже в Talks.

Твой понос же терпят, и ниче.

Уколол, молодец. Можешь идти делать уроки.

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

 λ x . x

чистая функция. А что ты хотел этим сказать?

Кококококококо

Я, наверное, не совсем удачный пример привел. Пусть будет пример со свободной переменной

l(x) ---> x + a
a=1
b=2
l(b) ---> выхлоп 3
a=2
l(b) ---> выхлоп 4

Эта функция чистая,

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

С pure-философской точки зрения - да! Неоспоримо!

Но в программировании нас интересует баланс между pure-философией и практикой. И когда pure-философия становится непрактичной, нам приходится от нее отклониться в сторону практики.

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

l(3) ---> 3
a=2
l(3) ---> 4

Расскажите мне ещё о чистых функциях.

Тогда объясни, умник, чем она отличается от такой, кроме синтаксиса.

l(x, y) ---> x + y
a=1
b=2
l(a, b) ---> выхлоп 3
a=2
l(a, b) ---> выхлоп 4

Я не понял, че это такое.

Угодай уже популярно, на пальцах, объяснил. Если не ферштейн, то срочно наверни матчетца. Тебя даже википедия просветит.

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

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

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

Гы-ы-ы-ы. Ышшо один «прозревший»? Сколько же вас таких еще будет-то?

Ты сначала в кишки какого-нибудь Data.ByteString (строгой версии), а потом три пацанам про чистоту ФП вообще, и хаскеля в частности.

Для тех кто в танке: все потроха BS сотоят из unsafe-вызовов чуть более чем наполовину. В том числе и из пресловутого unsafePerformIO. BS — суть ForeignPtr, т.е. на хаскельной куче лежат только указатель на данные, и указатель на финалайзер. ЧСХ, и финалайзер, и аллокатор — высокомагические функции рантайма (написанного на самом обычном чистом C), а по сути дела — malloc и free.

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

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

Они неверны, бесполезны и бессмысленны.

Они идеально верны с философской точки зрения, но вот бесполезны и бессмысленны - это точно!

но вот бесполезны и бессмысленны - это точно!

Печально, что ТС этого не понимает и считает себя тоже правым.

быдло элита ФП

Пусть они и дальше продолжают забавляться с монадами:-)

Эта функция чистая

Чистая функция по определению возвращает одни и те же значения при одних и тех же аргументах — твоя l возвращает разные при одном и том же b, значит она не чистая. Её можно очистить если передавать контекст явно (State monad, etc.) — b одно и то же, но контекст (окружение) разное, так что результаты разные, всё чисто, никаких проблем.

Так же можно очистить всё что угодно (ST, IO, Par, etc. monads) — все функции чистые, просто в остальных языках это не так (не возвращают там функции одно и то же при одинаковых результатах).

З.Ы.

Нормальные пацаны

http://dlang.org/function.html

http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

http://lwn.net/Articles/285332

http://llvm.org/releases/2.2/docs/ReleaseNotes.html

http://llvm.org/releases/2.4/docs/ReleaseNotes.html

http://pimiddy.wordpress.com/2012/04/20/pure-functions-in-cc

можно очистить если передавать контекст явно

Ну так, при динамическом диндинге контекст передается явно:

(define inner (lambda() (+ x y)))

(define context1 (lambda()(let (x 1 y 2) (inner))))
(define context2 (lambda()(let (x 2 y 2) (inner))))

(print (context1)) ; 3
(print (context2)) ; 4

диндинге/биндинге

// fixed

при одинаковых результатах

*аргументах

явно

Неявно — в context1 и context2 ты же ничего не передаёшь. Но если починить дисциплину связывания, то да — вполне будет чистое при явной передаче иммутабельных mapов в качестве окружения (только не ФП, а функции в вопросе).

в context1 и context2 ты же ничего не передаёшь

Ну, можно сказать, что передаю. Let здесь, кажись, эквивалентно:

(define inner (lambda() (+ x y)))
(define context1 (lambda() ((lambda(x y) (inner))1 2)))
(print (context1)) ; 3

Я про

(inner)

(context1)

прилетают они туда исключительно за ширмой по dynamic scoping. Scheme, CL (не считая специальных переменных) и все остальные нормальные языки используют лексическую область видимости, так что вообще не вижу смысла обсуждать заведомо сломанное поведение.

А так классический пример:

f >- g = uncurry g . f
ret = (,)
put x _ = ((), x)
get x = (x, x)
lift f x y = x >- \a -> y >- (ret . f a)

t =
  put 1                                 >- \_ ->
  let l x = lift (+) get (ret x)        in
  l 1                                   >- \r1 ->
  put 2                                 >- \_ ->
  l 1                                   >- \r2 ->
  ret (r1, r2)

-- > t 0
-- ((2,3),2)

К параше пройди, фраер приблатненный, пока всей хатой твою морду под шконарь не опустили, мурло ушастое.

Ты свою пасть лоховскую прикрой, я таких как ты нюх топтал, опущенец. И не только.

Обоснуй предъяву, а не то масть твоя щас петушиной окажется.

Недолго мучилась старушка. У фраерка то пукан с гипертонией.

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

Лор какой-то не тот: во всем Ынтерпрайзе сейчас мейнстрим это ООП,а fp - just for fun, на лоре почему-то все с точностью на оборот.

А что тебя удивляет? Ведь ЛОР не является сообществом профессиональных разработчиков, да и никогда им не был. Профессионалы (то есть те, кто владеет технологиями на высоком уровне и зарабатывает на жизнь разработкой ПО) здесь в подавляющем меньшинстве и, я бы сказал, на птичьих правах. Абсолютное большинство — это тролли, диванные теоретики, доморощенные гуру, форумные трепачи, лисперы, хаскелисты и прочие ёбнутые на голову адепты маргинальщины, фрики, школьники, хипсторы, петросяны, IT-эзотерики, IT-шарлатаны, IT-небыдло и так далее. Здесь в воздухе густо пахнет мамкиным борщом и нонконформизмом. Здесь модно поливать говном все практические, промышленные технологии и подходы (к которым, несомненно, относится и ООП).

ЛОР маргинален, поэтому и мейнстримом здесь является маргинальщина (Haskell, LISP и т.п.) Поэтому IMHO все закономерно.

+1

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

Можно подробнее о нечеловеческой деятельности?