Haskell, Lisp и многословие [закрыто]

Для тех из вас, кто имел опыт работы как с Haskell, так и с некоторыми разновидностями Lisp, мне любопытно, насколько «приятно» (если использовать ужасный термин) писать код на Haskell и Lisp.

Немного предыстории: сейчас я изучаю Haskell, раньше работал со Scheme и CL (и немного углубился в Clojure). Традиционно меня можно было считать поклонником динамических языков за их краткость и скорость. Я быстро влюбился в макросы Lisp, поскольку они дали мне еще один способ избежать многословия и шаблонности.

Я нахожу Haskell невероятно интересным, поскольку он знакомит меня со способами программирования, о существовании которых я не подозревал. В нем определенно есть некоторые аспекты, которые, как кажется, могут помочь в достижении гибкости, например, простота написания частичных функций. Однако меня немного беспокоит потеря макросов Lisp (я предполагаю, что теряю их; правда, я, возможно, просто еще не узнал о них?) И систему статической типизации.

Не мог бы кто-нибудь, кто сделал приличное количество кода в обоих мирах, прокомментировать, чем отличается опыт, что вы предпочитаете, и если это предпочтение является ситуативным?

Короткий ответ:

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

[Примечание: существует " Template Haskell ", который позволяет писать макросы так же, как в Lisp, но, строго говоря, вам никогда не понадобится .]

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

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

С другой стороны, программирование на Haskell намного менее интерактивно, чем на Lisp, и огромное количество отражений, присутствующих в таких языках, как Lisp, просто не соответствует статическому взгляду на мир, который предполагает Haskell. Поэтому доступные вам наборы инструментов для двух языков сильно различаются, но их трудно сравнивать друг с другом.

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

В Haskell меньше необходимости в метапрограммировании, чем в Common Lisp, потому что многое можно структурировать вокруг монад, а добавленный синтаксис делает встроенные DSL менее древовидными, но всегда есть Template Haskell, как упоминалось ShreevatsaR , и даже Liskell (семантика Haskell + Lisp синтаксис), если вам нравятся круглые скобки.

Что касается макросов, вот страница, на которой рассказывается об этом: Hello Haskell, Goodbye Lisp . Это объясняет точку зрения, согласно которой макросы в Haskell просто не нужны. Для сравнения прилагается небольшой пример.

Пример случая, когда требуется макрос LISP, чтобы избежать оценки обоих аргументов:

(defmacro doif (x y) `(if ,x ,y))

Пример случая, когда Haskell не оценивает систематически оба аргумента без необходимости в каком-либо макроопределении:

doif x y = if x then (Just y) else Nothing

И вуаля

Я программист на Common Lisp.

Некоторое время назад я попробовал Haskell, и в итоге я решил придерживаться CL.

Причины:

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

У Haskell, конечно, есть свои достоинства, и некоторые вещи он делает принципиально по-другому, но в долгосрочной перспективе он меня не решает.

В Haskell вы можете определить функцию if, что невозможно в LISP. Это возможно из-за лени, которая делает программы более модульными. В этой классической статье Джона Хьюза « Почему важны FP » объясняется, как лень улучшает компоновку.

Есть действительно интересные вещи, которых вы можете достичь в Лиспе с помощью громоздких (если возможно) макросов в Haskell. Возьмем, к примеру, макрос «memoize» (см. Главу 9 PAIP Питера Норвига). С его помощью вы можете определить функцию, например foo, а затем просто оценить (memoize 'foo), которая заменяет глобальное определение foo мемоизированной версией. Можете ли вы добиться того же эффекта в Haskell с помощью функций высшего порядка?

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