Миран Липовача - Изучай Haskell во имя добра!

• Название: Изучай Haskell во имя добра!
• Автор: Миран Липовача
• Жанр: Программирование
• Год: 2012
• ISBN: 978-5-94074-749-9

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

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

Ещё одно необычное свойство Haskell состоит в том, что в этом языке придаётся особое значение рассуждениям о типах данных. Как следствие, вы помещаете больше внимания и меньше кода в ваши программы.

Вне зависимости от того, в каком направлении вы намерены двигаться, путешествуя в мире программирования, небольшой заход в страну Haskell себя оправдает. А если вы решите там остаться, то наверняка найдёте чем заняться и чему поучиться!

Эта книга поможет многим читателям найти свой путь к Haskell.

Отображения, монады, моноиды и другое!

Всё сказано в названии: «Изучай Хаскель во имя добра!» – весёлый иллюстрированный самоучитель по этому сложному функциональному языку.

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

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

Продираясь сквозь образные (и порой безумные) примеры автора, вы научитесь:

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

• Использовать волшебство «ленивости» Хаскеля для игры с бесконечными наборами данных.

• Организовывать свои программы, создавая собственные типы, классы типов и модули.

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

Нет лучшего способа изучить этот мощный язык, чем чтение «Изучай Хаскель во имя добра!», кроме, разве что, поедания мозга его создателей.

Миран Липовача (Miran Lipovača) изучает информатику в Любляне (Словения). Помимо его любви к Хаскелю, ему нравится заниматься боксом, играть на бас-гитаре и, конечно же, рисовать. У него есть увлечение танцующими скелетами и числом 71, а когда он проходит через автоматические двери, он притворяется, что на самом деле открывает их силой своей мысли.

---

ghci> fromIntegral (length [1,2,3,4]) + 3.2

7.2

Несколько заключительных слов о классах типов

Поскольку класс типа определяет абстрактный интерфейс, один и тот же тип данных может иметь экземпляры для различных классов, а для одного и того же класса могут быть определены экземпляры различных типов. Например, тип Char имеет экземпляры для многих классов, два из которых – Eq и Ord, поскольку мы можем сравнивать символы на равенство и располагать их в алфавитном порядке.

Иногда для типа данных должен быть определён экземпляр некоторого класса для того, чтобы имелась возможность определить для него экземпляр другого класса. Например, для определения экземпляра класса Ord необходимо предварительно иметь экземпляр класса Eq. Другими словами, наличие экземпляра класса Eq является предварительным (необходимым) условием для определения экземпляра класса Ord. Если поразмыслить, это вполне логично: раз уж допускается расположение неких значений в определённом порядке, то должна быть предусмотрена и возможность проверить их на равенство.

3 Синтаксис функций

Сопоставление с образцом

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

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

lucky :: Int -> String

lucky 7 = "СЧАСТЛИВОЕ ЧИСЛО 7!"

lucky x = "Прости, друг, повезёт в другой раз!"

Когда вы вызываете функцию lucky, производится проверка параметра на совпадение с заданными образцами в том порядке, в каком они были заданы. Когда проверка даст положительный результат, используется соответствующее тело функции. Единственный случай, когда число, переданное функции, удовлетворяет первому образцу, – когда оно равно семи. В противном случае проводится проверка на совпадение со следующим образцом. Следующий образец может быть успешно сопоставлен с любым числом; также он привязывает переданное число к переменной x.

Если в образце вместо реального значения (например, 7) пишут идентификатор, начинающийся со строчной буквы (например, x, y или myNumber), то этот образец будет сопоставлен любому переданному значению. Обратиться к сопоставленному значению в теле функции можно будет посредством введённого идентификатора.

Эта функция может быть реализована с использованием ключевого слова if. Ну а если нам потребуется написать функцию, которая называет цифры от 1 до 5 и выводит "Это число не в пределах от 1 до 5" для других чисел? Без сопоставления с образцом нам бы пришлось создать очень запутанное дерево условных выражений if – then – else. А вот что получится, если использовать сопоставление:

sayMe :: Int -> String

sayMe 1 = "Один!"

