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

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представляет вычисление, которое могло окончиться неуспешно.

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