Записки программиста

Мы с вами уже перестали бояться монад, но всякие непонятные стрелочки в коде типа <>, <$>, <*> и <|> по-прежнему повергают нас в ужас. Сегодня мы выясним, что и здесь бояться особо нечего. Как и в случае с монадами, здесь имеют место быть обыкновенные классы типов и функции для работы с ними. Все просто.

Функторы

Функтор — это просто такой класс для типов, к которым можно применить отображение (map):

Для fmap должны выполняться следующие законы:

Следует отметить, что в GHC есть расширение DeriveFunctor, позволяющее писать deriving Functor.

Типичные функторы — это Maybe, Either и, конечно же, списки. Для списков fmap определен просто как map. Обратите внимание, что он не может быть определен как reverse . map g, потому что это нарушило бы первый закон. Кроме того, часто экземпляр класса типов Functor объявляется для различных контейнеров. Например, Data.Map также является функтором.

У функции fmap есть инфиксная форма:

Из любой монады можно получить функтор:

Или в do-нотации:

То есть, можно сказать, что любая монада автоматически также является и функтором. В том числе, это относится к монаде IO, что позволяет писать:

Тем не менее, в общем случае без явного объявления экземпляра класса типов никакого функтора из монады вы не получите.

Пока несложно, правда?

Аппликативные функторы

Функтор — это когда данные, обернутые в некоторый контейнер или контекст, мы можем отобразить (map) путем применения некой функции. Аппликативные функторы — это такой шаг вперед по сравнению с функторами. Здесь в контекст оборачиваются не только данные, но и функции:

На первый взгляд все это выглядит несколько запутанно, поэтому рассмотрим пример. Списки, Maybe, Either и другие хорошо знакомые нам типы являются аппликативными функторами. Вот как это работает на примере Maybe:

А вот пример со списками:

То есть, функция pure как бы оборачивает функцию в контекст, а <*> применяет функцию в контексте к данным в контексте. Использование операторов *> и <* на практике я встречал довольно редко, но, тем не менее, с ними можно столкнуться. Тут требуется небольшое пояснение.

Есть такая забавная функция const, принимающая два аргумента и всегда возвращающая первый:

Есть такой забавный фокус:

Если вам это сломало мозг, тут объясняется, как это работает. Это несложно.

По умолчанию <* и *> определены так:

Например:

Куда указывает стрелочка, то значение и остается. Ну и в соответствии с семантикой <*>, если один из аргументов является Nothing или пустым списком, то и в итоге получаем Nothing или пустой список.

Аппликативные функторы должны подчиняться следующим законам:

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

Синергия классов типов Functor и Applicative

Как вы, конечно же, заметили, Applicative является подклассом Functor. Это означает, что стрелочки <$> и <*> часто используются совместно. Допустим, у нас есть такая функция:

Теперь мы хотим применить ее к трем числам — x, y и z. Если хотя бы для одного числа функция возвращает Nothing, то и весь результат должен быть Nothing. Иначе мы должны вернуть Just (1 / x, 1 / y, 1 / z). Как мы помним, Maybe является монадой, что позволяет вместо всяких вложенных if, then, else написать:

Но есть способ еще лучше. Как вы наверняка уже знаете, в Haskell есть функции (,), (,,), (,,,), и так далее, принимающие N аргументов и возвращающие соответствующий кортеж из N элементов:

Держим в уме, что запись a -> b -> c -> (a, b, c) равносильна a -> (b -> c -> (a, b, c)).

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

Вместо четырех строчек кода в do-нотации мы обошлись всего лишь одной. Разве это не здорово?

Также имеются функции liftA2, liftA3 и так далее, делающие то же самое:

Приведенный паттерн довольно широко используется в Haskell, например, в библиотеке aeson, при работе с формами в различных веб-фреймворках и тд.

Дополнение: Тихо и незаметно Applicative стал суперклассом Monad.

Моноиды

Моноиды в Haskell используются вообще везде.

Моноид — это просто такая штука, которую можно «складывать» (mappend) с другими такими же штуками и у которой имеется нейтральный элемент (mempty), который при сложении с любым другим элементом дает этот же элемент.

У mappend есть более короткая запись:

Законы для моноидов:

Список является типичным моноидом. Для него mempty — это пустой список, а mappend — операция ++:

Еще моноидами являются Set’ы, Map’ы, Maybe, а также Text, BinaryString и их билдеры. Для многих типов можно объявить более одного экземпляра класса типов Monoid. Например, для чисел можно выбрать в качестве mempty и mappend как число 0 и операцию сложения, так и число 1 и операцию умножения. Эта проблема в Haskell решается путем объявления newtype’ов, в случае с числами это соответственно Sum и Product.

Заключение

Дополнительные материалы:

• Прекрасное объяснение, нафига вообще нужна вся эта возня с моноидами, функторами и так далее;
• Соответствующая глава в LYH обязательна к прочтению, в ней есть много интересного, что не написано в этом посте;
• Еще более углубленный материл вы найдете в 10-й главе «Building and Parsing Text» замечательной книги Beginning Haskell;
• Typeclassopedia — неисчерпаемый источник мудрости о классах типов в Haskell, одна только картинка о связи между ними просветляет;

Помимо названных, в Haskell есть еще много занятных классов типов. Например, Foldable, для всего, что может сворачиваться (fold), Traversable для всего, что можно обойти слева направо, Alternative, представляющий собой моноид над аппликативными функторами (та самая непонятная стрелочка <|>) и другие. Но теперь, когда вы уже окончательно поняли, что в Haskell в принципе нет ничего, кроме типов, классов типов и функций для работы с ними, вы без труда разберетесь с ними самостоятельно. Не так ли?

Метки: Haskell, Функциональное программирование.