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

Функторы

Функтор — это просто такой класс для типов, к которым можно применить отображение (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 в принципе нет ничего, кроме типов, классов типов и функций для работы с ними, вы без труда разберетесь с ними самостоятельно. Не так ли?