Доброго времени суток. Это статья — перевод заинтересовавшего меня поста в блоге аспиранта Университета штата Нью-Йорк в Стоуни-Брук. Статья в доступной форме описывает основные концепции функционального программирования, их преимущества и недостатки. Думаю она будет полезна широкому кругу читателей, которые сомневаются, нужно ли им углубляться в мир функционального программирования или нет. Пожелания, предложения и замечания по переводу и терминологии принимаются по личной почте.
Мнение переводчика может иногда не совпадать с мнением автора, но переводить статью было крайне занимательно.
Понедельник, 19 июня, 2006
Введение
Программисты — прокрастинаторы (то есть лентяи). Прийти, сделать кофе, проверить почту, почитать RSS летну, почитать новости, проверить свежие статьи на техническом сайте, полистать политические дискуссии на программистском форуме. Смыть, повторить, чтобы ничего не пропустить. Пойти на обед. Вернуться, уткнутся в IDE на несколько минут. Проверить почту. Приготовить кофе. И вот неожиданно день подходит к концу.
Но время от времени в поле зрения оказываются занятные (затруднительные, многообещающие) статьи и посты в блогах. Если вы ищете в правильном месте, то как минимум одна такая статья будет встречаться вам каждые несколько дней. В этих постах сложно разобраться, на это требуется время, поэтому они накапливаются в папке «Прочитать». Прежде, чем вы успеете понять что к чему, окажется что уже накопилась куча ссылок и папка, полная PDF файлов. Вам, и понадобится целый год и хижина посреди леса, где на мили вокруг нет ни души, чтобы во всём этом разобраться. И желательно, чтобы кто-нибудь каждое утро приносил еду и забирал мусор, пока вы прогуливаетесь к реке.
Я не знаю, какой у вас список, но большая часть моего списка касается функционального программирования. Такие статьи обычно самые сложные. Часто они написаны сухим академическим языком, и даже «ветераны Wall Street с десятилетним стажем» не понимают о чем говорится в статьях по функциональному программированию (ФП). Если вы зададите вопрос менеджеру проекта в Citi Group или в Deutsche Bank [1] почему они выбрали JMS вместо Erlang, то услышите в ответ, что они не могут использовать академический язык для промышленных разработок. Проблема в том, что большинство комплексных систем с самыми жесткими требованиями были написаны с использованием элементов функционального программирования. Что-то не сходится.
Действительно статьи о ФП трудны для понимания, но их можно написать проще. Причина возникшей пропасти знаний чисто историческая. По сути в концепции ФП нет ничего сложного. Взгляните на эту статью, как на «доступное руководство по ФП», как на мостик между нашими императивными умами и миром ФП. Заварите себе кофе и продолжим. Надеюсь, что уже очень скоро коллеги начнут шутить по поводу ваших ФП комментариев.
Так что же такое ФП? Откуда оно пошло? На что оно годно? Если оно действительно так полезно, как об этом твердят защитники ФП, то почему его не используют чаще в промышленных масштабах? Почему только люди с PhD склоняются к функциональным языкам? Но что ещё важнее, почему так чертовски трудно освоить функциональные языки? Что скрывается за всеми этими замыканиями, продолжениями, каррированием, ленивые вычисления и отсутствие побочных эффектов? Как это всё можно использовать в проекте, который не охватывает целую вселенную? Почему это всё так далеко от того хорошего, что свято и дорого нашим императивным сердцам? Скоро мы во всём разберёмся. Для начала давайте поймём в чём причина огромной пропасти между академическими статьями и реальным миром. Чтобы ответить на этот вопрос достаточно прогуляться в парке.
Прогулка в парке
Садитесь в машину времени. Наша прогулка в парке произошла более 2 тысяч лет назад в один из тех солнечных дней давно забытой весны 380 года до н.э. За городскими стенами Афин под ласковыми тенями оливковых деревьев Платон прогуливался в направлении Академии с красивым мальчиком рабом. Стояла чудесная погода, обед приятной тяжестью отдавался в животе, и разговор плавно перешёл на философские темы.
«Посмотри на тех двух студентов», сказал Платон, аккуратно подбирая слова, чтобы придать вопросу образовательного смысла. «Кто из них, по-твоему, выше?» Мальчик раб посмотрел в сторону бассейна, возле которого стояли два человека. «Они приблизительно одного роста», ответил мальчик. «Что ты имеешь в виду под словами 'приблизительно одного роста'?», спросил Платон. «Ну, отсюда они выглядят одинаково, но я уверен, что если мы подойдём поближе, то я смогу увидеть разницу в росте.»
Платон улыбнулся. Он вёл мальчика в правильном направлении. «То есть ты хочешь сказать, что в мире нет идеально совпадающих вещей?» Мальчик призадумался и ответил: «Да, я так думаю. Всегда существует маленькая разница, даже если мы не можем её увидеть.» Он дошёл до самой сути! «Тогда если нет идеально совпадающих вещей в этом мире, то как ты понимаешь концепцию 'идеального' равенства?» Это ввело мальчика в ступор. Он ответил: «Я не знаю».
Так родилась первая попытка понять природу математики. Платон предположил, что в нашем мире всё лишь приближение идеала. Он также осознал, что люди способны понять концепцию идеала, хотя никогда с ним не сталкивались. Он пришёл к выводу, что идеальные математические формы должны существовать в другом мире, и что мы каким-то образом знаем о них из связей с этой «альтернативной» вселенной. Очевидно, что мы не можем увидеть идеальный круг. Но при этом мы понимаем, что из себя представляет идеальный круг, и как он может быть описан математически. Что же тогда математика? Почему вселенная описывается математическими законами? Всё ли может описать математика? [2]
Философия математики очень сложный предмет. Как и большинство философских дисциплин, она скорее задаёт вопросы, чем отвечает на них. Учёные в большинстве своём согласны с тем фактом, что математика — это настоящая головоломка: в основе лежит набор базовых непротиворечивых принципов и набор правил, как этими принципами оперировать. Затем мы можем комбинировать правила, получая всё более и более сложные законы. Математики называют такой метод «формальной системой» или «исчислением». Например, можно построить формальную систему для Тетриса. По сути работающий Тетрис и есть сам по себе формальная система, просто она записана в необычном виде.
Цивилизация пушистых существ с Альфы Центавра не сможет прочесть нашу формальную систему Тетриса или круга, потому что их единственный орган чувств может воспринимать только запахи. Возможно они никогда не построят Тетрис, но наверняка у них будет формальная система для круга. Скорее всего у нас не получится с ней ознакомиться, так как наше обоняние не настолько развито. Но как только будет расшифрован язык представления (путём различных сенсорных инструментов и стандартной техники обратного инженеринга), базовые концепции станут понятны любой интеллектуально развитой цивилизации.
Даже если бы не существовало ни одной разумной цивилизации во вселенной, формальная система для Тетриса и круга всё равно были бы логически верными. Просто не нашлось бы существ, способных эти системы найти и формализовать. Если внезапно появится разумная расса пришельцев, то они, скорее всего, разработают свою формальную систему для описания вселенной. Конечно, маловероятно, что они изобретут Тетрис, потому что во вселенной нет аналогов этой игре. Тетрис — это один пример из огромного числа формальных систем, загадок, которые не имеют отношения к окружающей действительности. Даже такое понятие как натуральные числа не всегда можно отнести к реальному миру, ведь можно представить себе настолько большое число, что его нельзя применить к чему-либо во вселенной, но при этом оно будет конечным.
Немного истории [3]
Давайте повернём колёса нашей машины времени и переместимся немного ближе, в 1930-е. Великая депрессия опустошила Новый и Старый свет. Почти все семьи из всех социальных слоев почувствовали на себе громадный экономический спад. Осталось совсем мало убежищ, в которых люди могли не боятся бедности. Некоторым людям повезло оказаться в таких убежищах. Нас интересуют математики в Принстонском университете.
Новые корпуса, построенные в готическом стиле, придавали университету ауру безопасности. Специалисты по логике со всей страны приглашались в Принстон для основания нового подразделения. В то время, как большинство американцев с трудом добывали себе пропитание, высокие потолки, стены с узорами из дерева, ежедневные дискуссии за чашечкой чая, и прогулки в лесу, составляли условия проживания в Принстоне.
Одним из математиков, проживавших в таком расточительном образе жизни, был молодой человек по имени Алонзо Чёрч (Alonzo Church). Алонзо получил степень бакалавра в Принстоне и его уговорили остаться в аспирантуре. Алонзо чувствовал, что окружающая обстановка была чересчур роскошной. Он редко появлялся на обсуждении математических проблем за чашечкой чая и не любил гулять в лесу. Алонзо был одиночкой: он был более плодовит, когда работал один. Тем не менее он регулярно встречался с другими обитателями Принстона. Среди которых были Алан Тьюринг (Alan Turing), Джон фон Нейман (John von Neumann) и Курт Гёдель (Kurt Gödel).
Эти четверо интересовались формальными системами. Они не уделяли особого внимания физическому миру, их интересовала работа с абстрактными математическими головоломками. В их головоломках было нечто общее: математики изучали вопросы вычислений. Если у нас есть машина с бесконечными вычислительными возможностями, то какие задачи можно на ней решать? Можно ли решать задачи автоматически? Существуют ли неразрешимые задачи и почему? Будут ли машины с разной архитектурой одинаковыми по мощности?
Совместно с другими учёными Алонзо разработал формальную систему названную Лямбда-исчислением. Система по сути была языком программирования для одной из воображаемых машин. Она была основана на функциях, которые принимают в качестве аргументов функции, и возвращают функцию. Такая функция была обозначена греческой буквой Лямбда, что дало название всей системе [4]. Используя эту систему Алонзо удалось построить рассуждения касательно вышеописанных вопросов и вывести ответы на них.
Независимо от Алонзо, Алан Тьюринг проводил подобное исследование. Он разработал другую формальную систему (которую сейчас называют Машиной Тьюринга), и используя её пришёл к выводам, подобным Алонзо. Позже было доказано, что машина Тьюринга и лябда-исчисление имеют одинаковую мощность.
В этот момент наша история останавливается. Я бы подытожил статью, и вы переключились бы на другую страницу, если бы не началась Вторая мировая война. Мир пылал. Войска США очень интенсивно использовали артиллерию. Чтобы повысить точность армия наняла большую группу математиков, которые постоянно решали дифференциальные уравнения, необходимые для баллистических таблиц стрельбы. Быстро стало понятно, что такая задача слишком сложна для ручного решения, для преодоления этой проблемы было разработано специальное оборудование. Первой машиной для решения баллистических таблиц был Mark I построенный IBM — она весила 5 тонн, состояла из 750'000 деталей и могла совершать 3 операции в секунду.
Гонка, конечно, на этом не закончилась. В 1949 общественности был показан Электронный Дискретный Переменный Автоматический Компьютер (Electronic Discrete Variable Automatic Computer, EDVAC). Это был первый пример реализации архитектуры фон Неймана, и был первой действительно работающей машиной Тьюринга. На некоторое время работы Алонзо Чёрча были отложены в сторонку.
В конце 50-ых профессов Массачусетского технологического института (MIT) Джон Маккарти (John McCarthy ), тоже выпускник Принстона, начал проявлять интерес к работе Алонзо Чёрча. В 1958 году он представил язык обработки списков, List Processing language (Lisp). Lisp задумывался как имплементация Лямбда-исчисления Алонзо, которая работает на компьютерах фон Неймана. Многие компьютерные учёные отметили выразительную мощь Lips-а. В 1973 году группа программистов в лаборатории искусственного интеллекта в Массачусетском технологическом институте разработали железо, которое они назвали Lisp-машиной. Это была аппаратная реализация лямбда-исчислений Алонзо.
Функциональное программирование
Функциональное программирование — это практическая реализация идей Алонзо Чёрча. Не все идеи Лямбда-исчисления переросли в практическую сферу, так как лямбда-исчисления не учитывали физических ограничений. Тем не менее, как и ОО программирование, функциональное программирование — это набор идей, а не набор четких указаний. Существует много функциональных языков, и большинство из них делают одни схожие вещи по разному. В данной статье я объясню наиболее широко используемые идеи из функциональных языков используя примеры на Java (да, вы можете писать функциональные программы на Java если у вас есть склонности к мазохизму). В следующих нескольких разделах мы возьмём язык Java и внесём в него изменения, чтобы он превратился в пригодный к использованию функциональный язык. Начнём наше путешествие.
Лямбда исчисление было придумано для изучения проблем, связанным с вычислениями. Функциональное программирование, стало быть, в первую очередь имеет дело с вычислениями, и, на удивление, использует для этого функции. Функция — это базовый элемент функционального программирования. Функции используются почти для всего, даже для простейших расчётов. Даже переменные заменяются функциями. В функциональном программировании переменные — это просто синонимы (alias) для выражений (чтобы нам не пришлось писать всё в одну строку). Их нельзя изменять. В каждую переменную можно записать только один раз. В терминах Java это означает, что все переменные объявляются как final (или const если имеем дело с C++). В ФП нет не-final переменных
final int i = 5;
final int j = i + 3;
Так как все переменные финальные, то можно сформулировать два утверждения. Нет смысла постоянно писать ключевое слово final, и нет смысла называть переменные … переменными. Теперь мы внесём два изменения в Java: каждое объявление переменной будет финальным, мы будем обращаться к переменным как к символам.
Теперь вы, наверное, удивляетесь, как вообще можно написать что-либо достаточно сложное на таком языке. Если все символы неизменяемые, то мы в принципе не можем поменять состояние программы! Это не совсем верно. Когда Алонзо работал над лямбда-исчислением, у него не было нужды сохранять состояние, чтобы изменить его позже. Его интересовало проведение операций над данными. Тем не менее, было доказано, что лямбда исчисление эквивалентно машине Тьюринга. В нём можно делать всё то же, что возможно в императивных языках. Как же нам достичь тех же результатов?
Оказывается, что функциональные программы могут хранить состояние, только они не используют для этого переменные. Они используют функции. Состояние хранится в параметрах функции, в стеке. Если хотите сохранить состояние, чтобы потом изменить его через время, то нужно написать рекурсивную функцию. Например, давайте напишем программу, которая переворачивает Java строку. Не забудьте, что все переменные объявляются как final [5].
String reverse(String arg) {
if(arg.length == 0) {
return arg;
}
else {
return reverse(arg.substring(1, arg.length)) + arg.substring(0, 1);
}
}
Эта функция довольно медленная, потому что она повторно вызывает сама себя [6]. Здесь возможна утечка памяти, так как множество раз создаются временные объекты. Но это функциональный стиль. Вам может показать странным, как люди могут так программировать. Ну, я как раз собирался вам рассказать.
Преимущества функционального программирования
Вы, наверное, думаете, что я не смогу привести доводы в оправдание монструозной функции выше. Когда я только начинал изучать функциональное программирование, я тоже так думал. Я ошибался. Есть очень хорошие аргументы в пользу такого стиля. Некоторые из них субъективные. Например, программисты заявляют, что функциональные программы проще понять. Я не буду приводить таких аргументов, потому что всем известно, что лёгкость понимания — это очень субъективная вещь. К счастью для меня, есть ещё куча объективных аргументов.
Unit тестирование
Так как в ФП каждый символ является неизменяемым, то функции не имеют побочных действий. Вы не можете менять значения переменных, к тому же функция не может поменять значение вне своей области видимости, и тем самым повлиять на другие функции (как это может случится с полями класса или глобальными переменными). Это означает, что единственный результат выполнения функции — это возвращаемое значение. А единственное, что может повлиять на возвращаемое значение — это аргументы, передаваемые в функцию.
Вот она, голубая мечта unit-тестеров. Можно протестировать каждую функцию в программе используя только нужные аргументы. Нет необходимости вызывать функции в правильном порядке или воссоздавать правильное внешнее состояние. Всё что вам нужно, это передать аргументы, которые соответствуют граничным случаям. Если все функции в вашей программе проходят Unit-тесты, то вы можете быть намного более уверены в качестве вашего ПО, чем в случае императивных языков программирования. В Java или C++ проверки возвращаемого значения не достаточно — функция может поменять внешнее состояние, которое тоже подлежит проверке. В ФП такой проблемы нет.
Отладка
Если функциональная программа ведёт себя не так, как вы ожидаете, то отладка — это пара пустяков. Вы всегда можете воспроизвести проблему, потому что ошибка в функции не зависит от постороннего кода, который выполнялся ранее. В императивной программе ошибка проявляется только на некоторое время. Вам придется пройти через ряд шагов, не относящихся к багу, из-за того, что работа функции зависит от внешнего состояния и побочных эффектов других функций. В ФП ситуация намного проще — если возвращаемое значение неправильное, то оно всегда будет неправильным, не зависимо от того, какие куски кода выполнялись прежде.
Как только вы воспроизведёте ошибку, найти её источник — тривиальная задача. Это даже приятно. Как только вы остановите выполнение программы, перед вами будет весь стек вызовов. Вы можете просмотреть аргументы вызова каждой функции, прямо как в императивном языке. С тем отличием, что в императивной программе этого не достаточно, ведь функции зависят от значений полей, глобальных переменных и состояний других классов. Функция в ФП зависит только от своих аргументов, и эта информация оказывается прямо у вас перед глазами! Даже больше, в императивной программе проверки возвращаемого значения не достаточно для того, чтобы сказать, правильно ли ведёт себя кусок кода. Вам придётся выследить десятки объектов за пределами функции, чтобы удостовериться, что всё работает правильно. В функциональном программировании всё, что нужно сделать — это взглянуть на возвращаемое значение!
Проходясь по стеку, вы обращаете внимание на передаваемые аргументы и возвращаемые значения. Как только возвращаемое значение отклоняется от нормы, вы углубляетесь в функцию и двигаетесь дальше. Так повторяется несколько раз пока вы не найдёте источник ошибки!
Многопоточность
Функциональная программа сразу готова к распараллеливанию без каких-либо изменений. Вам не придётся задумываться о deadlock-ах или состояниях гонки (race conditions) потому что вам не нужны блокировки! Ни один кусочек данных в функциональной программе не меняется дважды одним и тем же потоком или разными. Это означает, что вы можете легко добавить потоков к вашей программе даже не задумываясь при этом о проблемах, присущих императивным языкам.
Если дела обстоят подобным образом, то почему так редко функциональные языки программирования используются в многопоточных приложениях? На самом деле чаще, чем вы думаете. Компания Ericsson разработала функциональный язык под названием Erlang для использования на отказоустойчивых и масштабируемых телекоммуникационных коммутаторах. Многие отметили преимущества Erlang-а и стали его <a href=«www.erlang.org/faq/faq.html#AEN50»использовать. Мы говорим о телекоммуникациях и системах контроля трафика, которые далеко не так просто масштабируются, как типичные системы, разработанные на Wall Street. Вообще-то, системы написанные на Erlang, не такие масштабируемые и надёжные, как Java системы. Erlang системы просто сверхнадёжные.
На этом история многопоточности не заканчивается. Если вы пишете по сути однопоточное приложение, то компилятор всё равно может оптимизировать функциональную программу так, чтобы она использовала несколько CPU. Посмотрим на следующий кусок кода.
String s1 = somewhatLongOperation1();
String s2 = somewhatLongOperation2();
String s3 = concatenate(s1, s2);
Компилятор функционального языка может проанализировать код, классифицировать функции, которые создают строки s1 и s2, как функции потребляющие много времени, и запустить их параллельно. Это невозможно сделать в императивном языке, потому что каждая функция может изменять внешнее состояние и код, идущий непосредственно после вызова, может зависеть от неё. В ФП автоматический анализ функций и поиск подходящих кандидатов для распараллеливания — это тривиальнейшая задача, как автоматический inline! В этом смысле функциональный стиль программирования соответствует требованиям завтрашнего дня. Разработчики железа уже не могут заставить CPU работать быстрее. Вместо этого они наращивают количество ядер и заявляют о четырёхкратном увеличении скорости многопоточных вычислений. Конечно они очень вовремя забывают сказать, что ваш новый процессор покажет прирост только в программах, разработанных с учётом распараллеливания. Среди императивного ПО таких очень мало. Зато 100% функциональных программ готовы к многопоточности из коробки.
Развёртывание по горячему
В старые времена для установки обновлений Windows приходилось перезагружать компьютер. Много раз. После установки новой версии медиа проигрывателя. В Windows XP произошли значительные изменения, но ситуация всё ещё далека от идеальной (сегодня я запустил Windows Update на работе и теперь надоедливое напоминание не оставит меня в покое, пока не перезагружусь). В Unix системах модель обновления была получше. Для установки обновлений приходилось останавливать некоторые компоненты, но не всю ОС. Хотя ситуация выглядит лучше, но для большого класса серверных приложений это всё ещё не приемлемо. Телекоммуникационные системы должны быть включены 100% времени, ведь если из-за обновления человек не сможет вызвать скорую, то жизни могут быть потеряны. Фирмы с Wall Streets тоже не желают останавливать сервера на выходных, чтобы установить обновления.
В идеале нужно обновить все нужные участки кода не останавливая систему в принципе. В императивном мире это невозможно [пер. в Smalltalk-е очень даже возможно]. Представьте себе выгрузку Java класса на лету и перезагрузка новой версии. Если бы мы так сделали, то все экземпляры класса стали бы нерабочими, потому что потерялось бы состояние, которое они хранили. Нам пришлось бы писать хитрый код, для контроля версий. Пришлось бы серриализовать все созданные экземпляры класса, потом уничтожить их, создать экземпляры нового класса, попытаться загрузить серриализованные данные в надежде, что миграция пройдёт нормально и новые экземпляры будут валидными. И кроме того, миграционный код необходимо писать каждый раз вручную. И ещё миграционный код должен сохранять ссылки между объектами. В теории ещё куда ни шло, но на практике это никогда не заработает.
В функциональной программе всё состояние хранится в стеке в виде аргументов функций. Это позволяет значительно упростить развёртывание по горячему! По сути всё что нужно сделать — это вычислить разницу между кодом на рабочем сервере и новой версией, и установить изменения в коде. Остальное будет сделано языковыми инструментами автоматически! Если вы думаете, что это научная фантастика, то дважды подумайте. Инженеры, имеющие дело с Erlang, годами обновляют свои системы без остановки их работы.
Доказательные вычисления и оптимизация (Machine Assisted Proofs and Optimizations)
Еще одно интересное свойство функциональных языков программирования состоит в том, что их можно изучать с математической точки зрения. Так как функциональный язык — это реализация формальной системы, то все математические операции используемые на бумаге, могут быть применены и к функциональным программам. Компилятор, например, может конвертировать участок кода в эквивалентный, но более эффективный кусок, при этом математически обосновав их эквивалентность [7]. Реляционные базы данных годами производят такие оптимизации. Ничто не мешает использовать аналогичные приёмы в обычных программах.
Дополнительно вы можете использовать математический аппарат, чтобы доказать корректность участков ваших программ. При желании можно написать инструменты, которые анализируют код и автоматически создают Unit-тесты для граничных случаев! Такая функциональность бесценна для сверхнадёжных систем (rock solid systems). При разработке систем контроля кардиостимуляторов или управления воздушным трафиком такие инструменты просто необходимы. Если же ваши разработки не находятся в сфере критически важных приложений, то инструменты автоматической проверки всё равно дадут вам гигантское преимущество перед вашими конкурентами.
Функции высшего порядка
Помните, когда я говорил о преимуществах ФП, я отметил, что «всё выглядит красиво, но бесполезно, если мне придётся писать на корявом языке, в котором всё final». Это было заблуждением. Использование final повсеместно выглядит коряво только в императивных языках программирования, таких как Java. Функциональные языки программирования оперируют другими видами абстракций, такими, что вы забудете о том, что когда-то любили менять переменные. Один из таких инструментов — это функции высшего порядка.
В ФП функция — это не тоже самое, что функция в Java или C. Это надмножество — они могут тоже самое, что Java функции и даже больше. Пусть у нас есть функция на C:
int add(int i, int j) {
return i + j;
}
В ФП это не тоже самое, что обычная C функция. Давайте расширим наш Java компилятор, чтобы он поддерживал такую запись. Компилятор должен превратить объявление функции в следующий Java код (не забывайте, что везде присутствует неявный final):
int add(int i, int j) {
return i + j;
}
}
add_function_t add = new add_function_t();
Символ add не совсем функция. Это маленький класс с одним методом. Теперь мы можем передавать add в качестве аргумента в другие функции. Мы можем записать его в другой символ. Мы можем создавать экземпляры add_function_t в runtime и они будут уничтожены сборщиком мусора, если станут ненужными. Функции становятся базовыми объектами, как числа и строки. Функции, которые оперируют функциями (принимают их в качестве аргументов) называются функциями высшего порядка. Пусть это вас не пугает. Понятие функций высшего порядка почти не отличается от понятия Java классов, которые оперируют друг другом (мы можем передавать классы в другие классы). Мы можем называть их «классы высшего порядка», но никто этим не заморачивается, потому что за Java не стоит строгое академическое сообщество.
Как и когда нужно использовать функции высшего порядка? Я рад, что вы спросили. Вы пишите свою программу как один большой монолитный кусок кода не заботясь об иерархии классов. Если вы увидите, что какой-то участок кода повторяется в разных места, вы выносите его в отдельную функцию (к счастью в школах еще учат как это делать). Если вы замечаете, что часть логики в вашей функции должна вести себя по разному в некоторых ситуациях, то вы создаёте функцию высшего порядка. Запутались? Вот реальный пример из мой работы.
Предположим, что у нас есть участок Java кода, который получает сообщение, преобразует его различными способами и передаёт на другой сервер.
void handleMessage(Message msg) {
// ...
msg.setClientCode("ABCD_123");
// ...
sendMessage(msg);
}
// ...
}
Теперь представьте себе, что система поменялась, и теперь нужно распределять сообщения между двумя серверами вместо одного. Всё остаётся неизменным, кроме кода клиента — второй сервер хочет получать этот код в другом формате. Как нам справиться с этой ситуацией? Мы можем проверять, куда должно попасть сообщение, и в зависимости от этого устанавливать правильный код клиента. Например так:
class MessageHandler {
void handleMessage(Message msg) {
// ...
if(msg.getDestination().equals("server1") {
msg.setClientCode("ABCD_123");
} else {
msg.setClientCode("123_ABC");
}
// ...
sendMessage(msg);
}
// ...
}
Но такой подход плохо масштабируется. При добавлении новых серверов функция будет расти линейно, и внесение изменений превратится в кошмар. Объектно ориентированный подход заключается в выделении общего суперкласса MessageHandler и вынесение логики определения кода клиента в подклассы:
abstract class MessageHandler {
void handleMessage(Message msg) {
// ...
msg.setClientCode(getClientCode());
// ...
sendMessage(msg);
}
abstract String getClientCode();
// ...
}
class MessageHandlerOne extends MessageHandler {
String getClientCode() {
return "ABCD_123";
}
}
class MessageHandlerTwo extends MessageHandler {
String getClientCode() {
return "123_ABCD";
}
}
Теперь для каждого сервера мы можем создать экземпляр соответствующего класса. Добавление новых сервером становится более удобным. Но для такого небольшого изменения многовато текста. Пришлось создать два новых типа чтобы просто добавить поддержку различного кода клиента! Теперь сделаем тоже самое в нашем языке с поддержкой функций высшего порядка:
class MessageHandler {
void handleMessage(Message msg, Function getClientCode) {
// ...
Message msg1 = msg.setClientCode(getClientCode());
// ...
sendMessage(msg1);
}
// ...
}
String getClientCodeOne() {
return "ABCD_123";
}
String getClientCodeTwo() {
return "123_ABCD";
}
MessageHandler handler = new MessageHandler();
handler.handleMessage(someMsg, getClientCodeOne);
Мы не создавали новых типов и не усложняли иерархию классов. Мы просто передали функцию в качестве параметра. Мы достигли того же эффекта, как и в объектно-ориентированном аналоге, только с некоторыми преимуществами. Мы не привязывали себя к какой-либо иерархии классов: мы можем передавать любые другие функции в runtime и менять их в любой момент, сохраняя при этом высокий уровень модульности меньшим количеством кода. По сути компилятор создал объектно-ориентированный «клей» вместо нас! При этом сохраняются все остальные преимущества ФП. Конечно абстракции, предлагаемые функциональными языками на этом не заканчиваются. Функции высшего порядка это только начало
Каррирование
Большинство людей, с которыми я встречаюсь, прочли книгу «Паттерны проектирования» Банды Четырёх. Любой уважающий себя программист будет говорить, что книга не привязана к какому-либо конкретному языку программирования, а паттерны применимы к разработке ПО в целом. Это благородное заявление. Но к сожалению оно далеко от истины.
Функциональные языке невероятно выразительны. В функциональном языке вам не понадобятся паттерны проектирования, потому что язык настолько высокоуровневый, что вы легко начнёте программировать в концепциях, которые исключают все известные паттерны программирования. Одним из таких паттернов является Адаптер (чем он отличается от Фасада? Похоже, что кому-то понадобилось наштамповать побольше страниц, чтобы выполнить условия контракта). Этот паттерн оказывается ненужным если в языке есть поддержки каррирования.
Паттерн Адаптер наиболее часто применяется к «стандартной» единице абстракции в Java — классу. В функциональных языках паттерн применяется к функциям. Паттерн берёт интерфейс и преобразует его в другой интерфейс, согласно определённым требованиям. Вот пример паттерна Адаптер:
int pow(int i, int j);
int square(int i)
{
return pow(i, 2);
}
Этот код адаптирует интерфейс функции, возводящей число в произвольную степень, к интерфейсу функции, которая возводит число в квадрат. В аккадемических кругах этот простейший приём называется каррирование (в честь специалиста по логике Хаскелла Карри (Haskell Curry), который провёл ряд математических трюков, чтобы всё это формализовать). Так как в ФП функции используются повсеместно в качестве аргументов, каррирование используется очень часто, чтобы привести функции к интерфейсу, необходимому в том или ином месте. Так как интерфейс функции — это её аргументы, то каррирование используется для уменьшения количества аргументов (как в примере выше).
Этот инструмент является встроенным в функциональные языки. Вам не нужно вручную создавать функцию, которая оборачивает оригинал. Функциональный язык сделает всё за вас. Как обычно давайте расширим наш язык, добавив в него каррирование.
square = int pow(int i, 2);
Этой строкой мы автоматически создаём функцию возведения в квадрат с одним аргументом. Новая функция будет вызывать функцию pow, подставляя 2 в качестве второго аргумента. С точки зрения Java, это будет выглядеть следующим образом:
class square_function_t {
int square(int i) {
return pow(i, 2);
}
}
square_function_t square = new square_function_t();
Как видите, мы просто написали обёртку над оригинальной функцией. В ФП каррирование как раз и представляет из себя простой и удобный способ создания обёрток. Вы сосредотачиваетесь на задаче, а компилятор пишет необходимый код за вас! Всё очень просто, и происходит каждый раз, когда вы хотите использовать паттерн Адаптер (обёртку).
Ленивые вычисления
Ленивые (или отложенные) вычисления — это интересная техника, которая становится возможной как только вы усвоите функциональную философию. Мы уже встречали следующий кусок кода, когда говорили о многопоточности:
String s1 = somewhatLongOperation1();
String s2 = somewhatLongOperation2();
String s3 = concatenate(s1, s2);
В императивных языках программирования очерёдность вычисления не вызывает никаких вопросов. Поскольку каждая функция может повлиять или зависеть от внешнего состояния, то необходимо соблюдать чёткую очерёдность вызовов: сначала somewhatLongOperation1, затем somewhatLongOperation2, и concatenate в конце. Но не всё так просто в функциональных языках.
Как мы уже видели ранее somewhatLongOperation1 и somewhatLongOperation2 могут быть запущены одновременно, потому что функции гарантированно не влияют и не зависят от глобального состояния. Но что, если мы не хотим выполнять их одновременно, нужно ли вызывать их последовательно? Ответ — нет. Эти вычисления должны быть запущены, только если какая-либо другая функция зависит от s1 и s2. Нам даже не нужно выполнять их до тех пор, пока они понадобятся внутри concatenate. Если вместо concatenate мы подставим функцию, которая в зависимости от условия использует один аргумент из двух, то второй аргумент можно даже не вычислять! Haskell — это пример языка с отложенными вычислениями. В Haskell отсутствует гарантия какой-либо очередности вызовов (вообще!), потому что Haskell выполняет код по мере необходимости.
Ленивые вычисления обладают рядом достоинств как и некоторыми недостатками. В следующем разделе мы обсудим достоинства и я объясню как уживаться с недостатки.
Оптимизация
Ленивые вычисления обеспечивают громадный потенциал для оптимизаций. Ленивый компилятор рассматривает код в точности как математик изучает алгебраические выражения — он может отменять некоторые вещи, отменять выполнение тех или иных участков кода, менять очерёдность вызовов для большей эффективности, даже располагать код таким образом, чтобы уменьшить количество ошибок, при этом гарантируя целостность программы. Это самое большое преимущество при описании программы строгими формальными примитивами — код подчиняется математическим законам и может быть изучен математическими методами.
Абрстрагирование структур управления
Ленивые вычисления обеспечивают настолько высокий уровень абстракций, что становятся возможными удивительные вещи. Например представим себе реализацию следующей управляющей структуры:
unless(stock.isEuropean()) {
sendToSEC(stock);
}
Мы хотим, чтобы функция sendToSEC выполнялась только если фонд (stock) не европейский. Как можно реализовать unless? Без ленивый вычислений нам бы понадобилась система макросов, но в языках, подобных Haskell, это не обязательно. Мы можем объявить unless в виде функции!
void unless(boolean condition, List code) {
if(!condition)
code;
}
Заметьте, что code не будет выполняться, если condition == true. В строгих языках такое поведение невозможно повторить, так как аргументы будут вычислены прежде, чем unless будет вызвана.
Бесконечные структуры данных
Ленивые языки позволяют создавать бесконечные структуры данных, создание которых в строгих языках гораздо сложнее [пер. — только не в Python]. Например представьте себе последовательность Фибоначи. Очевидно, что мы не может вычислить бесконечный список за конечное время и при этом сохранить его в памяти. В строгих языках, таких как Java, мы просто написали бы функцию, которая возвращает произвольный член последовательности. В языках подобных Haskell мы можем абстрагироваться и просто объявить бесконечный список чисел Фибоначи. Так как язык ленивый, то будут вычислены лишь необходимые части списка, которые реально используются в программе. Это позволяет абстрагироваться от большого числа проблем и посмотреть на них с более высокого уровня (например можно использовать функции обработки списков на бесконечных последовательностях).
Недостатки
Конечно бесплатный сыр бывает только в мышеловке. Ленивые вычисления тянут за собой ряд недостатков. В основном это недостатки от лени. В реальности очень часто нужен прямой порядок вычислений. Возьмём, например, следующий код:
System.out.println("Please enter your name: ");
System.in.readLine();
В ленивом языке никто не гарантирует, что первая строка выполнится раньше второй! Это означает, что мы не можем делать ввод-вывод, не можем нормально использовать нативные функции (ведь их нужно вызывать в определённом порядке, чтобы учитывать их побочные эффекты), и не можем взаимодействовать с внешним миром! Если мы введём механизм для упорядочивания выполнения кода, то потеряем преимущество математической строгости кода (а следом потеряем все плюшки функционального программирования). К счастью ещё не всё потеряно. Математики взялись за работу и придумали несколько приёмов для того, чтобы убедится в правильном порядке выполняемых инструкций не потеряв функционального духа. Мы получили лучшее от двух миров! Такие приёмы включают в себя продолжения (continuation), монады (monads) и однозначная типизация (uniqueness typing). В данной статье мы поработаем с продолжениями, а монады и однозначную типизацию отложим до следующего раза. Занятно, что продолжения очень полезная штука, которая используется не только для задания строгого порядка вычислений. Об этом мы тоже поговорим.
Продолжения
Продолжения в программировании играют такую же роль, как «Код да Винчи» в человеческой истории: удивительное разоблачение величайшей тайны человечества. Ну, может не совсем так, но они точно срывают покровы, как в своё время вы научились брать корень из -1.
Когда мы рассматривали функции мы изучили лишь половину правда, ведь мы исходили из предположения, что функция возвращает значение в вызывающую её функцию. В этом смысле продолжение — это обобщение функций. Функция не обязательно должна возвращать управление в то место, откуда её вызвали, а может возвращать в любое место программы. «Продолжение» — это параметр, который мы может передать в функцию, чтобы указать точку возврата. Звучит намного страшнее, чем есть на самом деле. Давайте взглянем на следующий код:
int i = add(5, 10);
int j = square(i);
Функция add возвращает число 15, которое записывается в i, в том месте, где функция и была вызвана. Затем значение i используется при вызове square. Заметьте, что ленивый компилятор не может поменять очередность вычислений, ведь вторая строка зависит от результата первой. Мы можем переписать этот код с использованием Стиль Передачи Продолжения (Continuation Passing Style или CPS), когда add возвращает значение в функцию square.
int j = add(5, 10, square);
В таком случае add получает дополнительный аргумент — функцию, которая будет вызвана после того, как add закончит работать. В обоих примерах j будет равен 225.
В этом и заключается первый приём, позволяющий задать порядок выполнения двух выражений. Вернёмся к нашему примеру с вводом-выводом
System.out.println("Please enter your name: ");
System.in.readLine();
Эти две строки не зависят друг от друга, и компилятор волен поменять их порядок по своему хотению. Но если мы перепишем в CPS, то тем самым добавим нужную зависимость, и компилятору придётся проводить вычисления одно за другим!
System.out.println("Please enter your name: ", System.in.readLine);
В таком случае println должен будет вызвать readLine, передав ему свой результат, и вернуть результат readLine в конце. В таком виде мы можем быть уверены, что эти функции будут вызваны по очереди, и что readLine вообще вызовется (ведь компилятор ожидает получить результат последней операции). В случае Java println возвращает void. Но если бы возвращалось какое-либо абстрактное значение (которое может служить аргументом readLine), то это решило бы нашу проблему! Конечно выстраивание таких цепочек функций сильно ухудшает читаемость кода, но с этим можно бороться. Мы можем добавить в наш язык синтаксических плюшек, которые позволят нам писать выражения как обычно, а компилятор автоматически выстраивал бы вычисления в цепочки. Теперь мы можем проводить вычисления в любом порядке, не потеряв при этом достоинств ФП (включая возможность исследовать программу математическими методами)! Если вас это сбивает с толку, то помните, что функции — это всего лишь экземпляры класса с единственным членом. Перепишите наш пример так, чтобы println и readLine были экземплярами классов, так вам станет понятней.
Но на этом польза продолжений не заканчивается. Мы можем написать всю программу целиком используя CPS, чтобы каждая функция вызывалась с дополнительным параметром, продолжением, в которое передаётся результат. В принципе любую программу можно перевести на CPS, если воспринимать каждую функцию как частный случай продолжений. Такое преобразование можно произвести автоматически (в действительности многие компиляторы так и делают).
Как только мы переведём программу к CPS виду, становится ясно, что у каждой инструкции есть продолжение, функция в которую будет передаваться результат, что в обычной программе было бы точкой вызова. Возьмём любую инструкцию из последнего примера, например add(5,10). В программе, написанной в CPS виде, понятно что будет являться продолжением — это функция, которую add вызовет по окончанию работы. Но что будет продолжением в случае не-CPS программы? Мы, конечно, можем конвертировать программу в CPS, но нужно ли это?
Оказывается, что в этом нет необходимости. Посмотрите внимательно на наше CPS преобразование. Если вы начнёте писать компилятор для него, то обнаружите, что для CPS версии не нужен стек! Функции никогда ничего не возвращают, в традиционном понимании слова «return», они просто вызывают другую функцию, подставляя результат вычислений. Отпадает необходимость проталкивать (push) аргументы в стек перед каждым вызовом, а потом извлекать (pop) их обратно. Мы можем просто хранить аргументы в каком-либо фиксированном участке памяти и использовать jump вместо обычного вызова. Нам нет нужны хранить первоначальные аргументы, ведь они больше никогда не понадобятся, ведь функции ничего не возвращают!
Таким образом, программы в CPS стиле не нуждаются в стеке, но содержат дополнительный аргумент, в виде функции, которую нужно вызвать. Программы в не-CPS стиле лишены дополнительного аргумента, но используют стек. Что же хранится в стеке? Просто аргументы и указатель на участок памяти, куда должна вернуться функция. Ну как, вы уже догадались? В стеке храниться информация о продолжениях! Указатель на точку возврата в стеке — это то же самое, что и функция, которую нужно вызвать, в CPS программах! Чтобы выяснить, какое продолжение у add(5,10), достаточно взять из стека точку возврата.
Это было не трудно. Продолжение и указатель на точку возврата — это действительно одно и то же, только продолжение указывается явно, и по этому оно может отличаться от того места, где функция была вызвана. Если вы помните, что продолжение — это функция, а функция в нашем языке компилируется в экземпляр класса, то поймёте, что указатель на точку возврата в стеке и указатель на продолжение — это в действительности одно и то же, ведь наша функция (как экземпляр класса) — это всего лишь указатель. А значит, что в любой момент времени в вашей программы вы можете запросить текущее продолжение (по сути информацию из стека).
Хорошо, теперь мы уяснили, что же такое текущее продолжение. Что это значит? Если мы возьмём текущее продолжение и сохраним его где-нибудь, мы тем самым сохраним текущее состояние программы — заморозим её. Это похоже на режим гибернации ОС. В объекте продолжения хранится информация, необходимая для возобновления выполнения программы с той точки, когда был запрошен объект продолжения. Операционная система постоянно так делает с вашими программами, когда переключает контекст между потоками. Разница лишь в том, что всё находится под контролем ОС. Если вы запросите объект продолжения (в Scheme это делается вызовом функции call-with-current-continuation), то вы получите объект с текущим продолжением — стеком (или в случае CPS — функцией следующего вызова). Вы можете сохранить этот объект в переменную (или даже на диск). Если вы решите «перезапустить» программу с этим продолжением, то состояние вашей программы «преобразуется» к состоянию на момент взятия объекта продолжения. Это то же самое, как переключение к приостановленному потоку, или пробуждение ОС после гибернации. С тем исключением, что вы можете проделывать это много раз подряд. После пробуждения ОС информация о гибернации уничтожается. Если этого не делать, то можно было бы восстанавливать состояние ОС с одной и той же точки. Это почти как путешествие по времени. С продолжениями вы можете себе такое позволить!
В каких ситуациях продолжения будут полезны? Обычно если вы пытаетесь эмулировать состояние в системах лишенных такового по сути. Отличное применение продолжения нашли в Web-приложениях (например во фреймворке Seaside для языка Smalltalk). ASP.NET от Microsoft прикладывает огромные усилия, чтобы сохранять состояние между запросами, и облегчить вам жизнь. Если бы C# поддерживал продолжения, то сложность ASP.NET можно было бы уменьшить в два раза — достаточно было бы сохранять продолжение и восстанавливать его при следующем запросе. С точки зрения Web-программиста не было бы ни единого разрыва — программа продолжала бы свою работу со следующей строки! Продолжения — невероятно полезная абстракция для решения некоторых проблем. Учитывая то, что всё больше и больше традиционных толстых клиентов перемещаются в Web, важность продолжений будет со временем только расти.
Сопоставление с образцом (Pattern matching)
Сопоставление с образцом не такая уж новая или инновационная идея. На самом деле она имеет слабое отношение к функциональному программированию. Единственная причина, по которой его часто связывают с ФП, это то, что с некоторых пор в функциональных языках есть сопоставление с образцом, а в императивных — нет.
Давайте начнём наше знакомство с Pattern matching следующим примером. Вот функция вычисления чисел Фибоначи на Java:
int fib(int n) {
if(n == 0) return 1;
if(n == 1) return 1;
return fib(n - 2) + fib(n - 1);
}
А вот пример на Java-подобном языке с поддержкой Pattern matching-а
int fib(0) {
return 1;
}
int fib(1) {
return 1;
}
int fib(int n) {
return fib(n - 2) + fib(n - 1);
}
В чём разница? Компилятор реализует ветвление за нас.
Подумаешь, велика важность! Действительно важность не велика. Было подмечено, что большое количество функций содержат сложные switch конструкции (это отчасти верно для функциональных программ), и было принято решение выделить этот момент. Определение функции разбивается на несколько вариантов, и устанавливается паттерн на месте аргументов функции (это напоминает перегрузку методов). Когда происходит вызов функции, компилятор на лету сравнивает аргументы со всеми определениями и выбирает наиболее подходящий. Обычно выбор падает на самое специализированное определение функции. Например int fib(int n) может быть вызвана при n равном 1, но не будет, ведь int fib(1) — более специализированное определение.
Сопоставление с образцом обычно выглядит сложнее, чем в нашем примере. Например сложная система Pattern matching позволяет писать следующий код:
int f(int n < 10) { ... }
int f(int n) { ... }
Когда сопоставление с образцом может быть полезно? Список таких случаев на удивление очень большой! Каждый раз, когда вы используете сложные конструкции вложенных if, pattern matching может справиться лучше с меньшим количеством кода. В голову приходит хороший пример с функцией WndProc, которая реализуется в каждой Win32 программе (даже если она спрятана от программиста за высоким забором абстракций). Обычно сопоставление с образцом может даже проверять содержимое коллекций. Например, если вы передаёте массив в функцию, то вы можете отбирать все массивы, у которых первый элемент равен 1, а третий элемент больше 3.
Ещё одни преимуществом Pattern matching является то, что в случае внесения изменений вам не придётся копаться в одной огромной функции. Вам достаточно будет добавить (или изменить) некоторые определения функций. Тем самым мы избавляется от целого пласта паттернов из знаменитой книги Банды Четырёх. Чем сложнее и ветвистее условия, тем полезнее будет использовать Pattern matching. Как только вы начнёте их использовать, то удивитесь, как вы могли раньше без них обходится.
Замыкания
До сих пор мы обсуждали особенности ФП в контексте «чисто» функциональных языков — языков, которые являются реализацией лямбда исчисления и не содержат особенностей, противоречащих формальной системе Чёрча. Тем не менее, многие черты функциональных языков используются за пределами лямбда исчисления. Хотя реализация аксиоматической системы интересна с точки зрения программирования в терминах математических выражений, это не всегда может быть применимо на практике. Многие языки предпочитать использовать элементы функциональных языков не придерживаясь строгой функциональной доктрины. Некоторые такие языки (например Common Lisp) не требуют от переменных быть final — их значения можно менять. Они даже не требуют, чтобы функции зависели только от своих аргументов — функциям дозволенно обращаться к состоянию за пределом своей области видимости. Но при этом они включают в себя такие особенности, как функции высшего порядка. Передача функции в не-чистом языке немного отличается от аналогичной операции в пределах лямбда исчисления и требует наличия интересной особенности под названием: лексическое замыкание. Давайте взглянем на следующий пример. Помните, что в данном случае переменные не final и функция может обращаться к переменным за пределом своей области видимости:
Function makePowerFn(int power) {
int powerFn(int base) {
return pow(base, power);
}
return powerFn;
}
Function square = makePowerFn(2);
square(3); // returns 9
Функция make-power-fn возвращает функцию, которая принимает один аргумент и возводит его в определённую степень. Что произойдёт, когда мы попробуем вычислить square(3)? Переменная power находится вне области видимости powerFn, потому что makePowerFn уже завершилась, и её стек уничтожен. Как же тогда работает square? Язык должен каким-либо образом сохранить значение power, чтобы функция square могла работать. А что если мы создадим ещё одну функцию cube, которая возводит число в третью степень? Язык должен будет сохранять два значения power для каждой созданной в make-power-fn функции. Феномен хранения этих значений и называется замыканием. Замыкание не только сохраняет аргументы верхней функции. Например замыкание может выглядеть следующим образом:
Function makeIncrementer() {
int n = 0;
int increment() {
return ++n;
}
}
Function inc1 = makeIncrementer();
Function inc2 = makeIncrementer();
inc1(); // returns 1;
inc1(); // returns 2;
inc1(); // returns 3;
inc2(); // returns 1;
inc2(); // returns 2;
inc2(); // returns 3;
В процессе выполнения значения n сохраняются, и счётчики имеют доступ к ним. Более того у каждого счётчика своя копия n, не смотря на то, что они должны были исчезнуть после того, как функция makeIncrementer отработает. Как же компилятор умудряется это скомпилировать? Что происходит за кулисами замыканий? К счастью у нас есть волшебный пропуск.
Всё сделано достаточно логично. С первого взгляда ясно, что локальные переменные больше не подчиняются правилам области видимости и их время жизни не определено. Очевидно, что они больше не хранятся в стеке — их нужно держать в куче (heap) [8]. Замыкание, следовательно, сделано как обычная функция, которую мы обсуждали ранее, за исключением того, что в нём есть дополнительная ссылка на окружающие переменные:
class some_function_t {
SymbolTable parentScope;
// ...
}
Если замыкание обращается к переменной, которой нет в локальной области видимости, тогда оно принимает во внимание родительскую область. Вот и всё! Замыкание связывает функциональный мир с миром ООП. Каждый раз, когда вы создаёте класс, который хранит некоторое состояние, и передаёте его куда-то, вспомните про замыкания. Замыкание — это всего лишь объект, который создаёт «атрибуты» на лету, забирая их из области видимости, чтобы вам не пришлось делать это самим.
Что теперь?
Эта статья проходится лишь по верхушке айсберга Функционального Программирования. Вы можете копнуть глубже и увидеть нечто действительно большое, а в нашем случае ещё и хорошее. В будущем я планирую написать о теория категорий, монадах, функциональных структурах данных, системе типов в функциональных языках, функциональной многопоточности, функциональных базах данных, и ещё о многих вещах. Если у меня получится написать (и изучить в процессе) хотя бы о половине из этих тем, моя жизнь пройдёт не зря. А пока, Google — ваш верный друг.
Комментарии?
Если у вас есть вопросы, комментарии или предложения, черканите записочку на адрес coffeemug [собачка] gmail.com. Буду рад любым вашим отзывам.
Примечания
[1]. Когда я искал работу осенью 2005 года, я частенько задавал этот вопрос. Было очень занятно видеть пустой взгляд вместо ответа. Я-то думал, что за зарплату $300,000 у этих людей должно быть хорошее понимание всех доступных инструментов.
[2]. Этот вопрос неоднозначный. Физики и математики вынуждены признать, что нет ничего предельно ясного во вселенной, что можно было бы описать математически.
[3]. Я ненавидел уроки истории, которые предлагали только сухую хронологию дат, имён и событий. Для меня история — это жизни людей, которые изменили мир. Это те их личные причины, которая стоят за их действиями, и механизмы, которыми они оказывали влияние на миллионы душ. По этой причине исторический раздел этой статьи безнадёжно неполон. Здесь описываются только наиболее значимые люди и события.
[4]. Когда я только начинал изучать функциональное программирование, меня очень нервировал термин «лямбда», потому что я не мог до конца понять, что же он обозначает. В данном контексте лямбда — это функция. А греческая буква используется для удобства математической записи. Каждый раз, когда вы слышите «лямбда» в разговоре о функциональном программировании, переводите это про себя в «функцию».
[5]. Занимательно, что строки в Java не изменяются. Интересно было бы выяснить причину такого вероломства, но не будем отвлекаться.
[6]. Большинство компиляторов функциональных языков умеют оптимизировать рекурсивные функции превращая их в циклы по мере возможностей. Это называется оптимизация хвостовой рекурсии.
[7]. Обратное не всегда верно. Если иногда возможно доказать эквивалентность двух участков кода, но в общем случае это не возможно.
[8]. На самом деле это не медленнее, чем хранить в стеке, поскольку при использовании сборщика мусора выделение памяти занимает O(1) операций.
Автор: sheknitrtch
