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

ghci> Just 9 >>= (\x –> Just (x > 8))

Just True

Поскольку левым параметром функции >>=является значение в конструкторе Just, анонимная функция применяется к значению 9, и результатом становится значение Just True. Мы можем переписать это в нотации doследующим образом:

marySue :: Maybe Bool

marySue = do

x <���– Just 9

Just (x > 8)

Сравнивая оба варианта, легко увидеть, почему результатом всего монадического значения является результат последнего монадического значения в выражении doсо всеми предыдущими монадическими значениями, сцепленными с ним.

Инструкция нашего канатоходца может также быть выражена с использованием нотации do. Функции landLeftи landRightпринимают количество птиц и шест и производят шест, обёрнутый в Just. Исключение – это когда канатоходец соскальзывает, и тогда возвращается значение Nothing. Мы использовали операцию >>=для сцепления последовательных шагов, потому что каждый из них зависел от предыдущего и каждый обладал добавленным контекстом возможной неудачи. Здесь две птицы приземляются с левой стороны, затем две птицы – с правой, а потом одна птица – снова с левой:

routine :: Maybe Pole

routine = do

start <���– return (0, 0)

first <���– landLeft 2 start

second <���– landRight 2 first

landLeft 1 second

Давайте посмотрим, окончится ли это удачно для Пьера:

ghci> routine

Just (3,2)

Окончилось удачно!

Когда мы выполняли эти инструкции, явно записывая вызовы оператора >>=, мы обычно писали что-то вроде return (0, 0) >>= landLeft 2, потому что функция landLeftявляется функцией, которая возвращает значение типа Maybe. Однако при использовании выражения doкаждая строка должна представлять монадическое значение. Поэтому мы явно передаём предыдущее значение типа Poleфункциям landLeftи landRight. Если бы мы проверили образцы, к которым привязали наши значения типа Maybe, то startбыл бы равен (0, 0), firstбыл бы равен (2, 0)и т. д.

Поскольку выражения doзаписываются построчно, некоторым людям они могут показаться императивным кодом. Но эти выражения просто находятся в последовательности, поскольку каждое значение в каждой строке зависит от результатов выражений в предыдущих строках вместе с их контекстами (в данном случае контекстом является успешное либо неуспешное окончание их вычислений).

Ещё раз давайте взглянем на то, как выглядел бы этот кусок кода, если бы мы не использовали монадические стороны типа Maybe:

routine :: Maybe Pole

routine =

case Just (0, 0) of

Nothing –> Nothing

Just start –> case landLeft 2 start of

Nothing –> Nothing

Just first –> case landRight 2 first of

Nothing –> Nothing

Just second –> landLeft 1 second

Видите, как в случае успеха образец startполучает значение кортежа внутри Just (0, 0), образец firstполучает значение результата выполнения landLeft 2 startи т. д.?

Если мы хотим бросить Пьеру банановую кожуру в нотации do, можем сделать следующее:

routine :: Maybe Pole

routine = do

start <���– return (0, 0)

first <���– landLeft 2 start

Nothing

second <���– landRight 2 first

landLeft 1 second

Когда мы записываем в нотации doстроку, не связывая монадическое значение с помощью символа <���–, это похоже на помещение вызова функции >>за монадическим значением, результат которого мы хотим игнорировать. Мы помещаем монадическое значение в последовательность, но игнорируем его результат, так как нам неважно, чем он является. Плюс ко всему это красивее, чем записывать эквивалентную форму _ <���– Nothing.

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

Привязывая монадические значения к идентификаторам в нотации do, мы можем использовать сопоставление с образцом так же, как в выражениях letи параметрах функции. Вот пример сопоставления с образцом в выражении do:

justFirst :: Maybe Char

justFirst = do

(x:xs) <���– Just "привет"

return x

Мы используем сопоставление с образцом для получения первого символа строки "привет", а затем возвращаем его в качестве результата. Поэтому justFirstвозвращает значение Just 'п'.

Что если бы это сопоставление с образцом окончилось неуспешно? Когда сопоставление с образцом в функции оканчивается не успешно, происходит сопоставление со следующим образцом. Если сопоставление проходит по всем образцам для данной функции с невыполнением их условий, выдаётся ошибка и происходит аварийное завершение работы программы. С другой стороны, сопоставление с образцом, окончившееся неудачей в выражениях let, приводит к незамедлительному возникновению ошибки, потому что в выражениях letотсутствует механизм прохода к следующему образцу при невыполнении условия.

Когда сопоставление с образцом в выражении doзавершается неуспешно, функция fail(являющаяся частью класса типов Monad) позволяет ему вернуть в результате неудачу в контексте текущей монады, вместо того чтобы привести к аварийному завершению работы программы. Вот реализация функции по умолчанию:

fail :: (Monad m) => String –> m a

fail msg = error msg

Так что по умолчанию она действительно заставляет программу завершаться аварийно. Но монады, содержащие в себе контекст возможной неудачи (как тип Maybe), обычно реализуют её самостоятельно. Для типа Maybeона реализована следующим образом:

fail _ = Nothing

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

wopwop :: Maybe Char

wopwop = do

(x:xs) <���– Just ""