sayMe 2 = "Два!"

sayMe 3 = "Три!"

sayMe 4 = "Четыре!"

sayMe 5 = "Пять!"

sayMe x = "Это число не в пределах от 1 до 5"

Заметьте, что если бы мы переместили последнюю строку определения функции (образец в которой соответствует любому вводу) вверх, то функция всегда выводила бы "Это число не в пределах от 1 до 5", потому что невозможно было бы пройти дальше и провести проверку на совпадение с другими образцами.

Помните реализованную нами функцию факториала? Мы определили факториал числа n как произведение чисел [1..n]. Мы можем определить данную функцию рекурсивно, точно так же, как факториал определяется в математике. Начнём с того, что объявим факториал нуля равным единице.

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

factorial :: Integer -> Integer

factorial 0 = 1

factorial n = n * factorial (n – 1)

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

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

charName :: Char –> String

charName 'а' = "Артём"

charName 'б' = "Борис"

charName 'в' = "Виктор"

а затем попытаемся вызвать её с параметром, которого не ожидали. Произойдёт следующее:

ghci> charName 'а'

"Артём"

ghci> charName 'в'

"Виктор"

ghci> charName 'м'

"*** Exception: Non-exhaustive patterns in function charName

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

Сопоставление с парами

Сопоставление с образцом может быть использовано и для кортежей. Что если мы хотим создать функцию, которая принимает два двумерных вектора (представленных в форме пары) и складывает их? Чтобы сложить два вектора, нужно сложить их соответствующие координаты. Вот как мы написали бы такую функцию, если б не знали о сопоставлении с образцом:

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

addVectors a b = (fst a + fst b, snd a + snd b)

Это, конечно, сработает, но есть способ лучше. Давайте исправим функцию, чтобы она использовала сопоставление с образцом:

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

addVectors (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)

Так гораздо лучше. Теперь ясно, что параметры функции являются кортежами; к тому же компонентам кортежа сразу даны имена – это повышает читабельность. Заметьте, что мы сразу написали образец, соответствующий любым значениям. Тип функции addVectors в обоих случаях совпадает, так что мы гарантированно получим на входе две пары:

ghci> :t addVectors

addVectors :: (Double, Double) -> (Double, Double) -> (Double, Double)

Функции fst и snd извлекают компоненты пары. Но как быть с тройками? Увы, стандартных функций для этой цели не существует, однако мы можем создать свои:

first :: (a, b, c) –> a

first (x, _, _) = x

second :: (a, b, c) –> b

second (_, y, _) = y

third :: (a, b, c) –> c

third (_, _, z) = z

Символ _ имеет то же значение, что и в генераторах списков. Он означает, что нам не интересно значение на этом месте, так что мы просто пишем _.

Сопоставление со списками и генераторы списков

В генераторах списков тоже можно использовать сопоставление с образцом, например:

ghci> let xs = [(1,3), (4,3), (2,4), (5,3), (5,6), (3,1)]

ghci> [a+b | (a,b) <– xs]

[4,7,6,8,11,4]

Если сопоставление с образцом закончится неудачей для одного элемента списка, просто произойдёт переход к следующему элементу.

Списки сами по себе (то есть заданные прямо в тексте образца списковые литералы) могут быть использованы при сопоставлении с образцом. Вы можете проводить сравнение с пустым списком или с любым образцом, который включает оператор : и пустой список. Так как выражение [1,2,3] – это просто упрощённая запись выражения 1:2:3:[], можно использовать [1,2,3] как образец.

Образец вида (x:xs) связывает «голову» списка с x, а оставшуюся часть – с xs, даже если в списке всего один элемент; в этом случае xs – пустой список.

ПРИМЕЧАНИЕ. Образец (x:xs) используется очень часто, особенно с рекурсивными функциями. Образцы, в определении которых присутствует :, могут быть использованы только для списков длиной не менее единицы.

Если вы, скажем, хотите связать первые три элемента с переменными, а оставшиеся элементы списка – с другой переменной, то можете использовать что-то наподобие (x:y:z:zs). Образец сработает только для списков, содержащих не менее трёх элементов.