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

Nothing –> Nothing

Just pole2 –> case landLeft 2 pole2 of

Nothing –> Nothing

Just pole3 –> landLeft 1 pole3

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

Обратите внимание, каким образом реализация операции >>=для типа Maybeотражает именно эту логику, когда проверяется, равно ли значение Nothing, и действие производится на основе этих сведений. Если значение равно Nothing, она незамедлительно возвращает результат Nothing. Если значение не равно Nothing, она продолжает работу с тем, что находится внутри конструктора Just.

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

Монады в языке Haskell настолько полезны, что они обзавелись своим собственным синтаксисом, который называется « нотация do ». Вы уже познакомились с нотацией doв главе 8, когда мы использовали её для объединения нескольких действий ввода-вывода. Как оказывается, нотация doпредназначена не только для системы ввода-вывода, но может использоваться для любой монады. Её принцип остаётся прежним: последовательное «склеивание» монадических значений.

Рассмотрим этот знакомый пример монадического применения:

ghci> Just 3 >>= (\x –> Just (show x ++ "!"))

Just "3!"

Это мы уже проходили! Передача монадического значения функции, которая возвращает монадическое значение, – ничего особенного. Заметьте, как параметр xстановится равным значению 3внутри анонимной функции, когда мы выполняем код. Как только мы внутри этой анонимной функции, это просто обычное значение, а не монадическое. А что если бы у нас был ещё один вызов оператора >>=внутри этой функции? Посмотрите:

ghci> Just 3 >>= (\x –> Just "!" >>= (\y –> Just (show x ++ y)))

Just "3!"

Ага-а, вложенное использование операции >>=! Во внешней анонимной функции мы передаём значение Just "!"анонимной функции \y –> Just (show x ++ y). Внутри этой анонимной функции параметр yстановится равным "!". Параметр xпо-прежнему равен 3, потому что мы получили его из внешней анонимной функции. Всё это как будто напоминает мне о следующем выражении:

ghci> let x = 3; y = "!" in show x ++ y

"3!"

Главное отличие состоит в том, что значения в нашем примере с использованием оператора >>=являются монадическими. Это значения с контекстом неудачи. Мы можем заменить любое из них на неудачу:

ghci> Nothing >>= (\x –> Just "!" >>= (\y –> Just (show x ++ y))) Nothing

ghci> Just 3 >>= (\x –> Nothing >>= (\y –> Just (show x ++ y)))

Nothing

ghci> Just 3 >>= (\x –> Just "!" >>= (\y –> Nothing))

Nothing

В первой строке передача значения Nothingфункции естественным образом даёт в результате Nothing. Во второй строке мы передаём значение Just 3функции, и параметр xстановится равным 3. Но потом мы передаём значение Nothingвнутренней анонимной функции, и результатом становится Nothing, что заставляет внешнюю анонимную функцию тоже произвести Nothingв качестве своего результата. Это что-то вроде присвоения значений переменным в выражениях let, только значения, о которых идёт речь, являются монадическими.

Чтобы проиллюстрировать эту идею, давайте запишем следующие строки в сценарий так, чтобы каждое значение типа Maybeзанимало свою собственную строку:

foo :: Maybe String

foo = Just 3 >>= (\x –>

Just "!">>= (\y –>

Just (show x ++ y)))

Чтобы уберечь нас от написания всех этих раздражающих анонимных функций, язык Haskell предоставляет нам нотацию do. Она позволяет нам записать предыдущий кусок кода вот так:

foo :: Maybe String

foo = do

x <���– Just 3

y <���– Just "!"

Just (show x ++ y)

Могло показаться, что мы получили возможность временно извлекать сущности из значений типа Maybeбез необходимости проверять на каждом шагу, являются ли значения типа Maybeзначениями в конструкторе Justили значениями Nothing. Вот классно!.. Если какое-либо из значений, которые мы пытаемся извлечь, равно Nothing, всё выражение doв результате вернёт значение Nothing. Мы выдёргиваем наружу их значения (если таковые существуют) и перекладываем необходимость беспокойства о контексте, идущем с этими значениями, на плечи оператора >>=.

Выражения do– это просто другой синтаксис для сцепления монадических значений.

В выражении doкаждая строка, не являющаяся строкой let, является монадическим значением. Чтобы просмотреть её результат, мы используем символ <���–. Если у нас есть значение типа Maybe Stringи мы привязываем её к образцу с помощью символа <���–, этот образец будет иметь тип Stringтак же, как когда мы использовали операцию >>=для передачи монадических значений анонимным функциям.

Последнее монадическое значение в выражении do– такое как Just (show x ++ y)в этом примере – не может быть использовано с символом <���–для привязки его результата, потому что если бы мы преобразовали выражение doобратно в цепочку применений оператора >>=, это не имело бы смысла. Наоборот, результат последнего выражения является результатом всего склеенного монадического значения, учитывая возможную неудачу вычисления каждого из предыдущих монадических значений. Рассмотрите, например, следующую строку: