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

Это отчасти похоже на реализацию экземпляра для типа Maybe, только когда функция fmap применяется к значению, которое не представляет пустую коробку (значение CJust), мы не просто применяем функцию к содержимому, но и увеличиваем счётчик на 1. Пока вроде бы всё круто! Мы даже можем немного поиграть с этим:

ghci> fmap (++"-ха") (CJust 0 "хо")

CJust 1 "хо-ха"

ghci> fmap (++"-хе") (fmap (++"-ха") (CJust 0 "хо"))

CJust 2 "хо-ха-хе"

ghci> fmap (++"ля") CNothing

CNothing

Подчиняется ли этот тип законам функторов? Для того чтобы увидеть, что что-то не подчиняется закону, достаточно найти всего одно исключение.

ghci> fmap id (CJust 0 "ха-ха")

CJust 1 "ха-ха"

ghci> id (CJust 0 "ха-ха")

CJust 0 "ха-ха"

Как гласит первый закон функторов, если мы отобразим значение функтора с помощью функции id, это должно быть то же самое, что и просто вызов функции id с тем же значением функтора. Наш пример показывает, что это не относится к нашему функтору CMaybe. Хотя он и имеет экземпляр класса Functor, он не подчиняется данному закону функторов и, следовательно, не является функтором.

Поскольку тип CMaybe не является функтором, хотя он и притворяется таковым, использование его в качестве функтора может привести к неисправному коду. Когда мы используем функтор, не должно иметь значения, производим ли мы сначала композицию нескольких функций, а затем с её помощью отображаем значение функтора, или же просто отображаем значение функтора последовательно с помощью каждой функции. Но при использовании типа CMaybe это имеет значение, так как он следит, сколько раз его отобразили. Проблема!.. Если мы хотим, чтобы тип CMaybe подчинялся законам функторов, мы должны сделать так, чтобы поле типа Int не изменялось, когда используется функция fmap.

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

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

Использование аппликативных функторов

В этом разделе мы рассмотрим аппликативные функторы, которые являются расширенными функторами.

До настоящего времени мы были сосредоточены на отображении функторов с помощью функций, принимающих только один параметр. Но что происходит, когда мы отображаем функтор с помощью функции, которая принимает два параметра? Давайте рассмотрим пару конкретных примеров.

Если у нас есть Just 3, и мы выполняем выражение fmap (*) (Just 3), что мы получим? Из реализации экземпляра типа Maybe для класса Functor мы знаем, что если это значение Just, то функция будет применена к значению внутри Just. Следовательно, выполнение выражения fmap (*) (Just 3) вернёт Just ((*) 3), что может быть также записано в виде Just (3 *), если мы используем сечения. Интересно! Мы получаем функцию, обёрнутую в конструктор Just!

Вот ещё несколько функций внутри значений функторов:

ghci> :t fmap (++) (Just "эй")

fmap (++) (Just "эй") :: Maybe ([Char] –> [Char])

ghci> :t fmap compare (Just 'a')

fmap compare (Just 'a') :: Maybe (Char –> Ordering)

ghci> :t fmap compare "A LIST OF CHARS"

fmap compare "A LIST OF CHARS" :: [Char –> Ordering]

ghci> :t fmap (x y z –> x + y / z) [3,4,5,6]

fmap (x y z –> x + y / z) [3,4,5,6] :: (Fractional a) => [a –> a –> a]

Если мы отображаем список символов с помощью функции compare, которая имеет тип (Ord a) => a –> a –> Ordering, то получаем список функций типа Char –> Ordering, потому что функция compare частично применяется с помощью символов в списке. Это не список функций типа (Ord a) => a –> Ordering, так как первый идентификатор переменной типа a имел тип Char, а потому и второе вхождение a обязано принять то же самое значение – тип Char.

Мы видим, как, отображая значения функторов с помощью «многопараметрических» функций, мы получаем значения функторов, которые содержат внутри себя функции. А что теперь с ними делать?.. Мы можем, например, отображать их с помощью функций, которые принимают эти функции в качестве параметров – поскольку, что бы ни находилось в значении функтора, оно будет передано функции, с помощью которой мы его отображаем, в качестве параметра.

ghci> let a = fmap (*) [1,2,3,4]

ghci> :t a

a :: [Integer –> Integer]

ghci> fmap (f –> f 9) a

[9,18,27,36]

Но что если у нас есть значение функтора Just (3 *) и значение функтора Just 5, и мы хотим извлечь функцию из Just (3 *) и отобразить с её помощью Just 5? С обычными функторами у нас этого не получится, потому что они поддерживают только отображение имеющихся функторов с помощью обычных функций. Даже когда мы отображали функтор, содержащий функции, с помощью анонимной функции f –> f 9, мы делали именно это и только это. Но используя то, что предлагает нам функция fmap, мы не можем с помощью функции, которая находится внутри значения функтора, отобразить другое значение функтора. Мы могли бы произвести сопоставление конструктора Just по образцу для извлечения из него функции, а затем отобразить с её помощью Just 5, но мы ищем более общий и абстрактный подход, работающий с функторами.

Поприветствуйте аппликативные функторы

Итак, встречайте класс типов Applicative, находящийся в модуле Control.Applicative!.. Он определяет две функции: pure и <*>. Он не предоставляет реализации по умолчанию для какой-либо из этих функций, поэтому нам придётся определить их обе, если мы хотим, чтобы что-либо стало аппликативным функтором. Этот класс определён вот так:

class (Functor f) => Applicative f where

   pure :: a –> f a

   (<*>) :: f (a –> b) –> f a –> f b

Простое определение класса из трёх строк говорит нам о многом!.. Первая строка начинается с определения класса Applicative; также она вводит ограничение класса. Ограничение говорит, что если мы хотим определить для типа экземпляр класса Applicative, он, прежде всего, уже должен иметь экземпляр класса Functor. Вот почему, когда нам известно, что конструктор типа принадлежит классу Applicative, можно смело утверждать, что он также принадлежит классу Functor, так что мы можем применять к нему функцию fmap.

Первый метод, который он определяет, называется pure. Его сигнатура выглядит так: pure :: a –> f a. Идентификатор f играет здесь роль нашего экземпляра аппликативного функтора. Поскольку язык Haskell обладает очень хорошей системой типов и притом всё, что может делать функция, – это получать некоторые параметры и возвращать некоторое значение, мы можем многое сказать по объявлению типа, и данный тип – не исключение.

Функция pure должна принимать значение любого типа и возвращать аппликативное значение с этим значением внутри него. Словосочетание «внутри него» опять вызывает в памяти нашу аналогию с коробкой, хотя мы и видели, что она не всегда выдерживает проверку. Но тип a –> f a всё равно довольно нагляден. Мы берём значение и оборачиваем его в аппликативное значение, которое содержит в себе это значение в качестве результата. Лучший способ представить себе функцию pure – это сказать, что она берёт значение и помещает его в некий контекст по умолчанию (или чистый контекст) – минимальный контекст, который по-прежнему возвращает это значение.

Оператор <*> действительно интересен. У него вот такое определение типа:

f (a –> b) –> f a –> f b

Напоминает ли оно вам что-нибудь? Оно похоже на сигнатуру fmap :: (a –> b) –> f a –> f b. Вы можете воспринимать оператор <*> как разновидность расширенной функции fmap. Тогда как функция fmap принимает функцию и значение функтора и применяет функцию внутри значения функтора, оператор <*> принимает значение функтора, который содержит в себе функцию, и другой функтор – и извлекает эту функцию из первого функтора, затем отображая с её помощью второй.