Приступаем к типу Maybe

Теперь, когда у вас появилось хотя бы смутное представление о том, что такое монады, давайте внесём в это представление несколько большую определённость. К великому удивлению, тип Maybe является монадой. Здесь мы исследуем её чуть лучше, чтобы понять, как она работает в этой роли.

ПРИМЕЧАНИЕ. Убедитесь, что вы в настоящий момент понимаете, что такое аппликативные функторы (мы обсуждали их в главе 11). Вы должны хорошо разбираться в том, как работают различные экземпляры класса Applicative и какие виды вычислений они представляют. Для понимания монад вам понадобится развить уже имеющиеся знания об аппликативных функторах.

Значение типа Maybe a представляет значение типа a, но с прикреплённым контекстом возможной неудачи в вычислениях. Значение Just "дхарма" означает, что в нём имеется строка "дхарма". Значение Nothing представляет отсутствие значения, или, если вы посмотрите на строку как на результат вычисления, это говорит о том, что вычисление завершилось неуспешно.

Когда мы рассматривали тип Maybe как функтор, мы видели, что если нам нужно отобразить его с помощью функции, используя метод fmap, функция отображала содержимое, если это значение Just. В противном случае сохранялось значение Nothing, поскольку с помощью функции нечего отображать!

ghci> fmap (++"!") (Just "мудрость")

Just "мудрость!"

ghci> fmap (++"!") Nothing

Nothing

Тип Maybe функционирует в качестве аппликативного функтора аналогично. Однако при использовании аппликативных функторов сама функция находится в контексте наряду со значением, к которому она применяется. Тип Maybe является аппликативным функтором таким образом, что когда мы используем операцию <*> для применения функции внутри типа Maybe к значению, которое находится внутри типа Maybe, они оба должны быть значениями Just, чтобы результатом было значение Just; в противном случае результатом будет значение Nothing. Это имеет смысл. Если недостаёт функции либо значения, к которому вы её применяете, вы не можете ничего получить «из воздуха», поэтому вы должны распространить неудачу.

ghci> Just (+3) <*> Just 3

Just 6

ghci> Nothing <*> Just "алчность"

Nothing

ghci> Justord <*> Nothing

Nothing

Использование аппликативного стиля, чтобы обычные функции работали со значениями типа Maybe, действует аналогичным образом. Все значения должны быть значениями Just; в противном случае всё это напрасно (Nothing)!

ghci> max <$> Just 3 <*> Just 6

Just 6

ghci> max <$> Just 3 <*> Nothing

Nothing

А теперь давайте подумаем над тем, как бы мы использовали операцию >>= с типом Maybe. Операция >>= принимает монадическое значение и функцию, которая принимает обычное значение. Она возвращает монадическое значение и умудряется применить эту функцию к монадическому значению. Как она это делает, если функция принимает обычное значение? Ну, она должна принимать во внимание контекст этого монадического значения.

В данном случае операция >>= принимала бы значение типа Maybe a и функцию типа a –> Maybe b и каким-то образом применяла бы эту функцию к значению Maybe a. Чтобы понять, как она это делает, мы будем исходить из того, что тип Maybe является аппликативным функтором. Скажем, у нас есть анонимная функция x –> Just (x+1). Она принимает число, прибавляет к нему 1 и оборачивает его в конструктор Just:

ghci> (x –> Just (x+1)) 1

Just 2

ghci> (x –> Just (x+1)) 100

Just 101

Если мы передадим ей значение 1, она вернёт результат Just 2. Если мы дадим ей значение 100, результатом будет Just 101. Это выглядит очень просто. Но как нам передать этой функции значение типа Maybe? Если мы подумаем о том, как тип Maybe работает в качестве аппликативного функтора, ответить на этот вопрос будет довольно легко. Мы передаём функции значение Just, берём то, что находится внутри конструктора Just, и применяем к этому функцию. Если мы даём ей значение Nothing, то у нас остаётся функция, но к ней нечего (Nothing) применить. В этом случае давайте сделаем то же, что мы делали и прежде, и скажем, что результат равен Nothing.

Вместо того чтобы назвать функцию >>=, давайте пока назовём её applyMaybe. Она принимает значение типа Maybe a и функцию, которая возвращает значение типа Maybe b, и умудряется применить эту функцию к значению типа Maybe a. Вот она в исходном коде:

applyMaybe :: Maybe a –> (a –> Maybe b) –> Maybe b

applyMaybe Nothing f = Nothing

applyMaybe (Just x) f = f x

Теперь давайте с ней поиграем. Мы будем использовать её как инфиксную функцию так, чтобы значение типа Maybe было слева, а функция была справа:

ghci> Just 3 `applyMaybe` x –> Just (x+1)

Just 4

ghci> Just "смайлик" `applyMaybe` x –> Just (x ++ " :)")

Just "смайлик :)"

ghci> Nothing `applyMaybe` x –> Just (x+1)

Nothing

ghci> Nothing `applyMaybe` x –> Just (x ++ " :)")

Nothing

В данном примере, когда мы использовали функцию applyMaybe со значением Just и функцией, функция просто применялась к значению внутри конструктора Just. Когда мы попытались использовать её со значением Nothing, весь результат был равен Nothing. Что насчёт того, если функция возвращает Nothing? Давайте посмотрим:

ghci>Just 3 `applyMaybe` x –> if x > 2 then Just x else Nothing

Just 3

ghci> Just 1 `applyMaybe` x –> if x > 2 then Just x else Nothing

Nothing

Результаты оказались такими, каких мы и ждали! Если монадическое значение слева равно Nothing, то всё будет равно Nothing. А если функция справа возвращает значение Nothing, результатом опять будет Nothing. Это очень похоже на тот случай, когда мы использовали тип Maybe в качестве аппликативного функтора и в результате получали значение Nothing, если где-то в составе присутствовало значение Nothing.

Похоже, мы догадались, как взять причудливое значение, передать его функции, которая принимает обычное значение, и вернуть причудливое значение. Мы сделали это, помня, что значение типа Maybe представляет вычисление, которое могло окончиться неуспешно.

Вы можете спросить себя: «Чем это полезно?» Может показаться, что аппликативные функторы сильнее монад, поскольку аппликативные функторы позволяют нам взять обычную функцию и заставить её работать со значениями, имеющими контекст. В этой главе вы увидите, что монады, будучи усовершенствованными аппликативными функторами, тоже способны на такое. На самом деле они могут делать и кое-какие другие крутые вещи, на которые не способны аппликативные функторы.

Мы вернёмся к Maybe через минуту, но сначала давайте взглянем на класс типов, который относится к монадам.